5916589f4a907388509326db0cf95a442dae7f89
[WebKit-https.git] / Source / WebCore / rendering / RenderLayerCompositor.h
1 /*
2  * Copyright (C) 2009, 2013 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 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 "GraphicsLayerClient.h"
31 #include "GraphicsLayerUpdater.h"
32 #include "RenderLayer.h"
33 #include <wtf/HashMap.h>
34
35 namespace WebCore {
36
37 class FixedPositionViewportConstraints;
38 class GraphicsLayer;
39 class GraphicsLayerUpdater;
40 class RenderEmbeddedObject;
41 class RenderNamedFlowFragment;
42 class RenderVideo;
43 class RenderWidget;
44 class ScrollingCoordinator;
45 class StickyPositionViewportConstraints;
46 class TiledBacking;
47
48 typedef unsigned LayerTreeFlags;
49
50 enum CompositingUpdateType {
51     CompositingUpdateAfterStyleChange,
52     CompositingUpdateAfterLayout,
53     CompositingUpdateOnHitTest,
54     CompositingUpdateOnScroll,
55     CompositingUpdateOnCompositedScroll
56 };
57
58 enum {
59     CompositingReasonNone                                   = 0,
60     CompositingReason3DTransform                            = 1 << 0,
61     CompositingReasonVideo                                  = 1 << 1,
62     CompositingReasonCanvas                                 = 1 << 2,
63     CompositingReasonPlugin                                 = 1 << 3,
64     CompositingReasonIFrame                                 = 1 << 4,
65     CompositingReasonBackfaceVisibilityHidden               = 1 << 5,
66     CompositingReasonClipsCompositingDescendants            = 1 << 6,
67     CompositingReasonAnimation                              = 1 << 7,
68     CompositingReasonFilters                                = 1 << 8,
69     CompositingReasonPositionFixed                          = 1 << 9,
70     CompositingReasonPositionSticky                         = 1 << 10,
71     CompositingReasonOverflowScrollingTouch                 = 1 << 11,
72     CompositingReasonStacking                               = 1 << 12,
73     CompositingReasonOverlap                                = 1 << 13,
74     CompositingReasonNegativeZIndexChildren                 = 1 << 14,
75     CompositingReasonTransformWithCompositedDescendants     = 1 << 15,
76     CompositingReasonOpacityWithCompositedDescendants       = 1 << 16,
77     CompositingReasonMaskWithCompositedDescendants          = 1 << 17,
78     CompositingReasonReflectionWithCompositedDescendants    = 1 << 18,
79     CompositingReasonFilterWithCompositedDescendants        = 1 << 19,
80     CompositingReasonBlendingWithCompositedDescendants      = 1 << 20,
81     CompositingReasonPerspective                            = 1 << 21,
82     CompositingReasonPreserve3D                             = 1 << 22,
83     CompositingReasonRoot                                   = 1 << 23,
84     CompositingReasonIsolatesCompositedBlendingDescendants  = 1 << 24,
85 };
86 typedef unsigned CompositingReasons;
87
88 // RenderLayerCompositor manages the hierarchy of
89 // composited RenderLayers. It determines which RenderLayers
90 // become compositing, and creates and maintains a hierarchy of
91 // GraphicsLayers based on the RenderLayer painting order.
92 // 
93 // There is one RenderLayerCompositor per RenderView.
94
95 class RenderLayerCompositor : public GraphicsLayerClient, public GraphicsLayerUpdaterClient {
96     WTF_MAKE_FAST_ALLOCATED;
97 public:
98     explicit RenderLayerCompositor(RenderView&);
99     ~RenderLayerCompositor();
100
101     // Return true if this RenderView is in "compositing mode" (i.e. has one or more
102     // composited RenderLayers)
103     bool inCompositingMode() const { return m_compositing; }
104     // This will make a compositing layer at the root automatically, and hook up to
105     // the native view/window system.
106     void enableCompositingMode(bool enable = true);
107
108     bool inForcedCompositingMode() const { return m_forceCompositingMode; }
109
110     // Returns true if the accelerated compositing is enabled
111     bool hasAcceleratedCompositing() const { return m_hasAcceleratedCompositing; }
112
113     bool canRender3DTransforms() const;
114
115     // Copy the accelerated compositing related flags from Settings
116     void cacheAcceleratedCompositingFlags();
117
118     // Called when the layer hierarchy needs to be updated (compositing layers have been
119     // created, destroyed or re-parented).
120     void setCompositingLayersNeedRebuild(bool needRebuild = true);
121     bool compositingLayersNeedRebuild() const { return m_compositingLayersNeedRebuild; }
122
123     // GraphicsLayers buffer state, which gets pushed to the underlying platform layers
124     // at specific times.
125     void scheduleLayerFlush(bool canThrottle);
126     void flushPendingLayerChanges(bool isFlushRoot = true);
127     
128     // flushPendingLayerChanges() flushes the entire GraphicsLayer tree, which can cross frame boundaries.
129     // This call returns the rootmost compositor that is being flushed (including self).
130     RenderLayerCompositor* enclosingCompositorFlushingLayers() const;
131
132     // Called when the GraphicsLayer for the given RenderLayer has flushed changes inside of flushPendingLayerChanges().
133     void didFlushChangesForLayer(RenderLayer&, const GraphicsLayer*);
134
135     // Called when something outside WebKit affects the visible rect (e.g. delegated scrolling). Might schedule a layer flush.
136     void didChangeVisibleRect();
137     
138     // Rebuild the tree of compositing layers
139     void updateCompositingLayers(CompositingUpdateType, RenderLayer* updateRoot = nullptr);
140     // This is only used when state changes and we do not exepect a style update or layout to happen soon (e.g. when
141     // we discover that an iframe is overlapped during painting).
142     void scheduleCompositingLayerUpdate();
143
144     // Update the compositing state of the given layer. Returns true if that state changed.
145     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
146     bool updateLayerCompositingState(RenderLayer&, CompositingChangeRepaint = CompositingChangeRepaintNow);
147
148     // Update the geometry for compositing children of compositingAncestor.
149     void updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer&, bool compositedChildrenOnly);
150     
151     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
152     bool clippedByAncestor(RenderLayer&) const;
153     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
154     bool clipsCompositingDescendants(const RenderLayer&) const;
155
156     // Whether the given layer needs an extra 'contents' layer.
157     bool needsContentsCompositingLayer(const RenderLayer&) const;
158
159     bool supportsFixedRootBackgroundCompositing() const;
160     bool needsFixedRootBackgroundLayer(const RenderLayer&) const;
161     GraphicsLayer* fixedRootBackgroundLayer() const;
162     
163     // Return the bounding box required for compositing layer and its childern, relative to ancestorLayer.
164     // If layerBoundingBox is not 0, on return it contains the bounding box of this layer only.
165     LayoutRect calculateCompositedBounds(const RenderLayer&, const RenderLayer& ancestorLayer) const;
166
167     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
168     void repaintOnCompositingChange(RenderLayer&);
169     
170     void repaintInCompositedAncestor(RenderLayer&, const LayoutRect&);
171     
172     // Notify us that a layer has been added or removed
173     void layerWasAdded(RenderLayer& parent, RenderLayer& child);
174     void layerWillBeRemoved(RenderLayer& parent, RenderLayer& child);
175
176     // Get the nearest ancestor layer that has overflow or clip, but is not a stacking context
177     RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer&) const;
178
179     // Repaint parts of all composited layers that intersect the given absolute rectangle (or the entire layer if the pointer is null).
180     void repaintCompositedLayers(const IntRect* = 0);
181
182     // Returns true if the given layer needs it own backing store.
183     bool requiresOwnBackingStore(const RenderLayer&, const RenderLayer* compositingAncestorLayer, const LayoutRect& layerCompositedBoundsInAncestor, const LayoutRect& ancestorCompositedBounds) const;
184
185     RenderLayer& rootRenderLayer() const;
186     GraphicsLayer* rootGraphicsLayer() const;
187     GraphicsLayer* scrollLayer() const;
188
189 #if ENABLE(RUBBER_BANDING)
190     GraphicsLayer* headerLayer() const;
191     GraphicsLayer* footerLayer() const;
192 #endif
193
194     enum RootLayerAttachment {
195         RootLayerUnattached,
196         RootLayerAttachedViaChromeClient,
197         RootLayerAttachedViaEnclosingFrame
198     };
199
200     RootLayerAttachment rootLayerAttachment() const { return m_rootLayerAttachment; }
201     void updateRootLayerAttachment();
202     void updateRootLayerPosition();
203     
204     void setIsInWindow(bool);
205
206     void clearBackingForAllLayers();
207     
208     void layerBecameComposited(const RenderLayer&) { ++m_compositedLayerCount; }
209     void layerBecameNonComposited(const RenderLayer&);
210     
211 #if ENABLE(VIDEO)
212     // Use by RenderVideo to ask if it should try to use accelerated compositing.
213     bool canAccelerateVideoRendering(RenderVideo&) const;
214 #endif
215
216     // Walk the tree looking for layers with 3d transforms. Useful in case you need
217     // to know if there is non-affine content, e.g. for drawing into an image.
218     bool has3DContent() const;
219     
220     // Most platforms connect compositing layer trees between iframes and their parent document.
221     // Some (currently just Mac) allow iframes to do their own compositing.
222     static bool allowsIndependentlyCompositedFrames(const FrameView*);
223     bool shouldPropagateCompositingToEnclosingFrame() const;
224
225     static RenderLayerCompositor* frameContentsCompositor(RenderWidget*);
226     // Return true if the layers changed.
227     static bool parentFrameContentLayers(RenderWidget*);
228
229     // Update the geometry of the layers used for clipping and scrolling in frames.
230     void frameViewDidChangeLocation(const IntPoint& contentsOffset);
231     void frameViewDidChangeSize();
232     void frameViewDidScroll();
233     void frameViewDidAddOrRemoveScrollbars();
234     void frameViewDidLayout();
235     void rootFixedBackgroundsChanged();
236
237     void scrollingLayerDidChange(RenderLayer&);
238     void fixedRootBackgroundLayerChanged();
239
240     String layerTreeAsText(LayerTreeFlags);
241
242     virtual float deviceScaleFactor() const override;
243     virtual float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
244     virtual float pageScaleFactor() const override;
245     virtual float zoomedOutPageScaleFactor() const override;
246
247     virtual void didCommitChangesForLayer(const GraphicsLayer*) const override;
248     virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
249
250     void layerTiledBackingUsageChanged(const GraphicsLayer*, bool /*usingTiledBacking*/);
251     
252     bool keepLayersPixelAligned() const;
253     bool acceleratedDrawingEnabled() const { return m_acceleratedDrawingEnabled; }
254
255     void deviceOrPageScaleFactorChanged();
256
257     void windowScreenDidChange(PlatformDisplayID);
258
259     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
260     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
261     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
262 #if ENABLE(RUBBER_BANDING)
263     GraphicsLayer* layerForOverhangAreas() const { return m_layerForOverhangAreas.get(); }
264     GraphicsLayer* layerForContentShadow() const { return m_contentShadowLayer.get(); }
265
266     GraphicsLayer* updateLayerForTopOverhangArea(bool wantsLayer);
267     GraphicsLayer* updateLayerForBottomOverhangArea(bool wantsLayer);
268     GraphicsLayer* updateLayerForHeader(bool wantsLayer);
269     GraphicsLayer* updateLayerForFooter(bool wantsLayer);
270 #endif
271
272     ScrollableArea* scrollableAreaForScrollLayerID(ScrollingNodeID) const;
273
274     void updateScrollCoordinatedStatus(RenderLayer&);
275     void removeFromScrollCoordinatedLayers(RenderLayer&);
276
277     void willRemoveScrollingLayer(RenderLayer&);
278     void didAddScrollingLayer(RenderLayer&);
279
280 #if PLATFORM(IOS)
281     void registerAllViewportConstrainedLayers();
282     void unregisterAllViewportConstrainedLayers();
283
284     void registerAllScrollingLayers();
285     void unregisterAllScrollingLayers();
286 #endif
287
288     void resetTrackedRepaintRects();
289     void setTracksRepaints(bool);
290
291     void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
292
293     bool viewHasTransparentBackground(Color* backgroundColor = 0) const;
294
295     bool hasNonMainLayersWithTiledBacking() const { return m_layersWithTiledBackingCount; }
296
297     CompositingReasons reasonsForCompositing(const RenderLayer&) const;
298
299     void setLayerFlushThrottlingEnabled(bool);
300     void disableLayerFlushThrottlingTemporarilyForInteraction();
301     
302     void didPaintBacking(RenderLayerBacking*);
303
304     void setRootExtendedBackgroundColor(const Color&);
305     Color rootExtendedBackgroundColor() const { return m_rootExtendedBackgroundColor; }
306
307 private:
308     class OverlapMap;
309
310     // GraphicsLayerClient implementation
311     virtual void notifyAnimationStarted(const GraphicsLayer*, double) override { }
312     virtual void notifyFlushRequired(const GraphicsLayer*) override;
313     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&) override;
314
315     virtual bool isTrackingRepaints() const override;
316     
317     // GraphicsLayerUpdaterClient implementation
318     virtual void flushLayers(GraphicsLayerUpdater*) override;
319     virtual void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const override;
320     
321     // Whether the given RL needs a compositing layer.
322     bool needsToBeComposited(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
323     // Whether the layer has an intrinsic need for compositing layer.
324     bool requiresCompositingLayer(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
325     // Whether the layer could ever be composited.
326     bool canBeComposited(const RenderLayer&) const;
327
328     // Make or destroy the backing for this layer; returns true if backing changed.
329     bool updateBacking(RenderLayer&, CompositingChangeRepaint shouldRepaint);
330
331     void clearBackingForLayerIncludingDescendants(RenderLayer&);
332
333     // Repaint the given rect (which is layer's coords), and regions of child layers that intersect that rect.
334     void recursiveRepaintLayer(RenderLayer&, const IntRect* = nullptr);
335
336     void addToOverlapMap(OverlapMap&, RenderLayer&, IntRect& layerBounds, bool& boundsComputed);
337     void addToOverlapMapRecursive(OverlapMap&, RenderLayer&, RenderLayer* ancestorLayer = nullptr);
338
339     void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>&);
340
341     // Returns true if any layer's compositing changed
342     void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap*, struct CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
343
344     void computeRegionCompositingRequirements(RenderNamedFlowFragment*, OverlapMap*, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
345
346     void computeCompositingRequirementsForNamedFlowFixed(RenderLayer&, OverlapMap*, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
347
348     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
349     void rebuildCompositingLayerTree(RenderLayer&, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
350
351     // Recurses down the RenderFlowThread tree, parenting descendant compositing layers and collecting an array of child 
352     // layers for the current compositing layer corresponding to the anonymous region (that belongs to the region's parent).
353     void rebuildRegionCompositingLayerTree(RenderNamedFlowFragment*, Vector<GraphicsLayer*>& childList, int depth);
354
355     void rebuildCompositingLayerTreeForNamedFlowFixed(RenderLayer&, Vector<GraphicsLayer*>& childList, int depth);
356
357     // Recurses down the tree, updating layer geometry only.
358     void updateLayerTreeGeometry(RenderLayer&, int depth);
359     
360     // Hook compositing layers together
361     void setCompositingParent(RenderLayer& childLayer, RenderLayer* parentLayer);
362     void removeCompositedChildren(RenderLayer&);
363
364     bool layerHas3DContent(const RenderLayer&) const;
365     bool isRunningAcceleratedTransformAnimation(RenderLayerModelObject&) const;
366
367     void appendOverlayLayers(Vector<GraphicsLayer*>&);
368     bool hasAnyAdditionalCompositedLayers(const RenderLayer& rootLayer) const;
369
370     void ensureRootLayer();
371     void destroyRootLayer();
372
373     void attachRootLayer(RootLayerAttachment);
374     void detachRootLayer();
375     
376     void rootLayerAttachmentChanged();
377
378     void updateOverflowControlsLayers();
379
380     void updateScrollLayerPosition();
381
382     void notifyIFramesOfCompositingChange();
383
384     bool isFlushingLayers() const { return m_flushingLayers; }
385     
386     Page* page() const;
387     TiledBacking* pageTiledBacking() const;
388     
389     GraphicsLayerFactory* graphicsLayerFactory() const;
390     ScrollingCoordinator* scrollingCoordinator() const;
391
392     // Whether a running transition or animation enforces the need for a compositing layer.
393     bool requiresCompositingForAnimation(RenderLayerModelObject&) const;
394     bool requiresCompositingForTransform(RenderLayerModelObject&) const;
395     bool requiresCompositingForBackfaceVisibility(RenderLayerModelObject&) const;
396     bool requiresCompositingForVideo(RenderLayerModelObject&) const;
397     bool requiresCompositingForCanvas(RenderLayerModelObject&) const;
398     bool requiresCompositingForPlugin(RenderLayerModelObject&) const;
399     bool requiresCompositingForFrame(RenderLayerModelObject&) const;
400     bool requiresCompositingForFilters(RenderLayerModelObject&) const;
401     bool requiresCompositingForScrollableFrame() const;
402     bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
403     bool requiresCompositingForOverflowScrolling(const RenderLayer&) const;
404     bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
405
406 #if PLATFORM(IOS)
407     bool requiresCompositingForScrolling(const RenderLayer&) const;
408
409     void updateCustomLayersAfterFlush();
410
411     ChromeClient* chromeClient() const;
412
413 #endif
414
415     enum ScrollCoordinationReason {
416         FixedOrSticky = 1 << 0,
417         Scrolling = 1 << 1
418     };
419     typedef unsigned ScrollCoordinationReasons;
420
421     void updateScrollCoordinatedLayer(RenderLayer&, ScrollCoordinationReasons);
422     void detachScrollCoordinatedLayer(RenderLayer&);
423
424     FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
425     StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer&) const;
426
427     bool requiresScrollLayer(RootLayerAttachment) const;
428     bool requiresHorizontalScrollbarLayer() const;
429     bool requiresVerticalScrollbarLayer() const;
430     bool requiresScrollCornerLayer() const;
431 #if ENABLE(RUBBER_BANDING)
432     bool requiresOverhangAreasLayer() const;
433     bool requiresContentShadowLayer() const;
434 #endif
435
436     bool hasCoordinatedScrolling() const;
437     bool shouldCompositeOverflowControls() const;
438
439     void scheduleLayerFlushNow();
440     bool isThrottlingLayerFlushes() const;
441     void startInitialLayerFlushTimerIfNeeded();
442     void startLayerFlushTimerIfNeeded();
443     void layerFlushTimerFired(Timer<RenderLayerCompositor>&);
444
445     void paintRelatedMilestonesTimerFired(Timer<RenderLayerCompositor>&);
446
447 #if !LOG_DISABLED
448     const char* logReasonsForCompositing(const RenderLayer&);
449     void logLayerInfo(const RenderLayer&, int depth);
450 #endif
451
452     bool mainFrameBackingIsTiled() const;
453
454 private:
455     RenderView& m_renderView;
456     std::unique_ptr<GraphicsLayer> m_rootContentLayer;
457     Timer<RenderLayerCompositor> m_updateCompositingLayersTimer;
458
459     bool m_hasAcceleratedCompositing;
460     ChromeClient::CompositingTriggerFlags m_compositingTriggers;
461
462     int m_compositedLayerCount;
463     bool m_showDebugBorders;
464     bool m_showRepaintCounter;
465     bool m_acceleratedDrawingEnabled;
466
467     // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
468     // because only then do we know the final size of plugins and iframes.
469     mutable bool m_reevaluateCompositingAfterLayout;
470
471     bool m_compositing;
472     bool m_compositingLayersNeedRebuild;
473     bool m_flushingLayers;
474     bool m_shouldFlushOnReattach;
475     bool m_forceCompositingMode;
476     bool m_inPostLayoutUpdate; // true when it's OK to trust layout information (e.g. layer sizes and positions)
477
478     bool m_isTrackingRepaints; // Used for testing.
479
480     unsigned m_layersWithTiledBackingCount;
481
482     RootLayerAttachment m_rootLayerAttachment;
483
484     // Enclosing clipping layer for iframe content
485     std::unique_ptr<GraphicsLayer> m_clipLayer;
486     std::unique_ptr<GraphicsLayer> m_scrollLayer;
487
488 #if PLATFORM(IOS)
489     HashSet<RenderLayer*> m_scrollingLayers;
490     HashSet<RenderLayer*> m_scrollingLayersNeedingUpdate;
491 #endif
492     HashSet<RenderLayer*> m_scrollCoordinatedLayers;
493     HashSet<RenderLayer*> m_scrollCoordinatedLayersNeedingUpdate;
494
495     // Enclosing layer for overflow controls and the clipping layer
496     std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
497
498     // Layers for overflow controls
499     std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
500     std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
501     std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
502 #if ENABLE(RUBBER_BANDING)
503     std::unique_ptr<GraphicsLayer> m_layerForOverhangAreas;
504     std::unique_ptr<GraphicsLayer> m_contentShadowLayer;
505     std::unique_ptr<GraphicsLayer> m_layerForTopOverhangArea;
506     std::unique_ptr<GraphicsLayer> m_layerForBottomOverhangArea;
507     std::unique_ptr<GraphicsLayer> m_layerForHeader;
508     std::unique_ptr<GraphicsLayer> m_layerForFooter;
509 #endif
510
511     std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
512
513     Timer<RenderLayerCompositor> m_layerFlushTimer;
514     bool m_layerFlushThrottlingEnabled;
515     bool m_layerFlushThrottlingTemporarilyDisabledForInteraction;
516     bool m_hasPendingLayerFlush;
517
518     Timer<RenderLayerCompositor> m_paintRelatedMilestonesTimer;
519
520 #if !LOG_DISABLED
521     int m_rootLayerUpdateCount;
522     int m_obligateCompositedLayerCount; // count of layer that have to be composited.
523     int m_secondaryCompositedLayerCount; // count of layers that have to be composited because of stacking or overlap.
524     double m_obligatoryBackingStoreBytes;
525     double m_secondaryBackingStoreBytes;
526 #endif
527
528     Color m_rootExtendedBackgroundColor;
529
530     HashMap<ScrollingNodeID, RenderLayer*> m_scrollingNodeToLayerMap;
531 };
532
533
534 } // namespace WebCore
535
536 #endif // RenderLayerCompositor_h