Don't invalidate composition for style changes in non-composited layers
[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
34 namespace WebCore {
35
36 class FixedPositionViewportConstraints;
37 class GraphicsLayer;
38 class GraphicsLayerUpdater;
39 class RenderEmbeddedObject;
40 class RenderNamedFlowFragment;
41 class RenderVideo;
42 class RenderWidget;
43 class ScrollingCoordinator;
44 class StickyPositionViewportConstraints;
45 class TiledBacking;
46
47 typedef unsigned LayerTreeFlags;
48
49 enum CompositingUpdateType {
50     CompositingUpdateAfterStyleChange,
51     CompositingUpdateAfterLayout,
52     CompositingUpdateOnHitTest,
53     CompositingUpdateOnScroll,
54     CompositingUpdateOnCompositedScroll
55 };
56
57 enum {
58     CompositingReasonNone                                   = 0,
59     CompositingReason3DTransform                            = 1 << 0,
60     CompositingReasonVideo                                  = 1 << 1,
61     CompositingReasonCanvas                                 = 1 << 2,
62     CompositingReasonPlugin                                 = 1 << 3,
63     CompositingReasonIFrame                                 = 1 << 4,
64     CompositingReasonBackfaceVisibilityHidden               = 1 << 5,
65     CompositingReasonClipsCompositingDescendants            = 1 << 6,
66     CompositingReasonAnimation                              = 1 << 7,
67     CompositingReasonFilters                                = 1 << 8,
68     CompositingReasonPositionFixed                          = 1 << 9,
69     CompositingReasonPositionSticky                         = 1 << 10,
70     CompositingReasonOverflowScrollingTouch                 = 1 << 11,
71     CompositingReasonStacking                               = 1 << 12,
72     CompositingReasonOverlap                                = 1 << 13,
73     CompositingReasonNegativeZIndexChildren                 = 1 << 14,
74     CompositingReasonTransformWithCompositedDescendants     = 1 << 15,
75     CompositingReasonOpacityWithCompositedDescendants       = 1 << 16,
76     CompositingReasonMaskWithCompositedDescendants          = 1 << 17,
77     CompositingReasonReflectionWithCompositedDescendants    = 1 << 18,
78     CompositingReasonFilterWithCompositedDescendants        = 1 << 19,
79     CompositingReasonBlendingWithCompositedDescendants      = 1 << 20,
80     CompositingReasonPerspective                            = 1 << 21,
81     CompositingReasonPreserve3D                             = 1 << 22,
82     CompositingReasonWillChange                             = 1 << 23,
83     CompositingReasonRoot                                   = 1 << 24,
84     CompositingReasonIsolatesCompositedBlendingDescendants  = 1 << 25,
85 };
86 typedef unsigned CompositingReasons;
87
88 // RenderLayerCompositor manages the hierarchy of
89 // composited RenderLayers. It determines which RenderLayers
90 // become compositing, and creates and maintains a hierarchy of
91 // GraphicsLayers based on the RenderLayer painting order.
92 // 
93 // There is one RenderLayerCompositor per RenderView.
94
95 class RenderLayerCompositor final : public GraphicsLayerClient, public GraphicsLayerUpdaterClient {
96     WTF_MAKE_FAST_ALLOCATED;
97 public:
98     explicit RenderLayerCompositor(RenderView&);
99     virtual ~RenderLayerCompositor();
100
101     // Return true if this RenderView is in "compositing mode" (i.e. has one or more
102     // composited RenderLayers)
103     bool inCompositingMode() const { return m_compositing; }
104     // This will make a compositing layer at the root automatically, and hook up to
105     // the native view/window system.
106     void enableCompositingMode(bool enable = true);
107
108     bool inForcedCompositingMode() const { return m_forceCompositingMode; }
109
110     // Returns true if the accelerated compositing is enabled
111     bool hasAcceleratedCompositing() const { return m_hasAcceleratedCompositing; }
112
113     bool canRender3DTransforms() const;
114
115     // Copy the accelerated compositing related flags from Settings
116     void cacheAcceleratedCompositingFlags();
117
118     // Called when the layer hierarchy needs to be updated (compositing layers have been
119     // created, destroyed or re-parented).
120     void setCompositingLayersNeedRebuild(bool needRebuild = true);
121     bool compositingLayersNeedRebuild() const { return m_compositingLayersNeedRebuild; }
122     
123     void willRecalcStyle();
124
125     // Returns true if the composited layers were actually updated.
126     bool didRecalcStyleWithNoPendingLayout();
127
128     // GraphicsLayers buffer state, which gets pushed to the underlying platform layers
129     // at specific times.
130     void scheduleLayerFlush(bool canThrottle);
131     void flushPendingLayerChanges(bool isFlushRoot = true);
132     
133     // flushPendingLayerChanges() flushes the entire GraphicsLayer tree, which can cross frame boundaries.
134     // This call returns the rootmost compositor that is being flushed (including self).
135     RenderLayerCompositor* enclosingCompositorFlushingLayers() const;
136
137     // Called when the GraphicsLayer for the given RenderLayer has flushed changes inside of flushPendingLayerChanges().
138     void didFlushChangesForLayer(RenderLayer&, const GraphicsLayer*);
139
140     // Called when something outside WebKit affects the visible rect (e.g. delegated scrolling). Might schedule a layer flush.
141     void didChangeVisibleRect();
142     
143     // Rebuild the tree of compositing layers
144     bool updateCompositingLayers(CompositingUpdateType, RenderLayer* updateRoot = nullptr);
145     // This is only used when state changes and we do not exepect a style update or layout to happen soon (e.g. when
146     // we discover that an iframe is overlapped during painting).
147     void scheduleCompositingLayerUpdate();
148     // This is used to cancel any pending update timers when the document goes into page cache.
149     void cancelCompositingLayerUpdate();
150
151     // Update the compositing state of the given layer. Returns true if that state changed.
152     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
153     bool updateLayerCompositingState(RenderLayer&, CompositingChangeRepaint = CompositingChangeRepaintNow);
154
155     // Update the geometry for compositing children of compositingAncestor.
156     void updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer&, bool compositedChildrenOnly);
157     
158     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
159     bool clippedByAncestor(RenderLayer&) const;
160     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
161     bool clipsCompositingDescendants(const RenderLayer&) const;
162
163     // Whether the given layer needs an extra 'contents' layer.
164     bool needsContentsCompositingLayer(const RenderLayer&) const;
165
166     bool supportsFixedRootBackgroundCompositing() const;
167     bool needsFixedRootBackgroundLayer(const RenderLayer&) const;
168     GraphicsLayer* fixedRootBackgroundLayer() const;
169
170     void rootOrBodyStyleChanged(RenderElement&, const RenderStyle* oldStyle);
171
172     // Called after the view transparency, or the document or base background color change.
173     void rootBackgroundTransparencyChanged();
174     
175     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
176     void repaintOnCompositingChange(RenderLayer&);
177     
178     void repaintInCompositedAncestor(RenderLayer&, const LayoutRect&);
179     
180     // Notify us that a layer has been added or removed
181     void layerWasAdded(RenderLayer& parent, RenderLayer& child);
182     void layerWillBeRemoved(RenderLayer& parent, RenderLayer& child);
183
184     void layerStyleChanged(StyleDifference, RenderLayer&, const RenderStyle* oldStyle);
185
186     static bool canCompositeClipPath(const RenderLayer&);
187
188     // Get the nearest ancestor layer that has overflow or clip, but is not a stacking context
189     RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer&) const;
190
191     // Repaint all composited layers.
192     void repaintCompositedLayers();
193
194     // Returns true if the given layer needs it own backing store.
195     bool requiresOwnBackingStore(const RenderLayer&, const RenderLayer* compositingAncestorLayer, const LayoutRect& layerCompositedBoundsInAncestor, const LayoutRect& ancestorCompositedBounds) const;
196
197     WEBCORE_EXPORT RenderLayer& rootRenderLayer() const;
198     GraphicsLayer* rootGraphicsLayer() const;
199     WEBCORE_EXPORT GraphicsLayer* scrollLayer() const;
200     GraphicsLayer* clipLayer() const;
201     GraphicsLayer* rootContentLayer() const;
202
203 #if ENABLE(RUBBER_BANDING)
204     GraphicsLayer* headerLayer() const;
205     GraphicsLayer* footerLayer() const;
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&) { ++m_compositedLayerCount; }
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 rootFixedBackgroundsChanged();
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     void updateScrollCoordinatedStatus(RenderLayer&);
284     void removeFromScrollCoordinatedLayers(RenderLayer&);
285
286     void willRemoveScrollingLayerWithBacking(RenderLayer&, RenderLayerBacking&);
287     void didAddScrollingLayer(RenderLayer&);
288
289 #if PLATFORM(IOS)
290     void registerAllViewportConstrainedLayers();
291     void unregisterAllViewportConstrainedLayers();
292
293     void registerAllScrollingLayers();
294     void unregisterAllScrollingLayers();
295 #endif
296
297     void resetTrackedRepaintRects();
298     void setTracksRepaints(bool);
299
300     void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
301
302     bool viewHasTransparentBackground(Color* backgroundColor = nullptr) const;
303
304     bool hasNonMainLayersWithTiledBacking() const { return m_layersWithTiledBackingCount; }
305
306     CompositingReasons reasonsForCompositing(const RenderLayer&) const;
307
308     void setLayerFlushThrottlingEnabled(bool);
309     void disableLayerFlushThrottlingTemporarilyForInteraction();
310     
311     void didPaintBacking(RenderLayerBacking*);
312
313     void setRootExtendedBackgroundColor(const Color&);
314     const Color& rootExtendedBackgroundColor() const { return m_rootExtendedBackgroundColor; }
315
316 #if ENABLE(CSS_SCROLL_SNAP)
317     void updateScrollSnapPropertiesWithFrameView(const FrameView&);
318 #endif
319
320     // For testing.
321     WEBCORE_EXPORT void startTrackingLayerFlushes();
322     WEBCORE_EXPORT unsigned layerFlushCount() const;
323
324     WEBCORE_EXPORT void startTrackingCompositingUpdates();
325     WEBCORE_EXPORT unsigned compositingUpdateCount() const;
326
327 private:
328     class OverlapMap;
329     struct CompositingState;
330     struct OverlapExtent;
331
332     // GraphicsLayerClient implementation
333     void notifyFlushRequired(const GraphicsLayer*) override;
334     void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&) override;
335     void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const override;
336     bool isTrackingRepaints() const override;
337     
338     // GraphicsLayerUpdaterClient implementation
339     void flushLayersSoon(GraphicsLayerUpdater&) override;
340
341     // Whether the given RL needs a compositing layer.
342     bool needsToBeComposited(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
343     // Whether the layer has an intrinsic need for compositing layer.
344     bool requiresCompositingLayer(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
345     // Whether the layer could ever be composited.
346     bool canBeComposited(const RenderLayer&) const;
347
348     // Make or destroy the backing for this layer; returns true if backing changed.
349     enum class BackingRequired { No, Yes, Unknown };
350     bool updateBacking(RenderLayer&, CompositingChangeRepaint shouldRepaint, BackingRequired = BackingRequired::Unknown);
351
352     void clearBackingForLayerIncludingDescendants(RenderLayer&);
353
354     // Repaint this and its child layers.
355     void recursiveRepaintLayer(RenderLayer&);
356
357     void computeExtent(const OverlapMap&, const RenderLayer&, OverlapExtent&) const;
358     void addToOverlapMap(OverlapMap&, const RenderLayer&, OverlapExtent&);
359     void addToOverlapMapRecursive(OverlapMap&, const RenderLayer&, const RenderLayer* ancestorLayer = nullptr);
360
361     void updateCompositingLayersTimerFired();
362
363     // Returns true if any layer's compositing changed
364     void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap&, CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
365
366     void computeRegionCompositingRequirements(RenderNamedFlowFragment*, OverlapMap&, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
367
368     void computeCompositingRequirementsForNamedFlowFixed(RenderLayer&, OverlapMap&, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
369
370     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
371     void rebuildCompositingLayerTree(RenderLayer&, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
372
373     // Recurses down the RenderFlowThread tree, parenting descendant compositing layers and collecting an array of child 
374     // layers for the current compositing layer corresponding to the anonymous region (that belongs to the region's parent).
375     void rebuildRegionCompositingLayerTree(RenderNamedFlowFragment*, Vector<GraphicsLayer*>& childList, int depth);
376
377     void rebuildCompositingLayerTreeForNamedFlowFixed(RenderLayer&, Vector<GraphicsLayer*>& childList, int depth);
378
379     // Recurses down the tree, updating layer geometry only.
380     void updateLayerTreeGeometry(RenderLayer&, int depth);
381     
382     // Hook compositing layers together
383     void setCompositingParent(RenderLayer& childLayer, RenderLayer* parentLayer);
384     void removeCompositedChildren(RenderLayer&);
385
386     bool layerHas3DContent(const RenderLayer&) const;
387     bool isRunningTransformAnimation(RenderLayerModelObject&) const;
388
389     void appendDocumentOverlayLayers(Vector<GraphicsLayer*>&);
390     bool hasAnyAdditionalCompositedLayers(const RenderLayer& rootLayer) const;
391
392     void ensureRootLayer();
393     void destroyRootLayer();
394
395     void attachRootLayer(RootLayerAttachment);
396     void detachRootLayer();
397     
398     void rootLayerAttachmentChanged();
399
400     void updateOverflowControlsLayers();
401
402     void updateScrollLayerPosition();
403
404     FloatPoint positionForClipLayer() const;
405
406     void notifyIFramesOfCompositingChange();
407
408     bool isFlushingLayers() const { return m_flushingLayers; }
409     void updateScrollCoordinatedLayersAfterFlushIncludingSubframes();
410     void updateScrollCoordinatedLayersAfterFlush();
411     
412     Page& page() const;
413     
414     GraphicsLayerFactory* graphicsLayerFactory() const;
415     ScrollingCoordinator* scrollingCoordinator() const;
416
417 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
418     RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const override;
419 #endif
420
421     bool requiresCompositingForAnimation(RenderLayerModelObject&) const;
422     bool requiresCompositingForTransform(RenderLayerModelObject&) const;
423     bool requiresCompositingForBackfaceVisibility(RenderLayerModelObject&) const;
424     bool requiresCompositingForVideo(RenderLayerModelObject&) const;
425     bool requiresCompositingForCanvas(RenderLayerModelObject&) const;
426     bool requiresCompositingForPlugin(RenderLayerModelObject&) const;
427     bool requiresCompositingForFrame(RenderLayerModelObject&) const;
428     bool requiresCompositingForFilters(RenderLayerModelObject&) const;
429     bool requiresCompositingForWillChange(RenderLayerModelObject&) const;
430     bool requiresCompositingForScrollableFrame() const;
431     bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
432     bool requiresCompositingForOverflowScrolling(const RenderLayer&) const;
433     bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
434     static bool styleChangeMayAffectIndirectCompositingReasons(const RenderLayerModelObject& renderer, const RenderStyle& oldStyle);
435
436 #if PLATFORM(IOS)
437     bool requiresCompositingForScrolling(const RenderLayer&) const;
438
439     void updateCustomLayersAfterFlush();
440 #endif
441
442     void updateScrollCoordinationForThisFrame(ScrollingNodeID);
443     ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, ScrollingNodeID parentNodeID);
444     void updateScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles);
445     void detachScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles);
446     void reattachSubframeScrollLayers();
447     
448     FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
449     StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer&) const;
450
451     bool requiresScrollLayer(RootLayerAttachment) const;
452     bool requiresHorizontalScrollbarLayer() const;
453     bool requiresVerticalScrollbarLayer() const;
454     bool requiresScrollCornerLayer() const;
455 #if ENABLE(RUBBER_BANDING)
456     bool requiresOverhangAreasLayer() const;
457     bool requiresContentShadowLayer() const;
458 #endif
459
460     // True if the FrameView uses a ScrollingCoordinator.
461     bool hasCoordinatedScrolling() 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 private:
483     RenderView& m_renderView;
484     std::unique_ptr<GraphicsLayer> m_rootContentLayer;
485     Timer m_updateCompositingLayersTimer;
486
487     ChromeClient::CompositingTriggerFlags m_compositingTriggers { static_cast<ChromeClient::CompositingTriggerFlags>(ChromeClient::AllTriggers) };
488     bool m_hasAcceleratedCompositing { true };
489
490     bool m_showDebugBorders { false };
491     bool m_showRepaintCounter { false };
492     bool m_acceleratedDrawingEnabled { false };
493     bool m_displayListDrawingEnabled { false };
494
495     // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
496     // because only then do we know the final size of plugins and iframes.
497     mutable bool m_reevaluateCompositingAfterLayout { false };
498
499     bool m_compositing { false };
500     bool m_compositingLayersNeedRebuild { false };
501     bool m_flushingLayers { false };
502     bool m_shouldFlushOnReattach { false };
503     bool m_forceCompositingMode { false };
504     bool m_inPostLayoutUpdate { false }; // true when it's OK to trust layout information (e.g. layer sizes and positions)
505     bool m_subframeScrollLayersNeedReattach { false };
506
507     bool m_isTrackingRepaints { false }; // Used for testing.
508
509     int m_compositedLayerCount { 0 };
510     unsigned m_layersWithTiledBackingCount { 0 };
511     unsigned m_layerFlushCount { 0 };
512     unsigned m_compositingUpdateCount { 0 };
513
514     RootLayerAttachment m_rootLayerAttachment { RootLayerUnattached };
515
516     // Enclosing clipping layer for iframe content
517     std::unique_ptr<GraphicsLayer> m_clipLayer;
518     std::unique_ptr<GraphicsLayer> m_scrollLayer;
519
520 #if PLATFORM(IOS)
521     HashSet<RenderLayer*> m_scrollingLayers;
522     HashSet<RenderLayer*> m_scrollingLayersNeedingUpdate;
523 #endif
524     HashSet<RenderLayer*> m_scrollCoordinatedLayers;
525     HashSet<RenderLayer*> m_scrollCoordinatedLayersNeedingUpdate;
526
527     // Enclosing layer for overflow controls and the clipping layer
528     std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
529
530     // Layers for overflow controls
531     std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
532     std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
533     std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
534 #if ENABLE(RUBBER_BANDING)
535     std::unique_ptr<GraphicsLayer> m_layerForOverhangAreas;
536     std::unique_ptr<GraphicsLayer> m_contentShadowLayer;
537     std::unique_ptr<GraphicsLayer> m_layerForTopOverhangArea;
538     std::unique_ptr<GraphicsLayer> m_layerForBottomOverhangArea;
539     std::unique_ptr<GraphicsLayer> m_layerForHeader;
540     std::unique_ptr<GraphicsLayer> m_layerForFooter;
541 #endif
542
543     std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
544
545     Timer m_layerFlushTimer;
546
547     bool m_layerFlushThrottlingEnabled { false };
548     bool m_layerFlushThrottlingTemporarilyDisabledForInteraction { false };
549     bool m_hasPendingLayerFlush { false };
550     bool m_layerNeedsCompositingUpdate { false };
551     bool m_viewBackgroundIsTransparent { false };
552
553 #if !LOG_DISABLED
554     int m_rootLayerUpdateCount { 0 };
555     int m_obligateCompositedLayerCount { 0 }; // count of layer that have to be composited.
556     int m_secondaryCompositedLayerCount { 0 }; // count of layers that have to be composited because of stacking or overlap.
557     double m_obligatoryBackingStoreBytes { 0 };
558     double m_secondaryBackingStoreBytes { 0 };
559 #endif
560
561     Color m_rootExtendedBackgroundColor;
562
563     HashMap<ScrollingNodeID, RenderLayer*> m_scrollingNodeToLayerMap;
564 };
565
566 void paintScrollbar(Scrollbar*, GraphicsContext&, const IntRect& clip);
567
568 } // namespace WebCore