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