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