getBoundingClientRects not updated for programmatic scrolls
[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 #pragma once
27
28 #include "ChromeClient.h"
29 #include "GraphicsLayerClient.h"
30 #include "GraphicsLayerUpdater.h"
31 #include "RenderLayer.h"
32 #include <wtf/HashMap.h>
33 #include <wtf/OptionSet.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 class CompositingReason {
59     Transform3D                            = 1 << 0,
60     Video                                  = 1 << 1,
61     Canvas                                 = 1 << 2,
62     Plugin                                 = 1 << 3,
63     IFrame                                 = 1 << 4,
64     BackfaceVisibilityHidden               = 1 << 5,
65     ClipsCompositingDescendants            = 1 << 6,
66     Animation                              = 1 << 7,
67     Filters                                = 1 << 8,
68     PositionFixed                          = 1 << 9,
69     PositionSticky                         = 1 << 10,
70     OverflowScrollingTouch                 = 1 << 11,
71     Stacking                               = 1 << 12,
72     Overlap                                = 1 << 13,
73     NegativeZIndexChildren                 = 1 << 14,
74     TransformWithCompositedDescendants     = 1 << 15,
75     OpacityWithCompositedDescendants       = 1 << 16,
76     MaskWithCompositedDescendants          = 1 << 17,
77     ReflectionWithCompositedDescendants    = 1 << 18,
78     FilterWithCompositedDescendants        = 1 << 19,
79     BlendingWithCompositedDescendants      = 1 << 20,
80     Perspective                            = 1 << 21,
81     Preserve3D                             = 1 << 22,
82     WillChange                             = 1 << 23,
83     Root                                   = 1 << 24,
84     IsolatesCompositedBlendingDescendants  = 1 << 25,
85 };
86
87 // RenderLayerCompositor manages the hierarchy of
88 // composited RenderLayers. It determines which RenderLayers
89 // become compositing, and creates and maintains a hierarchy of
90 // GraphicsLayers based on the RenderLayer painting order.
91 // 
92 // There is one RenderLayerCompositor per RenderView.
93
94 class RenderLayerCompositor final : public GraphicsLayerClient, public GraphicsLayerUpdaterClient {
95     WTF_MAKE_FAST_ALLOCATED;
96 public:
97     explicit RenderLayerCompositor(RenderView&);
98     virtual ~RenderLayerCompositor();
99
100     // Return true if this RenderView is in "compositing mode" (i.e. has one or more
101     // composited RenderLayers)
102     bool inCompositingMode() const { return m_compositing; }
103     // This will make a compositing layer at the root automatically, and hook up to
104     // the native view/window system.
105     void enableCompositingMode(bool enable = true);
106
107     bool inForcedCompositingMode() const { return m_forceCompositingMode; }
108
109     // Returns true if the accelerated compositing is enabled
110     bool hasAcceleratedCompositing() const { return m_hasAcceleratedCompositing; }
111
112     bool canRender3DTransforms() const;
113
114     // Copy the accelerated compositing related flags from Settings
115     void cacheAcceleratedCompositingFlags();
116
117     // Called when the layer hierarchy needs to be updated (compositing layers have been
118     // created, destroyed or re-parented).
119     void setCompositingLayersNeedRebuild(bool needRebuild = true);
120     bool compositingLayersNeedRebuild() const { return m_compositingLayersNeedRebuild; }
121     
122     void willRecalcStyle();
123
124     // Returns true if the composited layers were actually updated.
125     bool didRecalcStyleWithNoPendingLayout();
126
127     // GraphicsLayers buffer state, which gets pushed to the underlying platform layers
128     // at specific times.
129     void scheduleLayerFlush(bool canThrottle);
130     void flushPendingLayerChanges(bool isFlushRoot = true);
131     
132     // flushPendingLayerChanges() flushes the entire GraphicsLayer tree, which can cross frame boundaries.
133     // This call returns the rootmost compositor that is being flushed (including self).
134     RenderLayerCompositor* enclosingCompositorFlushingLayers() const;
135
136     // Called when the GraphicsLayer for the given RenderLayer has flushed changes inside of flushPendingLayerChanges().
137     void didFlushChangesForLayer(RenderLayer&, const GraphicsLayer*);
138
139     // Called when something outside WebKit affects the visible rect (e.g. delegated scrolling). Might schedule a layer flush.
140     void didChangeVisibleRect();
141     
142     // Rebuild the tree of compositing layers
143     bool updateCompositingLayers(CompositingUpdateType, RenderLayer* updateRoot = nullptr);
144     // This is only used when state changes and we do not exepect a style update or layout to happen soon (e.g. when
145     // we discover that an iframe is overlapped during painting).
146     void scheduleCompositingLayerUpdate();
147     // This is used to cancel any pending update timers when the document goes into page cache.
148     void cancelCompositingLayerUpdate();
149
150     // Update the compositing state of the given layer. Returns true if that state changed.
151     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
152     bool updateLayerCompositingState(RenderLayer&, CompositingChangeRepaint = CompositingChangeRepaintNow);
153
154     // Update the geometry for compositing children of compositingAncestor.
155     void updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer&, bool compositedChildrenOnly);
156     
157     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
158     bool clippedByAncestor(RenderLayer&) const;
159     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
160     bool clipsCompositingDescendants(const RenderLayer&) const;
161
162     // Whether the given layer needs an extra 'contents' layer.
163     bool needsContentsCompositingLayer(const RenderLayer&) const;
164
165     bool supportsFixedRootBackgroundCompositing() const;
166     bool needsFixedRootBackgroundLayer(const RenderLayer&) const;
167     GraphicsLayer* fixedRootBackgroundLayer() const;
168
169     void rootOrBodyStyleChanged(RenderElement&, const RenderStyle* oldStyle);
170
171     // Called after the view transparency, or the document or base background color change.
172     void rootBackgroundTransparencyChanged();
173     
174     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
175     void repaintOnCompositingChange(RenderLayer&);
176     
177     void repaintInCompositedAncestor(RenderLayer&, const LayoutRect&);
178     
179     // Notify us that a layer has been added or removed
180     void layerWasAdded(RenderLayer& parent, RenderLayer& child);
181     void layerWillBeRemoved(RenderLayer& parent, RenderLayer& child);
182
183     void layerStyleChanged(StyleDifference, RenderLayer&, const RenderStyle* oldStyle);
184
185     static bool canCompositeClipPath(const RenderLayer&);
186
187     // Get the nearest ancestor layer that has overflow or clip, but is not a stacking context
188     RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer&) const;
189
190     // Repaint all composited layers.
191     void repaintCompositedLayers();
192
193     // Returns true if the given layer needs it own backing store.
194     bool requiresOwnBackingStore(const RenderLayer&, const RenderLayer* compositingAncestorLayer, const LayoutRect& layerCompositedBoundsInAncestor, const LayoutRect& ancestorCompositedBounds) const;
195
196     WEBCORE_EXPORT RenderLayer& rootRenderLayer() const;
197     GraphicsLayer* rootGraphicsLayer() const;
198     WEBCORE_EXPORT GraphicsLayer* scrollLayer() const;
199     GraphicsLayer* clipLayer() const;
200     GraphicsLayer* rootContentLayer() const;
201
202 #if ENABLE(RUBBER_BANDING)
203     GraphicsLayer* headerLayer() const;
204     GraphicsLayer* footerLayer() const;
205 #endif
206
207     enum RootLayerAttachment {
208         RootLayerUnattached,
209         RootLayerAttachedViaChromeClient,
210         RootLayerAttachedViaEnclosingFrame
211     };
212
213     RootLayerAttachment rootLayerAttachment() const { return m_rootLayerAttachment; }
214     void updateRootLayerAttachment();
215     void updateRootLayerPosition();
216     
217     void setIsInWindow(bool);
218
219     void clearBackingForAllLayers();
220     
221     void layerBecameComposited(const RenderLayer&) { ++m_compositedLayerCount; }
222     void layerBecameNonComposited(const RenderLayer&);
223     
224 #if ENABLE(VIDEO)
225     // Use by RenderVideo to ask if it should try to use accelerated compositing.
226     bool canAccelerateVideoRendering(RenderVideo&) const;
227 #endif
228
229     // Walk the tree looking for layers with 3d transforms. Useful in case you need
230     // to know if there is non-affine content, e.g. for drawing into an image.
231     bool has3DContent() const;
232     
233     static RenderLayerCompositor* frameContentsCompositor(RenderWidget*);
234     // Return true if the layers changed.
235     static bool parentFrameContentLayers(RenderWidget*);
236
237     // Update the geometry of the layers used for clipping and scrolling in frames.
238     void frameViewDidChangeLocation(const IntPoint& contentsOffset);
239     void frameViewDidChangeSize();
240     void frameViewDidScroll();
241     void frameViewDidAddOrRemoveScrollbars();
242     void frameViewDidLayout();
243     void rootFixedBackgroundsChanged();
244
245     void scrollingLayerDidChange(RenderLayer&);
246     void fixedRootBackgroundLayerChanged();
247
248     String layerTreeAsText(LayerTreeFlags);
249
250     float deviceScaleFactor() const override;
251     float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
252     float pageScaleFactor() const override;
253     float zoomedOutPageScaleFactor() const override;
254
255     void didCommitChangesForLayer(const GraphicsLayer*) const override;
256     void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
257
258     void layerTiledBackingUsageChanged(const GraphicsLayer*, bool /*usingTiledBacking*/);
259     
260     bool acceleratedDrawingEnabled() const { return m_acceleratedDrawingEnabled; }
261     bool displayListDrawingEnabled() const { return m_displayListDrawingEnabled; }
262
263     void deviceOrPageScaleFactorChanged();
264
265     void windowScreenDidChange(PlatformDisplayID);
266
267     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
268     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
269     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
270 #if ENABLE(RUBBER_BANDING)
271     GraphicsLayer* layerForOverhangAreas() const { return m_layerForOverhangAreas.get(); }
272     GraphicsLayer* layerForContentShadow() const { return m_contentShadowLayer.get(); }
273
274     GraphicsLayer* updateLayerForTopOverhangArea(bool wantsLayer);
275     GraphicsLayer* updateLayerForBottomOverhangArea(bool wantsLayer);
276     GraphicsLayer* updateLayerForHeader(bool wantsLayer);
277     GraphicsLayer* updateLayerForFooter(bool wantsLayer);
278 #endif
279
280     ScrollableArea* scrollableAreaForScrollLayerID(ScrollingNodeID) const;
281
282     enum class ScrollingNodeChangeFlags {
283         Layer           = 1 << 0,
284         LayerGeometry   = 1 << 1,
285     };
286
287     void updateScrollCoordinatedStatus(RenderLayer&, OptionSet<ScrollingNodeChangeFlags>);
288     void removeFromScrollCoordinatedLayers(RenderLayer&);
289
290     void willRemoveScrollingLayerWithBacking(RenderLayer&, RenderLayerBacking&);
291     void didAddScrollingLayer(RenderLayer&);
292
293 #if PLATFORM(IOS)
294     void registerAllViewportConstrainedLayers();
295     void unregisterAllViewportConstrainedLayers();
296
297     void registerAllScrollingLayers();
298     void unregisterAllScrollingLayers();
299 #endif
300
301     void resetTrackedRepaintRects();
302     void setTracksRepaints(bool);
303
304     void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
305
306     bool viewHasTransparentBackground(Color* backgroundColor = nullptr) const;
307
308     bool hasNonMainLayersWithTiledBacking() const { return m_layersWithTiledBackingCount; }
309
310     OptionSet<CompositingReason> reasonsForCompositing(const RenderLayer&) const;
311
312     void setLayerFlushThrottlingEnabled(bool);
313     void disableLayerFlushThrottlingTemporarilyForInteraction();
314     
315     void didPaintBacking(RenderLayerBacking*);
316
317     void setRootExtendedBackgroundColor(const Color&);
318     const Color& rootExtendedBackgroundColor() const { return m_rootExtendedBackgroundColor; }
319
320     void updateRootContentLayerClipping();
321
322 #if ENABLE(CSS_SCROLL_SNAP)
323     void updateScrollSnapPropertiesWithFrameView(const FrameView&);
324 #endif
325
326     // For testing.
327     WEBCORE_EXPORT void startTrackingLayerFlushes();
328     WEBCORE_EXPORT unsigned layerFlushCount() const;
329
330     WEBCORE_EXPORT void startTrackingCompositingUpdates();
331     WEBCORE_EXPORT unsigned compositingUpdateCount() const;
332
333 private:
334     class OverlapMap;
335     struct CompositingState;
336     struct OverlapExtent;
337
338     // GraphicsLayerClient implementation
339     void notifyFlushRequired(const GraphicsLayer*) override;
340     void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&, GraphicsLayerPaintFlags) override;
341     void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const override;
342     bool isTrackingRepaints() const override;
343     
344     // GraphicsLayerUpdaterClient implementation
345     void flushLayersSoon(GraphicsLayerUpdater&) override;
346
347     // Whether the given RL needs a compositing layer.
348     bool needsToBeComposited(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
349     // Whether the layer has an intrinsic need for compositing layer.
350     bool requiresCompositingLayer(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
351     // Whether the layer could ever be composited.
352     bool canBeComposited(const RenderLayer&) const;
353     bool needsCompositingUpdateForStyleChangeOnNonCompositedLayer(RenderLayer&, const RenderStyle* oldStyle) const;
354
355     // Make or destroy the backing for this layer; returns true if backing changed.
356     enum class BackingRequired { No, Yes, Unknown };
357     bool updateBacking(RenderLayer&, CompositingChangeRepaint shouldRepaint, BackingRequired = BackingRequired::Unknown);
358
359     void clearBackingForLayerIncludingDescendants(RenderLayer&);
360
361     // Repaint this and its child layers.
362     void recursiveRepaintLayer(RenderLayer&);
363
364     void computeExtent(const OverlapMap&, const RenderLayer&, OverlapExtent&) const;
365     void addToOverlapMap(OverlapMap&, const RenderLayer&, OverlapExtent&);
366     void addToOverlapMapRecursive(OverlapMap&, const RenderLayer&, const RenderLayer* ancestorLayer = nullptr);
367
368     void updateCompositingLayersTimerFired();
369
370     // Returns true if any layer's compositing changed
371     void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap&, CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
372
373     void computeRegionCompositingRequirements(RenderNamedFlowFragment*, OverlapMap&, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
374
375     void computeCompositingRequirementsForNamedFlowFixed(RenderLayer&, OverlapMap&, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
376
377     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
378     void rebuildCompositingLayerTree(RenderLayer&, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
379
380     // Recurses down the RenderFlowThread tree, parenting descendant compositing layers and collecting an array of child 
381     // layers for the current compositing layer corresponding to the anonymous region (that belongs to the region's parent).
382     void rebuildRegionCompositingLayerTree(RenderNamedFlowFragment*, Vector<GraphicsLayer*>& childList, int depth);
383
384     void rebuildCompositingLayerTreeForNamedFlowFixed(RenderLayer&, Vector<GraphicsLayer*>& childList, int depth);
385
386     // Recurses down the tree, updating layer geometry only.
387     void updateLayerTreeGeometry(RenderLayer&, int depth);
388     
389     // Hook compositing layers together
390     void setCompositingParent(RenderLayer& childLayer, RenderLayer* parentLayer);
391     void removeCompositedChildren(RenderLayer&);
392
393     bool layerHas3DContent(const RenderLayer&) const;
394     bool isRunningTransformAnimation(RenderLayerModelObject&) const;
395
396     void appendDocumentOverlayLayers(Vector<GraphicsLayer*>&);
397     bool hasAnyAdditionalCompositedLayers(const RenderLayer& rootLayer) const;
398
399     void ensureRootLayer();
400     void destroyRootLayer();
401
402     void attachRootLayer(RootLayerAttachment);
403     void detachRootLayer();
404     
405     void rootLayerAttachmentChanged();
406
407     void updateOverflowControlsLayers();
408
409     void updateScrollLayerPosition();
410
411     FloatPoint positionForClipLayer() const;
412
413     void notifyIFramesOfCompositingChange();
414
415     bool isFlushingLayers() const { return m_flushingLayers; }
416     void updateScrollCoordinatedLayersAfterFlushIncludingSubframes();
417     void updateScrollCoordinatedLayersAfterFlush();
418     
419     Page& page() const;
420     
421     GraphicsLayerFactory* graphicsLayerFactory() const;
422     ScrollingCoordinator* scrollingCoordinator() const;
423
424 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
425     RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const override;
426 #endif
427
428     bool requiresCompositingForAnimation(RenderLayerModelObject&) const;
429     bool requiresCompositingForTransform(RenderLayerModelObject&) const;
430     bool requiresCompositingForBackfaceVisibility(RenderLayerModelObject&) const;
431     bool requiresCompositingForVideo(RenderLayerModelObject&) const;
432     bool requiresCompositingForCanvas(RenderLayerModelObject&) const;
433     bool requiresCompositingForPlugin(RenderLayerModelObject&) const;
434     bool requiresCompositingForFrame(RenderLayerModelObject&) const;
435     bool requiresCompositingForFilters(RenderLayerModelObject&) const;
436     bool requiresCompositingForWillChange(RenderLayerModelObject&) const;
437     bool requiresCompositingForScrollableFrame() const;
438     bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
439     bool requiresCompositingForOverflowScrolling(const RenderLayer&) const;
440     bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
441     static bool styleChangeMayAffectIndirectCompositingReasons(const RenderLayerModelObject& renderer, const RenderStyle& oldStyle);
442
443 #if PLATFORM(IOS)
444     bool requiresCompositingForScrolling(const RenderLayer&) const;
445
446     void updateCustomLayersAfterFlush();
447 #endif
448
449     void updateScrollCoordinationForThisFrame(ScrollingNodeID);
450     ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, ScrollingNodeID parentNodeID);
451     void updateScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles, OptionSet<ScrollingNodeChangeFlags>);
452     void detachScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles);
453     void reattachSubframeScrollLayers();
454     
455     FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
456     StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer&) const;
457
458     bool requiresScrollLayer(RootLayerAttachment) const;
459     bool requiresHorizontalScrollbarLayer() const;
460     bool requiresVerticalScrollbarLayer() const;
461     bool requiresScrollCornerLayer() const;
462 #if ENABLE(RUBBER_BANDING)
463     bool requiresOverhangAreasLayer() const;
464     bool requiresContentShadowLayer() const;
465 #endif
466
467     // True if the FrameView uses a ScrollingCoordinator.
468     bool hasCoordinatedScrolling() const;
469     bool useCoordinatedScrollingForLayer(const RenderLayer&) const;
470
471     bool isAsyncScrollableStickyLayer(const RenderLayer&, const RenderLayer** enclosingAcceleratedOverflowLayer = nullptr) const;
472     bool isViewportConstrainedFixedOrStickyLayer(const RenderLayer&) const;
473     
474     bool shouldCompositeOverflowControls() const;
475
476     void scheduleLayerFlushNow();
477     bool isThrottlingLayerFlushes() const;
478     void startInitialLayerFlushTimerIfNeeded();
479     void startLayerFlushTimerIfNeeded();
480     void layerFlushTimerFired();
481
482 #if !LOG_DISABLED
483     const char* logReasonsForCompositing(const RenderLayer&);
484     void logLayerInfo(const RenderLayer&, int depth);
485 #endif
486
487     bool documentUsesTiledBacking() const;
488     bool isMainFrameCompositor() const;
489
490 private:
491     RenderView& m_renderView;
492     std::unique_ptr<GraphicsLayer> m_rootContentLayer;
493     Timer m_updateCompositingLayersTimer;
494
495     ChromeClient::CompositingTriggerFlags m_compositingTriggers { static_cast<ChromeClient::CompositingTriggerFlags>(ChromeClient::AllTriggers) };
496     bool m_hasAcceleratedCompositing { true };
497
498     bool m_showDebugBorders { false };
499     bool m_showRepaintCounter { false };
500     bool m_acceleratedDrawingEnabled { false };
501     bool m_displayListDrawingEnabled { false };
502
503     // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
504     // because only then do we know the final size of plugins and iframes.
505     mutable bool m_reevaluateCompositingAfterLayout { false };
506
507     bool m_compositing { false };
508     bool m_compositingLayersNeedRebuild { false };
509     bool m_flushingLayers { false };
510     bool m_shouldFlushOnReattach { false };
511     bool m_forceCompositingMode { false };
512     bool m_inPostLayoutUpdate { false }; // true when it's OK to trust layout information (e.g. layer sizes and positions)
513     bool m_subframeScrollLayersNeedReattach { false };
514
515     bool m_isTrackingRepaints { false }; // Used for testing.
516
517     int m_compositedLayerCount { 0 };
518     unsigned m_layersWithTiledBackingCount { 0 };
519     unsigned m_layerFlushCount { 0 };
520     unsigned m_compositingUpdateCount { 0 };
521
522     RootLayerAttachment m_rootLayerAttachment { RootLayerUnattached };
523
524     // Enclosing clipping layer for iframe content
525     std::unique_ptr<GraphicsLayer> m_clipLayer;
526     std::unique_ptr<GraphicsLayer> m_scrollLayer;
527
528 #if PLATFORM(IOS)
529     HashSet<RenderLayer*> m_scrollingLayers;
530     HashSet<RenderLayer*> m_scrollingLayersNeedingUpdate;
531 #endif
532     HashSet<RenderLayer*> m_scrollCoordinatedLayers;
533     HashSet<RenderLayer*> m_scrollCoordinatedLayersNeedingUpdate;
534
535     // Enclosing layer for overflow controls and the clipping layer
536     std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
537
538     // Layers for overflow controls
539     std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
540     std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
541     std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
542 #if ENABLE(RUBBER_BANDING)
543     std::unique_ptr<GraphicsLayer> m_layerForOverhangAreas;
544     std::unique_ptr<GraphicsLayer> m_contentShadowLayer;
545     std::unique_ptr<GraphicsLayer> m_layerForTopOverhangArea;
546     std::unique_ptr<GraphicsLayer> m_layerForBottomOverhangArea;
547     std::unique_ptr<GraphicsLayer> m_layerForHeader;
548     std::unique_ptr<GraphicsLayer> m_layerForFooter;
549 #endif
550
551     std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
552
553     Timer m_layerFlushTimer;
554
555     bool m_layerFlushThrottlingEnabled { false };
556     bool m_layerFlushThrottlingTemporarilyDisabledForInteraction { false };
557     bool m_hasPendingLayerFlush { false };
558     bool m_layerNeedsCompositingUpdate { false };
559     bool m_viewBackgroundIsTransparent { false };
560
561 #if !LOG_DISABLED
562     int m_rootLayerUpdateCount { 0 };
563     int m_obligateCompositedLayerCount { 0 }; // count of layer that have to be composited.
564     int m_secondaryCompositedLayerCount { 0 }; // count of layers that have to be composited because of stacking or overlap.
565     double m_obligatoryBackingStoreBytes { 0 };
566     double m_secondaryBackingStoreBytes { 0 };
567 #endif
568
569     Color m_rootExtendedBackgroundColor;
570
571     HashMap<ScrollingNodeID, RenderLayer*> m_scrollingNodeToLayerMap;
572 };
573
574 void paintScrollbar(Scrollbar*, GraphicsContext&, const IntRect& clip);
575
576 } // namespace WebCore