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