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