Compositing overlap testing can throw layers into compositing when they should not be.
[WebKit-https.git] / Source / WebCore / rendering / RenderLayerCompositor.h
1 /*
2  * Copyright (C) 2009 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 RenderLayerCompositor_h
27 #define RenderLayerCompositor_h
28
29 #include "ChromeClient.h"
30 #include "RenderLayer.h"
31 #include "RenderLayerBacking.h"
32
33 namespace WebCore {
34
35 #define PROFILE_LAYER_REBUILD 0
36
37 class GraphicsLayer;
38 class RenderEmbeddedObject;
39 class RenderPart;
40 class ScrollingCoordinator;
41 #if ENABLE(VIDEO)
42 class RenderVideo;
43 #endif
44
45 enum CompositingUpdateType {
46     CompositingUpdateAfterLayoutOrStyleChange,
47     CompositingUpdateOnHitTest,
48     CompositingUpdateOnScroll
49 };
50
51 // RenderLayerCompositor manages the hierarchy of
52 // composited RenderLayers. It determines which RenderLayers
53 // become compositing, and creates and maintains a hierarchy of
54 // GraphicsLayers based on the RenderLayer painting order.
55 // 
56 // There is one RenderLayerCompositor per RenderView.
57
58 class RenderLayerCompositor : public GraphicsLayerClient {
59 public:
60     RenderLayerCompositor(RenderView*);
61     ~RenderLayerCompositor();
62
63     // Return true if this RenderView is in "compositing mode" (i.e. has one or more
64     // composited RenderLayers)
65     bool inCompositingMode() const { return m_compositing; }
66     // This will make a compositing layer at the root automatically, and hook up to
67     // the native view/window system.
68     void enableCompositingMode(bool enable = true);
69     
70     // Returns true if the accelerated compositing is enabled
71     bool hasAcceleratedCompositing() const { return m_hasAcceleratedCompositing; }
72
73     bool canRender3DTransforms() const;
74
75     // Copy the accelerated compositing related flags from Settings
76     void cacheAcceleratedCompositingFlags();
77
78     // Called when the layer hierarchy needs to be updated (compositing layers have been
79     // created, destroyed or re-parented).
80     void setCompositingLayersNeedRebuild(bool needRebuild = true);
81     bool compositingLayersNeedRebuild() const { return m_compositingLayersNeedRebuild; }
82
83     // Controls whether or not to consult geometry when deciding which layers need
84     // to be composited. Defaults to true.
85     void setCompositingConsultsOverlap(bool b) { m_compositingConsultsOverlap = b; }
86     bool compositingConsultsOverlap() const { return m_compositingConsultsOverlap; }
87     
88     // GraphicsLayers buffer state, which gets pushed to the underlying platform layers
89     // at specific times.
90     void scheduleLayerFlush();
91     void flushPendingLayerChanges(bool isFlushRoot = true);
92     
93     // flushPendingLayerChanges() flushes the entire GraphicsLayer tree, which can cross frame boundaries.
94     // This call returns the rootmost compositor that is being flushed (including self).
95     RenderLayerCompositor* enclosingCompositorFlushingLayers() const;
96
97     // Called when the GraphicsLayer for the given RenderLayer has flushed changes inside of flushPendingLayerChanges().
98     void didFlushChangesForLayer(RenderLayer*);
99     
100     // Rebuild the tree of compositing layers
101     void updateCompositingLayers(CompositingUpdateType = CompositingUpdateAfterLayoutOrStyleChange, RenderLayer* updateRoot = 0);
102     // This is only used when state changes and we do not exepect a style update or layout to happen soon (e.g. when
103     // we discover that an iframe is overlapped during painting).
104     void scheduleCompositingLayerUpdate();
105     
106     // Update the compositing state of the given layer. Returns true if that state changed.
107     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
108     bool updateLayerCompositingState(RenderLayer*, CompositingChangeRepaint = CompositingChangeRepaintNow);
109
110     // Update the geometry for compositing children of compositingAncestor.
111     void updateCompositingDescendantGeometry(RenderLayer* compositingAncestor, RenderLayer* layer, RenderLayerBacking::UpdateDepth);
112     
113     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
114     bool clippedByAncestor(RenderLayer*) const;
115     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
116     bool clipsCompositingDescendants(const RenderLayer*) const;
117
118     // Whether the given layer needs an extra 'contents' layer.
119     bool needsContentsCompositingLayer(const RenderLayer*) const;
120     // Return the bounding box required for compositing layer and its childern, relative to ancestorLayer.
121     // If layerBoundingBox is not 0, on return it contains the bounding box of this layer only.
122     IntRect calculateCompositedBounds(const RenderLayer*, const RenderLayer* ancestorLayer);
123
124     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
125     void repaintOnCompositingChange(RenderLayer*);
126     
127     // Notify us that a layer has been added or removed
128     void layerWasAdded(RenderLayer* parent, RenderLayer* child);
129     void layerWillBeRemoved(RenderLayer* parent, RenderLayer* child);
130
131     // Get the nearest ancestor layer that has overflow or clip, but is not a stacking context
132     RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer* layer) const;
133
134     // Repaint parts of all composited layers that intersect the given absolute rectangle.
135     void repaintCompositedLayersAbsoluteRect(const IntRect&);
136
137     RenderLayer* rootRenderLayer() const;
138     GraphicsLayer* rootGraphicsLayer() const;
139     GraphicsLayer* scrollLayer() const;
140
141     enum RootLayerAttachment {
142         RootLayerUnattached,
143         RootLayerAttachedViaChromeClient,
144         RootLayerAttachedViaEnclosingFrame
145     };
146
147     RootLayerAttachment rootLayerAttachment() const { return m_rootLayerAttachment; }
148     void updateRootLayerAttachment();
149     void updateRootLayerPosition();
150     
151     void didMoveOnscreen();
152     void willMoveOffscreen();
153
154     void clearBackingForAllLayers();
155     
156     void layerBecameComposited(const RenderLayer*) { ++m_compositedLayerCount; }
157     void layerBecameNonComposited(const RenderLayer*)
158     {
159         ASSERT(m_compositedLayerCount > 0);
160         --m_compositedLayerCount;
161     }
162     
163     void didStartAcceleratedAnimation(CSSPropertyID);
164     
165 #if ENABLE(VIDEO)
166     // Use by RenderVideo to ask if it should try to use accelerated compositing.
167     bool canAccelerateVideoRendering(RenderVideo*) const;
168 #endif
169
170     // Walk the tree looking for layers with 3d transforms. Useful in case you need
171     // to know if there is non-affine content, e.g. for drawing into an image.
172     bool has3DContent() const;
173     
174     // Most platforms connect compositing layer trees between iframes and their parent document.
175     // Some (currently just Mac) allow iframes to do their own compositing.
176     static bool allowsIndependentlyCompositedFrames(const FrameView*);
177     bool shouldPropagateCompositingToEnclosingFrame() const;
178
179     static RenderLayerCompositor* frameContentsCompositor(RenderPart*);
180     // Return true if the layers changed.
181     static bool parentFrameContentLayers(RenderPart*);
182
183     // Update the geometry of the layers used for clipping and scrolling in frames.
184     void frameViewDidChangeLocation(const IntPoint& contentsOffset);
185     void frameViewDidChangeSize();
186     void frameViewDidScroll();
187
188     String layerTreeAsText(bool showDebugInfo = false);
189
190     // These are named to avoid conflicts with the functions in GraphicsLayerClient
191     // These return the actual internal variables.
192     bool compositorShowDebugBorders() const { return m_showDebugBorders; }
193     bool compositorShowRepaintCounter() const { return m_showRepaintCounter; }
194
195     virtual float deviceScaleFactor() const;
196     virtual float pageScaleFactor() const;
197     virtual void didCommitChangesForLayer(const GraphicsLayer*) const;
198     
199     bool keepLayersPixelAligned() const;
200
201     void deviceOrPageScaleFactorChanged();
202
203     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
204     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
205     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
206 #if ENABLE(RUBBER_BANDING)
207     GraphicsLayer* layerForOverhangAreas() const { return m_layerForOverhangAreas.get(); }
208 #endif
209
210     void documentBackgroundColorDidChange();
211
212 private:
213     class OverlapMap;
214
215     // GraphicsLayerClient Implementation
216     virtual void notifyAnimationStarted(const GraphicsLayer*, double) { }
217     virtual void notifySyncRequired(const GraphicsLayer*) { scheduleLayerFlush(); }
218     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect&);
219
220     virtual bool showDebugBorders(const GraphicsLayer*) const;
221     virtual bool showRepaintCounter(const GraphicsLayer*) const;
222     
223     // Whether the given RL needs a compositing layer.
224     bool needsToBeComposited(const RenderLayer*) const;
225     // Whether the layer has an intrinsic need for compositing layer.
226     bool requiresCompositingLayer(const RenderLayer*) const;
227     // Whether the layer could ever be composited.
228     bool canBeComposited(const RenderLayer*) const;
229
230     // Make or destroy the backing for this layer; returns true if backing changed.
231     bool updateBacking(RenderLayer*, CompositingChangeRepaint shouldRepaint);
232
233     void clearBackingForLayerIncludingDescendants(RenderLayer*);
234
235     // Repaint the given rect (which is layer's coords), and regions of child layers that intersect that rect.
236     void recursiveRepaintLayerRect(RenderLayer*, const IntRect&);
237
238     void addToOverlapMap(OverlapMap&, RenderLayer*, IntRect& layerBounds, bool& boundsComputed);
239     void addToOverlapMapRecursive(OverlapMap&, RenderLayer*);
240
241     void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>*);
242
243     // Returns true if any layer's compositing changed
244     void computeCompositingRequirements(RenderLayer*, OverlapMap*, struct CompositingState&, bool& layersChanged);
245     
246     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
247     void rebuildCompositingLayerTree(RenderLayer*, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer);
248
249     // Recurses down the tree, updating layer geometry only.
250     void updateLayerTreeGeometry(RenderLayer*);
251     
252     // Hook compositing layers together
253     void setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer);
254     void removeCompositedChildren(RenderLayer*);
255
256     bool layerHas3DContent(const RenderLayer*) const;
257     bool hasNonIdentity3DTransform(RenderObject*) const;
258     
259     bool hasAnyAdditionalCompositedLayers(const RenderLayer* rootLayer) const;
260
261     void ensureRootLayer();
262     void destroyRootLayer();
263
264     void attachRootLayer(RootLayerAttachment);
265     void detachRootLayer();
266     
267     void rootLayerAttachmentChanged();
268
269     void updateOverflowControlsLayers();
270
271     void notifyIFramesOfCompositingChange();
272
273     bool isFlushingLayers() const { return m_flushingLayers; }
274
275     ScrollingCoordinator* scrollingCoordinator() const;
276
277     // Whether a running transition or animation enforces the need for a compositing layer.
278     bool requiresCompositingForAnimation(RenderObject*) const;
279     bool requiresCompositingForTransform(RenderObject*) const;
280     bool requiresCompositingForVideo(RenderObject*) const;
281     bool requiresCompositingForCanvas(RenderObject*) const;
282     bool requiresCompositingForPlugin(RenderObject*) const;
283     bool requiresCompositingForFrame(RenderObject*) const;
284     bool requiresCompositingWhenDescendantsAreCompositing(RenderObject*) const;
285     bool requiresCompositingForFullScreen(RenderObject*) const;
286     bool requiresCompositingForFilters(RenderObject*) const;
287     bool requiresCompositingForScrollableFrame() const;
288     bool requiresCompositingForPosition(RenderObject*, const RenderLayer*) const;
289
290     bool requiresScrollLayer(RootLayerAttachment) const;
291     bool requiresHorizontalScrollbarLayer() const;
292     bool requiresVerticalScrollbarLayer() const;
293     bool requiresScrollCornerLayer() const;
294 #if ENABLE(RUBBER_BANDING)
295     bool requiresOverhangAreasLayer() const;
296     bool requiresContentShadowLayer() const;
297 #endif
298
299 private:
300     RenderView* m_renderView;
301     OwnPtr<GraphicsLayer> m_rootContentLayer;
302     Timer<RenderLayerCompositor> m_updateCompositingLayersTimer;
303
304     bool m_hasAcceleratedCompositing;
305     ChromeClient::CompositingTriggerFlags m_compositingTriggers;
306
307     int m_compositedLayerCount;
308     bool m_showDebugBorders;
309     bool m_showRepaintCounter;
310     bool m_compositingConsultsOverlap;
311
312     // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
313     // because only then do we know the final size of plugins and iframes.
314     // FIXME: once set, this is never cleared.
315     mutable bool m_compositingDependsOnGeometry;
316
317     mutable bool m_compositingNeedsUpdate;
318
319     bool m_compositing;
320     bool m_compositingLayersNeedRebuild;
321     bool m_flushingLayers;
322     bool m_forceCompositingMode;
323
324     RootLayerAttachment m_rootLayerAttachment;
325
326     // Enclosing clipping layer for iframe content
327     OwnPtr<GraphicsLayer> m_clipLayer;
328     OwnPtr<GraphicsLayer> m_scrollLayer;
329
330     // Enclosing layer for overflow controls and the clipping layer
331     OwnPtr<GraphicsLayer> m_overflowControlsHostLayer;
332
333     // Layers for overflow controls
334     OwnPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
335     OwnPtr<GraphicsLayer> m_layerForVerticalScrollbar;
336     OwnPtr<GraphicsLayer> m_layerForScrollCorner;
337 #if ENABLE(RUBBER_BANDING)
338     OwnPtr<GraphicsLayer> m_layerForOverhangAreas;
339     OwnPtr<GraphicsLayer> m_contentShadowLayer;
340 #endif
341 #if PROFILE_LAYER_REBUILD
342     int m_rootLayerUpdateCount;
343 #endif
344 };
345
346
347 } // namespace WebCore
348
349 #endif // RenderLayerCompositor_h