Rubber-banding should not affect the visibleRect of the TileCache
[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 "Frame.h"
31 #include "GraphicsLayerClient.h"
32 #include "GraphicsLayerUpdater.h"
33 #include "RenderLayer.h"
34 #include <wtf/HashMap.h>
35
36 namespace WebCore {
37
38 class FixedPositionViewportConstraints;
39 class GraphicsLayer;
40 class GraphicsLayerUpdater;
41 class RenderEmbeddedObject;
42 class RenderPart;
43 class ScrollingCoordinator;
44 class StickyPositionViewportConstraints;
45 #if ENABLE(VIDEO)
46 class RenderVideo;
47 #endif
48 class TiledBacking;
49
50 enum CompositingUpdateType {
51     CompositingUpdateAfterStyleChange,
52     CompositingUpdateAfterLayout,
53     CompositingUpdateOnHitTest,
54     CompositingUpdateOnScroll,
55     CompositingUpdateOnCompositedScroll
56 };
57
58 // RenderLayerCompositor manages the hierarchy of
59 // composited RenderLayers. It determines which RenderLayers
60 // become compositing, and creates and maintains a hierarchy of
61 // GraphicsLayers based on the RenderLayer painting order.
62 // 
63 // There is one RenderLayerCompositor per RenderView.
64
65 class RenderLayerCompositor : public GraphicsLayerClient, public GraphicsLayerUpdaterClient {
66     WTF_MAKE_FAST_ALLOCATED;
67 public:
68     explicit RenderLayerCompositor(RenderView*);
69     ~RenderLayerCompositor();
70
71     // Return true if this RenderView is in "compositing mode" (i.e. has one or more
72     // composited RenderLayers)
73     bool inCompositingMode() const { return m_compositing; }
74     // This will make a compositing layer at the root automatically, and hook up to
75     // the native view/window system.
76     void enableCompositingMode(bool enable = true);
77
78     bool inForcedCompositingMode() const { return m_forceCompositingMode; }
79
80     // Returns true if the accelerated compositing is enabled
81     bool hasAcceleratedCompositing() const { return m_hasAcceleratedCompositing; }
82
83     bool canRender3DTransforms() const;
84
85     // Copy the accelerated compositing related flags from Settings
86     void cacheAcceleratedCompositingFlags();
87
88     // Called when the layer hierarchy needs to be updated (compositing layers have been
89     // created, destroyed or re-parented).
90     void setCompositingLayersNeedRebuild(bool needRebuild = true);
91     bool compositingLayersNeedRebuild() const { return m_compositingLayersNeedRebuild; }
92
93     // Controls whether or not to consult geometry when deciding which layers need
94     // to be composited. Defaults to true.
95     void setCompositingConsultsOverlap(bool b) { m_compositingConsultsOverlap = b; }
96     bool compositingConsultsOverlap() const { return m_compositingConsultsOverlap; }
97     
98     // GraphicsLayers buffer state, which gets pushed to the underlying platform layers
99     // at specific times.
100     void scheduleLayerFlush();
101     void flushPendingLayerChanges(bool isFlushRoot = true);
102     
103     // flushPendingLayerChanges() flushes the entire GraphicsLayer tree, which can cross frame boundaries.
104     // This call returns the rootmost compositor that is being flushed (including self).
105     RenderLayerCompositor* enclosingCompositorFlushingLayers() const;
106
107     // Called when the GraphicsLayer for the given RenderLayer has flushed changes inside of flushPendingLayerChanges().
108     void didFlushChangesForLayer(RenderLayer*, const GraphicsLayer*);
109     
110     // Rebuild the tree of compositing layers
111     void updateCompositingLayers(CompositingUpdateType, RenderLayer* updateRoot = 0);
112     // This is only used when state changes and we do not exepect a style update or layout to happen soon (e.g. when
113     // we discover that an iframe is overlapped during painting).
114     void scheduleCompositingLayerUpdate();
115     
116     // Update the compositing state of the given layer. Returns true if that state changed.
117     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
118     bool updateLayerCompositingState(RenderLayer*, CompositingChangeRepaint = CompositingChangeRepaintNow);
119
120     // Update the geometry for compositing children of compositingAncestor.
121     void updateCompositingDescendantGeometry(RenderLayer* compositingAncestor, RenderLayer*, bool compositedChildrenOnly);
122     
123     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
124     bool clippedByAncestor(RenderLayer*) const;
125     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
126     bool clipsCompositingDescendants(const RenderLayer*) const;
127
128     // Whether the layer is fixed positioned to the view by an ancestor layer.
129     bool fixedPositionedByAncestor(const RenderLayer*) const;
130
131     // Whether the given layer needs an extra 'contents' layer.
132     bool needsContentsCompositingLayer(const RenderLayer*) const;
133
134     bool supportsFixedRootBackgroundCompositing() const;
135     bool needsFixedRootBackgroundLayer(const RenderLayer*) const;
136     GraphicsLayer* fixedRootBackgroundLayer() const;
137     
138     // Return the bounding box required for compositing layer and its childern, relative to ancestorLayer.
139     // If layerBoundingBox is not 0, on return it contains the bounding box of this layer only.
140     IntRect calculateCompositedBounds(const RenderLayer*, const RenderLayer* ancestorLayer) const;
141
142     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
143     void repaintOnCompositingChange(RenderLayer*);
144     
145     void repaintInCompositedAncestor(RenderLayer*, const LayoutRect&);
146     
147     // Notify us that a layer has been added or removed
148     void layerWasAdded(RenderLayer* parent, RenderLayer* child);
149     void layerWillBeRemoved(RenderLayer* parent, RenderLayer* child);
150
151     // Get the nearest ancestor layer that has overflow or clip, but is not a stacking context
152     RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer* layer) const;
153
154     // Repaint parts of all composited layers that intersect the given absolute rectangle (or the entire layer if the pointer is null).
155     void repaintCompositedLayers(const IntRect* = 0);
156
157     // Returns true if the given layer needs it own backing store.
158     bool requiresOwnBackingStore(const RenderLayer*, const RenderLayer* compositingAncestorLayer) const;
159
160     RenderLayer* rootRenderLayer() const;
161     GraphicsLayer* rootGraphicsLayer() const;
162     GraphicsLayer* scrollLayer() const;
163
164     enum RootLayerAttachment {
165         RootLayerUnattached,
166         RootLayerAttachedViaChromeClient,
167         RootLayerAttachedViaEnclosingFrame
168     };
169
170     RootLayerAttachment rootLayerAttachment() const { return m_rootLayerAttachment; }
171     void updateRootLayerAttachment();
172     void updateRootLayerPosition();
173     
174     void didMoveOnscreen();
175     void willMoveOffscreen();
176
177     void clearBackingForAllLayers();
178     
179     void layerBecameComposited(const RenderLayer*) { ++m_compositedLayerCount; }
180     void layerBecameNonComposited(const RenderLayer*);
181     
182 #if ENABLE(VIDEO)
183     // Use by RenderVideo to ask if it should try to use accelerated compositing.
184     bool canAccelerateVideoRendering(RenderVideo*) const;
185 #endif
186
187     // Walk the tree looking for layers with 3d transforms. Useful in case you need
188     // to know if there is non-affine content, e.g. for drawing into an image.
189     bool has3DContent() const;
190     
191     // Most platforms connect compositing layer trees between iframes and their parent document.
192     // Some (currently just Mac) allow iframes to do their own compositing.
193     static bool allowsIndependentlyCompositedFrames(const FrameView*);
194     bool shouldPropagateCompositingToEnclosingFrame() const;
195
196     static RenderLayerCompositor* frameContentsCompositor(RenderPart*);
197     // Return true if the layers changed.
198     static bool parentFrameContentLayers(RenderPart*);
199
200     // Update the geometry of the layers used for clipping and scrolling in frames.
201     void frameViewDidChangeLocation(const IntPoint& contentsOffset);
202     void frameViewDidChangeSize();
203     void frameViewDidScroll();
204     void frameViewDidLayout();
205     void rootFixedBackgroundsChanged();
206
207     void scrollingLayerDidChange(RenderLayer*);
208     void fixedRootBackgroundLayerChanged();
209
210     String layerTreeAsText(LayerTreeFlags);
211
212     virtual float deviceScaleFactor() const OVERRIDE;
213     virtual float pageScaleFactor() const OVERRIDE;
214     virtual void didCommitChangesForLayer(const GraphicsLayer*) const OVERRIDE;
215     virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) OVERRIDE;
216     
217     bool keepLayersPixelAligned() const;
218     bool acceleratedDrawingEnabled() const { return m_acceleratedDrawingEnabled; }
219
220     void deviceOrPageScaleFactorChanged();
221
222     void windowScreenDidChange(PlatformDisplayID);
223
224     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
225     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
226     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
227 #if ENABLE(RUBBER_BANDING)
228     GraphicsLayer* layerForOverhangAreas() const { return m_layerForOverhangAreas.get(); }
229 #endif
230
231     void updateViewportConstraintStatus(RenderLayer*);
232     void removeViewportConstrainedLayer(RenderLayer*);
233
234     void resetTrackedRepaintRects();
235     void setTracksRepaints(bool);
236
237     void reportMemoryUsage(MemoryObjectInfo*) const;
238     void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
239
240 private:
241     class OverlapMap;
242
243     // GraphicsLayerClient implementation
244     virtual void notifyAnimationStarted(const GraphicsLayer*, double) OVERRIDE { }
245     virtual void notifyFlushRequired(const GraphicsLayer*) OVERRIDE { scheduleLayerFlush(); }
246     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect&) OVERRIDE;
247
248     virtual bool isTrackingRepaints() const OVERRIDE;
249     
250     // GraphicsLayerUpdaterClient implementation
251     virtual void flushLayers(GraphicsLayerUpdater*) OVERRIDE;
252     virtual void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const OVERRIDE;
253     
254     // Whether the given RL needs a compositing layer.
255     bool needsToBeComposited(const RenderLayer*, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
256     // Whether the layer has an intrinsic need for compositing layer.
257     bool requiresCompositingLayer(const RenderLayer*, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
258     // Whether the layer could ever be composited.
259     bool canBeComposited(const RenderLayer*) const;
260
261     // Make or destroy the backing for this layer; returns true if backing changed.
262     bool updateBacking(RenderLayer*, CompositingChangeRepaint shouldRepaint);
263
264     void clearBackingForLayerIncludingDescendants(RenderLayer*);
265
266     // Repaint the given rect (which is layer's coords), and regions of child layers that intersect that rect.
267     void recursiveRepaintLayer(RenderLayer*, const IntRect* = 0);
268
269     void addToOverlapMap(OverlapMap&, RenderLayer*, IntRect& layerBounds, bool& boundsComputed);
270     void addToOverlapMapRecursive(OverlapMap&, RenderLayer*, RenderLayer* ancestorLayer = 0);
271
272     void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>*);
273
274     // Returns true if any layer's compositing changed
275     void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer*, OverlapMap*, struct CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
276     
277     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
278     void rebuildCompositingLayerTree(RenderLayer*, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
279
280     // Recurses down the tree, updating layer geometry only.
281     void updateLayerTreeGeometry(RenderLayer*, int depth);
282     
283     // Hook compositing layers together
284     void setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer);
285     void removeCompositedChildren(RenderLayer*);
286
287     bool layerHas3DContent(const RenderLayer*) const;
288     bool isRunningAcceleratedTransformAnimation(RenderObject*) const;
289
290     bool hasAnyAdditionalCompositedLayers(const RenderLayer* rootLayer) const;
291
292     void ensureRootLayer();
293     void destroyRootLayer();
294
295     void attachRootLayer(RootLayerAttachment);
296     void detachRootLayer();
297     
298     void rootLayerAttachmentChanged();
299
300     void updateOverflowControlsLayers();
301
302     void notifyIFramesOfCompositingChange();
303
304     bool isFlushingLayers() const { return m_flushingLayers; }
305     
306     Page* page() const;
307     TiledBacking* pageTiledBacking() const;
308
309     GraphicsLayerFactory* graphicsLayerFactory() const;
310     ScrollingCoordinator* scrollingCoordinator() const;
311
312     // Whether a running transition or animation enforces the need for a compositing layer.
313     bool requiresCompositingForAnimation(RenderObject*) const;
314     bool requiresCompositingForTransform(RenderObject*) const;
315     bool requiresCompositingForVideo(RenderObject*) const;
316     bool requiresCompositingForCanvas(RenderObject*) const;
317     bool requiresCompositingForPlugin(RenderObject*) const;
318     bool requiresCompositingForFrame(RenderObject*) const;
319     bool requiresCompositingForFilters(RenderObject*) const;
320     bool requiresCompositingForBlending(RenderObject* renderer) const;
321     bool requiresCompositingForScrollableFrame() const;
322     bool requiresCompositingForPosition(RenderObject*, const RenderLayer*, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
323     bool requiresCompositingForOverflowScrolling(const RenderLayer*) const;
324     bool requiresCompositingForIndirectReason(RenderObject*, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
325
326     void addViewportConstrainedLayer(RenderLayer*);
327     void registerOrUpdateViewportConstrainedLayer(RenderLayer*);
328     void unregisterViewportConstrainedLayer(RenderLayer*);
329
330     FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer*) const;
331     StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer*) const;
332
333     bool requiresScrollLayer(RootLayerAttachment) const;
334     bool requiresHorizontalScrollbarLayer() const;
335     bool requiresVerticalScrollbarLayer() const;
336     bool requiresScrollCornerLayer() const;
337 #if ENABLE(RUBBER_BANDING)
338     bool requiresOverhangAreasLayer() const;
339     bool requiresContentShadowLayer() const;
340 #endif
341
342 #if !LOG_DISABLED
343     const char* reasonForCompositing(const RenderLayer*);
344     void logLayerInfo(const RenderLayer*, int depth);
345 #endif
346
347 private:
348     RenderView* m_renderView;
349     OwnPtr<GraphicsLayer> m_rootContentLayer;
350     Timer<RenderLayerCompositor> m_updateCompositingLayersTimer;
351
352     bool m_hasAcceleratedCompositing;
353     ChromeClient::CompositingTriggerFlags m_compositingTriggers;
354
355     int m_compositedLayerCount;
356     bool m_showDebugBorders;
357     bool m_showRepaintCounter;
358     bool m_acceleratedDrawingEnabled;
359     bool m_compositingConsultsOverlap;
360
361     // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
362     // because only then do we know the final size of plugins and iframes.
363     mutable bool m_reevaluateCompositingAfterLayout;
364
365     bool m_compositing;
366     bool m_compositingLayersNeedRebuild;
367     bool m_flushingLayers;
368     bool m_shouldFlushOnReattach;
369     bool m_forceCompositingMode;
370     bool m_inPostLayoutUpdate; // true when it's OK to trust layout information (e.g. layer sizes and positions)
371
372     bool m_isTrackingRepaints; // Used for testing.
373
374     RootLayerAttachment m_rootLayerAttachment;
375
376     // Enclosing clipping layer for iframe content
377     OwnPtr<GraphicsLayer> m_clipLayer;
378     OwnPtr<GraphicsLayer> m_scrollLayer;
379
380     HashSet<RenderLayer*> m_viewportConstrainedLayers;
381     HashSet<RenderLayer*> m_viewportConstrainedLayersNeedingUpdate;
382
383     // Enclosing layer for overflow controls and the clipping layer
384     OwnPtr<GraphicsLayer> m_overflowControlsHostLayer;
385
386     // Layers for overflow controls
387     OwnPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
388     OwnPtr<GraphicsLayer> m_layerForVerticalScrollbar;
389     OwnPtr<GraphicsLayer> m_layerForScrollCorner;
390 #if ENABLE(RUBBER_BANDING)
391     OwnPtr<GraphicsLayer> m_layerForOverhangAreas;
392     OwnPtr<GraphicsLayer> m_contentShadowLayer;
393 #endif
394
395     OwnPtr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
396
397 #if !LOG_DISABLED
398     int m_rootLayerUpdateCount;
399     int m_obligateCompositedLayerCount; // count of layer that have to be composited.
400     int m_secondaryCompositedLayerCount; // count of layers that have to be composited because of stacking or overlap.
401     double m_obligatoryBackingStoreBytes;
402     double m_secondaryBackingStoreBytes;
403 #endif
404 };
405
406
407 } // namespace WebCore
408
409 #endif // RenderLayerCompositor_h