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