Use background color for GraphicsLayers when applicable
[WebKit-https.git] / Source / WebCore / rendering / RenderLayerBacking.h
1 /*
2  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef RenderLayerBacking_h
27 #define RenderLayerBacking_h
28
29 #if USE(ACCELERATED_COMPOSITING)
30
31 #include "FloatPoint.h"
32 #include "FloatPoint3D.h"
33 #include "GraphicsLayer.h"
34 #include "GraphicsLayerClient.h"
35 #include "RenderLayer.h"
36 #include "TransformationMatrix.h"
37
38 namespace WebCore {
39
40 class KeyframeList;
41 class RenderLayerCompositor;
42 class TiledBacking;
43
44 enum CompositingLayerType {
45     NormalCompositingLayer, // non-tiled layer with backing store
46     TiledCompositingLayer, // tiled layer (always has backing store)
47     MediaCompositingLayer, // layer that contains an image, video, webGL or plugin
48     ContainerCompositingLayer // layer with no backing store
49 };
50
51 // RenderLayerBacking controls the compositing behavior for a single RenderLayer.
52 // It holds the various GraphicsLayers, and makes decisions about intra-layer rendering
53 // optimizations.
54 // 
55 // There is one RenderLayerBacking for each RenderLayer that is composited.
56
57 class RenderLayerBacking : public GraphicsLayerClient {
58     WTF_MAKE_NONCOPYABLE(RenderLayerBacking); WTF_MAKE_FAST_ALLOCATED;
59 public:
60     RenderLayerBacking(RenderLayer*);
61     ~RenderLayerBacking();
62
63     RenderLayer* owningLayer() const { return m_owningLayer; }
64
65     enum UpdateDepth { CompositingChildren, AllDescendants };
66     void updateAfterLayout(UpdateDepth, bool isUpdateRoot);
67     
68     // Returns true if layer configuration changed.
69     bool updateGraphicsLayerConfiguration();
70     // Update graphics layer position and bounds.
71     void updateGraphicsLayerGeometry(); // make private
72     // Update contents and clipping structure.
73     void updateDrawsContent();
74     
75     GraphicsLayer* graphicsLayer() const { return m_graphicsLayer.get(); }
76
77     // Layer to clip children
78     bool hasClippingLayer() const { return (m_containmentLayer && !m_usingTiledCacheLayer); }
79     GraphicsLayer* clippingLayer() const { return !m_usingTiledCacheLayer ? m_containmentLayer.get() : 0; }
80
81     // Layer to get clipped by ancestor
82     bool hasAncestorClippingLayer() const { return m_ancestorClippingLayer != 0; }
83     GraphicsLayer* ancestorClippingLayer() const { return m_ancestorClippingLayer.get(); }
84
85     bool hasContentsLayer() const { return m_foregroundLayer != 0; }
86     GraphicsLayer* foregroundLayer() const { return m_foregroundLayer.get(); }
87
88     bool hasScrollingLayer() const { return m_scrollingLayer; }
89     GraphicsLayer* scrollingLayer() const { return m_scrollingLayer.get(); }
90     GraphicsLayer* scrollingContentsLayer() const { return m_scrollingContentsLayer.get(); }
91
92     void attachToScrollingCoordinator(RenderLayerBacking* parent);
93     void detachFromScrollingCoordinator();
94     uint64_t scrollLayerID() const { return m_scrollLayerID; }
95     
96     bool hasMaskLayer() const { return m_maskLayer != 0; }
97
98     GraphicsLayer* parentForSublayers() const;
99     GraphicsLayer* childForSuperlayers() const { return m_ancestorClippingLayer ? m_ancestorClippingLayer.get() : m_graphicsLayer.get(); }
100
101     // RenderLayers with backing normally short-circuit paintLayer() because
102     // their content is rendered via callbacks from GraphicsLayer. However, the document
103     // layer is special, because it has a GraphicsLayer to act as a container for the GraphicsLayers
104     // for descendants, but its contents usually render into the window (in which case this returns true).
105     // This returns false for other layers, and when the document layer actually needs to paint into its backing store
106     // for some reason.
107     bool paintsIntoWindow() const;
108     
109     // Returns true for a composited layer that has no backing store of its own, so
110     // paints into some ancestor layer.
111     bool paintsIntoCompositedAncestor() const { return !m_requiresOwnBackingStore; }
112
113     void setRequiresOwnBackingStore(bool);
114
115     void setContentsNeedDisplay();
116     // r is in the coordinate space of the layer's render object
117     void setContentsNeedDisplayInRect(const IntRect&);
118
119     // Notification from the renderer that its content changed.
120     void contentChanged(ContentChangeType);
121
122     // Interface to start, finish, suspend and resume animations and transitions
123     bool startTransition(double, CSSPropertyID, const RenderStyle* fromStyle, const RenderStyle* toStyle);
124     void transitionPaused(double timeOffset, CSSPropertyID);
125     void transitionFinished(CSSPropertyID);
126
127     bool startAnimation(double timeOffset, const Animation* anim, const KeyframeList& keyframes);
128     void animationPaused(double timeOffset, const String& name);
129     void animationFinished(const String& name);
130
131     void suspendAnimations(double time = 0);
132     void resumeAnimations();
133
134     IntRect compositedBounds() const;
135     void setCompositedBounds(const IntRect&);
136     void updateCompositedBounds();
137     
138     void updateAfterWidgetResize();
139     void positionOverflowControlsLayers(const IntSize& offsetFromRoot);
140
141     bool usingTileCache() const { return m_usingTiledCacheLayer; }
142     TiledBacking* tiledBacking() const;
143     void adjustTileCacheCoverage();
144     
145     void updateDebugIndicators(bool showBorder, bool showRepaintCounter);
146     
147     // GraphicsLayerClient interface
148     virtual bool shouldUseTileCache(const GraphicsLayer*) const OVERRIDE;
149     virtual void notifyAnimationStarted(const GraphicsLayer*, double startTime) OVERRIDE;
150     virtual void notifyFlushRequired(const GraphicsLayer*) OVERRIDE;
151     virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) OVERRIDE;
152
153     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& clip) OVERRIDE;
154
155     virtual float deviceScaleFactor() const OVERRIDE;
156     virtual float pageScaleFactor() const OVERRIDE;
157     virtual void didCommitChangesForLayer(const GraphicsLayer*) const OVERRIDE;
158     virtual bool getCurrentTransform(const GraphicsLayer*, TransformationMatrix&) const OVERRIDE;
159
160     virtual bool isTrackingRepaints() const OVERRIDE;
161
162 #ifndef NDEBUG
163     virtual void verifyNotPainting();
164 #endif
165
166     IntRect contentsBox() const;
167     IntRect backgroundBox() const;
168     
169     // For informative purposes only.
170     CompositingLayerType compositingLayerType() const;
171     
172     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
173     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
174     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
175
176 #if ENABLE(CSS_FILTERS)
177     bool canCompositeFilters() const { return m_canCompositeFilters; }
178 #endif
179
180     // Return an estimate of the backing store area (in pixels) allocated by this object's GraphicsLayers.
181     double backingStoreMemoryEstimate() const;
182
183     String nameForLayer() const;
184     
185 #if ENABLE(CSS_COMPOSITING)
186     void setBlendMode(BlendMode);
187 #endif
188
189 private:
190     void createPrimaryGraphicsLayer();
191     void destroyGraphicsLayers();
192     
193     PassOwnPtr<GraphicsLayer> createGraphicsLayer(const String&);
194
195     RenderLayerModelObject* renderer() const { return m_owningLayer->renderer(); }
196     RenderLayerCompositor* compositor() const { return m_owningLayer->compositor(); }
197
198     void updateInternalHierarchy();
199     bool updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip);
200     bool updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer);
201     bool updateForegroundLayer(bool needsForegroundLayer);
202     bool updateMaskLayer(bool needsMaskLayer);
203     bool requiresHorizontalScrollbarLayer() const;
204     bool requiresVerticalScrollbarLayer() const;
205     bool requiresScrollCornerLayer() const;
206     bool updateScrollingLayers(bool scrollingLayers);
207     void updateDrawsContent(bool isSimpleContainer);
208
209     GraphicsLayerPaintingPhase paintingPhaseForPrimaryLayer() const;
210     
211     IntSize contentOffsetInCompostingLayer() const;
212     // Result is transform origin in pixels.
213     FloatPoint3D computeTransformOrigin(const IntRect& borderBox) const;
214     // Result is perspective origin in pixels.
215     FloatPoint computePerspectiveOrigin(const IntRect& borderBox) const;
216
217     void updateOpacity(const RenderStyle*);
218     void updateTransform(const RenderStyle*);
219 #if ENABLE(CSS_FILTERS)
220     void updateFilters(const RenderStyle*);
221 #endif
222 #if ENABLE(CSS_COMPOSITING)
223     void updateLayerBlendMode(const RenderStyle*);
224 #endif
225     // Return the opacity value that this layer should use for compositing.
226     float compositingOpacity(float rendererOpacity) const;
227     
228     bool isMainFrameRenderViewLayer() const;
229     
230     bool paintsBoxDecorations() const;
231     bool paintsChildren() const;
232
233     // Returns true if this compositing layer has no visible content.
234     bool isSimpleContainerCompositingLayer() const;
235     // Returns true if this layer has content that needs to be rendered by painting into the backing store.
236     bool containsPaintedContent() const;
237     // Returns true if the RenderLayer just contains an image that we can composite directly.
238     bool isDirectlyCompositedImage() const;
239     void updateImageContents();
240
241     Color rendererBackgroundColor() const;
242     void updateBackgroundColor(bool isSimpleContainer);
243     void updateContentsRect(bool isSimpleContainer);
244
245     bool containsNonEmptyRenderers() const;
246     bool hasVisibleNonCompositingDescendantLayers() const;
247
248     bool shouldClipCompositedBounds() const;
249
250     bool hasTileCacheFlatteningLayer() const { return (m_containmentLayer && m_usingTiledCacheLayer); }
251     GraphicsLayer* tileCacheFlatteningLayer() const { return m_usingTiledCacheLayer ? m_containmentLayer.get() : 0; }
252
253     void paintIntoLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase);
254
255     static CSSPropertyID graphicsLayerToCSSProperty(AnimatedPropertyID);
256     static AnimatedPropertyID cssToGraphicsLayerProperty(CSSPropertyID);
257
258     RenderLayer* m_owningLayer;
259
260     OwnPtr<GraphicsLayer> m_ancestorClippingLayer; // only used if we are clipped by an ancestor which is not a stacking context
261     OwnPtr<GraphicsLayer> m_graphicsLayer;
262     OwnPtr<GraphicsLayer> m_foregroundLayer;       // only used in cases where we need to draw the foreground separately
263     OwnPtr<GraphicsLayer> m_containmentLayer; // Only used if we have clipping on a stacking context with compositing children, or if the layer has a tile cache.
264     OwnPtr<GraphicsLayer> m_maskLayer;             // only used if we have a mask
265
266     OwnPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
267     OwnPtr<GraphicsLayer> m_layerForVerticalScrollbar;
268     OwnPtr<GraphicsLayer> m_layerForScrollCorner;
269
270     OwnPtr<GraphicsLayer> m_scrollingLayer; // only used if the layer is using composited scrolling.
271     OwnPtr<GraphicsLayer> m_scrollingContentsLayer; // only used if the layer is using composited scrolling.
272
273     uint64_t m_scrollLayerID;
274
275     IntRect m_compositedBounds;
276
277     bool m_artificiallyInflatedBounds;      // bounds had to be made non-zero to make transform-origin work
278     bool m_isMainFrameRenderViewLayer;
279     bool m_usingTiledCacheLayer;
280     bool m_requiresOwnBackingStore;
281 #if ENABLE(CSS_FILTERS)
282     bool m_canCompositeFilters;
283 #endif
284
285     static bool m_creatingPrimaryGraphicsLayer;
286 };
287
288 } // namespace WebCore
289
290 #endif // USE(ACCELERATED_COMPOSITING)
291
292 #endif // RenderLayerBacking_h