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