Source/WebCore/rendering/RenderLayerCompositor.h

   1 /*
   2  * Copyright (C) 2009, 2013 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef RenderLayerCompositor_h
  27 #define RenderLayerCompositor_h
  28
  29 #include "ChromeClient.h"
  30 #include "GraphicsLayerClient.h"
  31 #include "GraphicsLayerUpdater.h"
  32 #include "RenderLayer.h"
  33 #include <wtf/HashMap.h>
  34
  35 namespace WebCore {
  36
  37 class FixedPositionViewportConstraints;
  38 class GraphicsLayer;
  39 class GraphicsLayerUpdater;
  40 class RenderEmbeddedObject;
  41 class RenderNamedFlowFragment;
  42 class RenderVideo;
  43 class RenderWidget;
  44 class ScrollingCoordinator;
  45 class StickyPositionViewportConstraints;
  46 class TiledBacking;
  47
  48 typedef unsigned LayerTreeFlags;
  49
  50 enum CompositingUpdateType {
  51     CompositingUpdateAfterStyleChange,
  52     CompositingUpdateAfterLayout,
  53     CompositingUpdateOnHitTest,
  54     CompositingUpdateOnScroll,
  55     CompositingUpdateOnCompositedScroll
  56 };
  57
  58 enum {
  59     CompositingReasonNone                                   = 0,
  60     CompositingReason3DTransform                            = 1 << 0,
  61     CompositingReasonVideo                                  = 1 << 1,
  62     CompositingReasonCanvas                                 = 1 << 2,
  63     CompositingReasonPlugin                                 = 1 << 3,
  64     CompositingReasonIFrame                                 = 1 << 4,
  65     CompositingReasonBackfaceVisibilityHidden               = 1 << 5,
  66     CompositingReasonClipsCompositingDescendants            = 1 << 6,
  67     CompositingReasonAnimation                              = 1 << 7,
  68     CompositingReasonFilters                                = 1 << 8,
  69     CompositingReasonPositionFixed                          = 1 << 9,
  70     CompositingReasonPositionSticky                         = 1 << 10,
  71     CompositingReasonOverflowScrollingTouch                 = 1 << 11,
  72     CompositingReasonStacking                               = 1 << 12,
  73     CompositingReasonOverlap                                = 1 << 13,
  74     CompositingReasonNegativeZIndexChildren                 = 1 << 14,
  75     CompositingReasonTransformWithCompositedDescendants     = 1 << 15,
  76     CompositingReasonOpacityWithCompositedDescendants       = 1 << 16,
  77     CompositingReasonMaskWithCompositedDescendants          = 1 << 17,
  78     CompositingReasonReflectionWithCompositedDescendants    = 1 << 18,
  79     CompositingReasonFilterWithCompositedDescendants        = 1 << 19,
  80     CompositingReasonBlendingWithCompositedDescendants      = 1 << 20,
  81     CompositingReasonPerspective                            = 1 << 21,
  82     CompositingReasonPreserve3D                             = 1 << 22,
  83     CompositingReasonRoot                                   = 1 << 23,
  84     CompositingReasonIsolatesCompositedBlendingDescendants  = 1 << 24,
  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     void didRecalcStyleWithNoPendingLayout();
 125
 126     // GraphicsLayers buffer state, which gets pushed to the underlying platform layers
 127     // at specific times.
 128     void scheduleLayerFlush(bool canThrottle);
 129     void flushPendingLayerChanges(bool isFlushRoot = true);
 130
 131     // flushPendingLayerChanges() flushes the entire GraphicsLayer tree, which can cross frame boundaries.
 132     // This call returns the rootmost compositor that is being flushed (including self).
 133     RenderLayerCompositor* enclosingCompositorFlushingLayers() const;
 134
 135     // Called when the GraphicsLayer for the given RenderLayer has flushed changes inside of flushPendingLayerChanges().
 136     void didFlushChangesForLayer(RenderLayer&, const GraphicsLayer*);
 137
 138     // Called when something outside WebKit affects the visible rect (e.g. delegated scrolling). Might schedule a layer flush.
 139     void didChangeVisibleRect();
 140
 141     // Rebuild the tree of compositing layers
 142     void updateCompositingLayers(CompositingUpdateType, RenderLayer* updateRoot = nullptr);
 143     // This is only used when state changes and we do not exepect a style update or layout to happen soon (e.g. when
 144     // we discover that an iframe is overlapped during painting).
 145     void scheduleCompositingLayerUpdate();
 146     // This is used to cancel any pending update timers when the document goes into page cache.
 147     void cancelCompositingLayerUpdate();
 148
 149     // Update the compositing state of the given layer. Returns true if that state changed.
 150     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
 151     bool updateLayerCompositingState(RenderLayer&, CompositingChangeRepaint = CompositingChangeRepaintNow);
 152
 153     // Update the geometry for compositing children of compositingAncestor.
 154     void updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer&, bool compositedChildrenOnly);
 155
 156     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
 157     bool clippedByAncestor(RenderLayer&) const;
 158     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
 159     bool clipsCompositingDescendants(const RenderLayer&) const;
 160
 161     // Whether the given layer needs an extra 'contents' layer.
 162     bool needsContentsCompositingLayer(const RenderLayer&) const;
 163
 164     bool supportsFixedRootBackgroundCompositing() const;
 165     bool needsFixedRootBackgroundLayer(const RenderLayer&) const;
 166     GraphicsLayer* fixedRootBackgroundLayer() const;
 167
 168     // Called after the view transparency, or the document or base background color change.
 169     void rootBackgroundTransparencyChanged();
 170
 171     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
 172     void repaintOnCompositingChange(RenderLayer&);
 173
 174     void repaintInCompositedAncestor(RenderLayer&, const LayoutRect&);
 175
 176     // Notify us that a layer has been added or removed
 177     void layerWasAdded(RenderLayer& parent, RenderLayer& child);
 178     void layerWillBeRemoved(RenderLayer& parent, RenderLayer& child);
 179
 180     void layerStyleChanged(StyleDifference, RenderLayer&, const RenderStyle* oldStyle);
 181
 182     static bool canCompositeClipPath(const RenderLayer&);
 183
 184     // Get the nearest ancestor layer that has overflow or clip, but is not a stacking context
 185     RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer&) const;
 186
 187     // Repaint all composited layers.
 188     void repaintCompositedLayers();
 189
 190     // Returns true if the given layer needs it own backing store.
 191     bool requiresOwnBackingStore(const RenderLayer&, const RenderLayer* compositingAncestorLayer, const LayoutRect& layerCompositedBoundsInAncestor, const LayoutRect& ancestorCompositedBounds) const;
 192
 193     WEBCORE_EXPORT RenderLayer& rootRenderLayer() const;
 194     GraphicsLayer* rootGraphicsLayer() const;
 195     WEBCORE_EXPORT GraphicsLayer* scrollLayer() const;
 196     GraphicsLayer* clipLayer() const;
 197     GraphicsLayer* rootContentLayer() const;
 198
 199 #if ENABLE(RUBBER_BANDING)
 200     GraphicsLayer* headerLayer() const;
 201     GraphicsLayer* footerLayer() const;
 202 #endif
 203
 204     enum RootLayerAttachment {
 205         RootLayerUnattached,
 206         RootLayerAttachedViaChromeClient,
 207         RootLayerAttachedViaEnclosingFrame
 208     };
 209
 210     RootLayerAttachment rootLayerAttachment() const { return m_rootLayerAttachment; }
 211     void updateRootLayerAttachment();
 212     void updateRootLayerPosition();
 213
 214     void setIsInWindow(bool);
 215
 216     void clearBackingForAllLayers();
 217
 218     void layerBecameComposited(const RenderLayer&) { ++m_compositedLayerCount; }
 219     void layerBecameNonComposited(const RenderLayer&);
 220
 221 #if ENABLE(VIDEO)
 222     // Use by RenderVideo to ask if it should try to use accelerated compositing.
 223     bool canAccelerateVideoRendering(RenderVideo&) const;
 224 #endif
 225
 226     // Walk the tree looking for layers with 3d transforms. Useful in case you need
 227     // to know if there is non-affine content, e.g. for drawing into an image.
 228     bool has3DContent() const;
 229
 230     static RenderLayerCompositor* frameContentsCompositor(RenderWidget*);
 231     // Return true if the layers changed.
 232     static bool parentFrameContentLayers(RenderWidget*);
 233
 234     // Update the geometry of the layers used for clipping and scrolling in frames.
 235     void frameViewDidChangeLocation(const IntPoint& contentsOffset);
 236     void frameViewDidChangeSize();
 237     void frameViewDidScroll();
 238     void frameViewDidAddOrRemoveScrollbars();
 239     void frameViewDidLayout();
 240     void rootFixedBackgroundsChanged();
 241
 242     void scrollingLayerDidChange(RenderLayer&);
 243     void fixedRootBackgroundLayerChanged();
 244
 245     String layerTreeAsText(LayerTreeFlags);
 246
 247     virtual float deviceScaleFactor() const override;
 248     virtual float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
 249     virtual float pageScaleFactor() const override;
 250     virtual float zoomedOutPageScaleFactor() const override;
 251
 252     virtual void didCommitChangesForLayer(const GraphicsLayer*) const override;
 253     virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
 254
 255     void layerTiledBackingUsageChanged(const GraphicsLayer*, bool /*usingTiledBacking*/);
 256
 257     bool acceleratedDrawingEnabled() const { return m_acceleratedDrawingEnabled; }
 258
 259     void deviceOrPageScaleFactorChanged();
 260
 261     void windowScreenDidChange(PlatformDisplayID);
 262
 263     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
 264     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
 265     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
 266 #if ENABLE(RUBBER_BANDING)
 267     GraphicsLayer* layerForOverhangAreas() const { return m_layerForOverhangAreas.get(); }
 268     GraphicsLayer* layerForContentShadow() const { return m_contentShadowLayer.get(); }
 269
 270     GraphicsLayer* updateLayerForTopOverhangArea(bool wantsLayer);
 271     GraphicsLayer* updateLayerForBottomOverhangArea(bool wantsLayer);
 272     GraphicsLayer* updateLayerForHeader(bool wantsLayer);
 273     GraphicsLayer* updateLayerForFooter(bool wantsLayer);
 274 #endif
 275
 276     ScrollableArea* scrollableAreaForScrollLayerID(ScrollingNodeID) const;
 277
 278     void updateScrollCoordinatedStatus(RenderLayer&);
 279     void removeFromScrollCoordinatedLayers(RenderLayer&);
 280
 281     void willRemoveScrollingLayerWithBacking(RenderLayer&, RenderLayerBacking&);
 282     void didAddScrollingLayer(RenderLayer&);
 283
 284 #if PLATFORM(IOS)
 285     void registerAllViewportConstrainedLayers();
 286     void unregisterAllViewportConstrainedLayers();
 287
 288     void registerAllScrollingLayers();
 289     void unregisterAllScrollingLayers();
 290 #endif
 291
 292     void resetTrackedRepaintRects();
 293     void setTracksRepaints(bool);
 294
 295     void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
 296
 297     bool viewHasTransparentBackground(Color* backgroundColor = nullptr) const;
 298
 299     bool hasNonMainLayersWithTiledBacking() const { return m_layersWithTiledBackingCount; }
 300
 301     CompositingReasons reasonsForCompositing(const RenderLayer&) const;
 302
 303     void setLayerFlushThrottlingEnabled(bool);
 304     void disableLayerFlushThrottlingTemporarilyForInteraction();
 305
 306     void didPaintBacking(RenderLayerBacking*);
 307
 308     void setRootExtendedBackgroundColor(const Color&);
 309     Color rootExtendedBackgroundColor() const { return m_rootExtendedBackgroundColor; }
 310
 311     // For testing.
 312     WEBCORE_EXPORT void startTrackingLayerFlushes();
 313     WEBCORE_EXPORT unsigned layerFlushCount() const;
 314
 315     WEBCORE_EXPORT void startTrackingCompositingUpdates();
 316     WEBCORE_EXPORT unsigned compositingUpdateCount() const;
 317
 318 private:
 319     class OverlapMap;
 320     struct CompositingState;
 321     struct OverlapExtent;
 322
 323     // GraphicsLayerClient implementation
 324     virtual void notifyFlushRequired(const GraphicsLayer*) override;
 325     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&) override;
 326     virtual void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const override;
 327     virtual bool isTrackingRepaints() const override;
 328
 329     // GraphicsLayerUpdaterClient implementation
 330     virtual void flushLayersSoon(GraphicsLayerUpdater&) override;
 331
 332     // Whether the given RL needs a compositing layer.
 333     bool needsToBeComposited(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
 334     // Whether the layer has an intrinsic need for compositing layer.
 335     bool requiresCompositingLayer(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
 336     // Whether the layer could ever be composited.
 337     bool canBeComposited(const RenderLayer&) const;
 338
 339     // Make or destroy the backing for this layer; returns true if backing changed.
 340     enum class BackingRequired { No, Yes, Unknown };
 341     bool updateBacking(RenderLayer&, CompositingChangeRepaint shouldRepaint, BackingRequired = BackingRequired::Unknown);
 342
 343     void clearBackingForLayerIncludingDescendants(RenderLayer&);
 344     void setIsInWindowForLayerIncludingDescendants(RenderLayer&, bool isInWindow);
 345
 346     // Repaint this and its child layers.
 347     void recursiveRepaintLayer(RenderLayer&);
 348
 349     void computeExtent(const OverlapMap&, const RenderLayer&, OverlapExtent&) const;
 350     void addToOverlapMap(OverlapMap&, const RenderLayer&, OverlapExtent&);
 351     void addToOverlapMapRecursive(OverlapMap&, const RenderLayer&, const RenderLayer* ancestorLayer = nullptr);
 352
 353     void updateCompositingLayersTimerFired();
 354
 355     // Returns true if any layer's compositing changed
 356     void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap&, CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
 357
 358     void computeRegionCompositingRequirements(RenderNamedFlowFragment*, OverlapMap&, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
 359
 360     void computeCompositingRequirementsForNamedFlowFixed(RenderLayer&, OverlapMap&, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
 361
 362     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
 363     void rebuildCompositingLayerTree(RenderLayer&, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
 364
 365     // Recurses down the RenderFlowThread tree, parenting descendant compositing layers and collecting an array of child
 366     // layers for the current compositing layer corresponding to the anonymous region (that belongs to the region's parent).
 367     void rebuildRegionCompositingLayerTree(RenderNamedFlowFragment*, Vector<GraphicsLayer*>& childList, int depth);
 368
 369     void rebuildCompositingLayerTreeForNamedFlowFixed(RenderLayer&, Vector<GraphicsLayer*>& childList, int depth);
 370
 371     // Recurses down the tree, updating layer geometry only.
 372     void updateLayerTreeGeometry(RenderLayer&, int depth);
 373
 374     // Hook compositing layers together
 375     void setCompositingParent(RenderLayer& childLayer, RenderLayer* parentLayer);
 376     void removeCompositedChildren(RenderLayer&);
 377
 378     bool layerHas3DContent(const RenderLayer&) const;
 379     bool isRunningTransformAnimation(RenderLayerModelObject&) const;
 380
 381     void appendDocumentOverlayLayers(Vector<GraphicsLayer*>&);
 382     bool hasAnyAdditionalCompositedLayers(const RenderLayer& rootLayer) const;
 383
 384     void ensureRootLayer();
 385     void destroyRootLayer();
 386
 387     void attachRootLayer(RootLayerAttachment);
 388     void detachRootLayer();
 389
 390     void rootLayerAttachmentChanged();
 391
 392     void updateOverflowControlsLayers();
 393
 394     void updateScrollLayerPosition();
 395
 396     FloatPoint positionForClipLayer() const;
 397
 398     void notifyIFramesOfCompositingChange();
 399
 400     bool isFlushingLayers() const { return m_flushingLayers; }
 401     void updateScrollCoordinatedLayersAfterFlushIncludingSubframes();
 402     void updateScrollCoordinatedLayersAfterFlush();
 403
 404     Page* page() const;
 405
 406     GraphicsLayerFactory* graphicsLayerFactory() const;
 407     ScrollingCoordinator* scrollingCoordinator() const;
 408
 409 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
 410     RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const override;
 411 #endif
 412
 413     bool requiresCompositingForAnimation(RenderLayerModelObject&) const;
 414     bool requiresCompositingForTransform(RenderLayerModelObject&) const;
 415     bool requiresCompositingForBackfaceVisibility(RenderLayerModelObject&) const;
 416     bool requiresCompositingForVideo(RenderLayerModelObject&) const;
 417     bool requiresCompositingForCanvas(RenderLayerModelObject&) const;
 418     bool requiresCompositingForPlugin(RenderLayerModelObject&) const;
 419     bool requiresCompositingForFrame(RenderLayerModelObject&) const;
 420     bool requiresCompositingForFilters(RenderLayerModelObject&) const;
 421     bool requiresCompositingForScrollableFrame() const;
 422     bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = nullptr) const;
 423     bool requiresCompositingForOverflowScrolling(const RenderLayer&) const;
 424     bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
 425
 426 #if PLATFORM(IOS)
 427     bool requiresCompositingForScrolling(const RenderLayer&) const;
 428
 429     void updateCustomLayersAfterFlush();
 430
 431     ChromeClient* chromeClient() const;
 432
 433 #endif
 434
 435     void updateScrollCoordinationForThisFrame(ScrollingNodeID);
 436     ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, ScrollingNodeID parentNodeID);
 437     void updateScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles);
 438     void detachScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles);
 439     void reattachSubframeScrollLayers();
 440
 441     FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
 442     StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer&) const;
 443
 444     bool requiresScrollLayer(RootLayerAttachment) const;
 445     bool requiresHorizontalScrollbarLayer() const;
 446     bool requiresVerticalScrollbarLayer() const;
 447     bool requiresScrollCornerLayer() const;
 448 #if ENABLE(RUBBER_BANDING)
 449     bool requiresOverhangAreasLayer() const;
 450     bool requiresContentShadowLayer() const;
 451 #endif
 452
 453     // True if the FrameView uses a ScrollingCoordinator.
 454     bool hasCoordinatedScrolling() const;
 455
 456     bool isAsyncScrollableStickyLayer(const RenderLayer&, const RenderLayer** enclosingAcceleratedOverflowLayer = nullptr) const;
 457     bool isViewportConstrainedFixedOrStickyLayer(const RenderLayer&) const;
 458
 459     bool shouldCompositeOverflowControls() const;
 460
 461     void scheduleLayerFlushNow();
 462     bool isThrottlingLayerFlushes() const;
 463     void startInitialLayerFlushTimerIfNeeded();
 464     void startLayerFlushTimerIfNeeded();
 465     void layerFlushTimerFired();
 466
 467     void paintRelatedMilestonesTimerFired();
 468
 469 #if !LOG_DISABLED
 470     const char* logReasonsForCompositing(const RenderLayer&);
 471     void logLayerInfo(const RenderLayer&, int depth);
 472 #endif
 473
 474     bool documentUsesTiledBacking() const;
 475     bool isMainFrameCompositor() const;
 476
 477 private:
 478     RenderView& m_renderView;
 479     std::unique_ptr<GraphicsLayer> m_rootContentLayer;
 480     Timer m_updateCompositingLayersTimer;
 481
 482     bool m_hasAcceleratedCompositing;
 483     ChromeClient::CompositingTriggerFlags m_compositingTriggers;
 484
 485     bool m_showDebugBorders;
 486     bool m_showRepaintCounter;
 487     bool m_acceleratedDrawingEnabled;
 488
 489     // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
 490     // because only then do we know the final size of plugins and iframes.
 491     mutable bool m_reevaluateCompositingAfterLayout;
 492
 493     bool m_compositing;
 494     bool m_compositingLayersNeedRebuild;
 495     bool m_flushingLayers;
 496     bool m_shouldFlushOnReattach;
 497     bool m_forceCompositingMode;
 498     bool m_inPostLayoutUpdate; // true when it's OK to trust layout information (e.g. layer sizes and positions)
 499     bool m_subframeScrollLayersNeedReattach;
 500
 501     bool m_isTrackingRepaints; // Used for testing.
 502
 503     int m_compositedLayerCount { 0 };
 504     unsigned m_layersWithTiledBackingCount { 0 };
 505     unsigned m_layerFlushCount { 0 };
 506     unsigned m_compositingUpdateCount { 0 };
 507
 508     RootLayerAttachment m_rootLayerAttachment;
 509
 510     // Enclosing clipping layer for iframe content
 511     std::unique_ptr<GraphicsLayer> m_clipLayer;
 512     std::unique_ptr<GraphicsLayer> m_scrollLayer;
 513
 514 #if PLATFORM(IOS)
 515     HashSet<RenderLayer*> m_scrollingLayers;
 516     HashSet<RenderLayer*> m_scrollingLayersNeedingUpdate;
 517 #endif
 518     HashSet<RenderLayer*> m_scrollCoordinatedLayers;
 519     HashSet<RenderLayer*> m_scrollCoordinatedLayersNeedingUpdate;
 520
 521     // Enclosing layer for overflow controls and the clipping layer
 522     std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
 523
 524     // Layers for overflow controls
 525     std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
 526     std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
 527     std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
 528 #if ENABLE(RUBBER_BANDING)
 529     std::unique_ptr<GraphicsLayer> m_layerForOverhangAreas;
 530     std::unique_ptr<GraphicsLayer> m_contentShadowLayer;
 531     std::unique_ptr<GraphicsLayer> m_layerForTopOverhangArea;
 532     std::unique_ptr<GraphicsLayer> m_layerForBottomOverhangArea;
 533     std::unique_ptr<GraphicsLayer> m_layerForHeader;
 534     std::unique_ptr<GraphicsLayer> m_layerForFooter;
 535 #endif
 536
 537     std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
 538
 539     Timer m_layerFlushTimer;
 540     bool m_layerFlushThrottlingEnabled;
 541     bool m_layerFlushThrottlingTemporarilyDisabledForInteraction;
 542     bool m_hasPendingLayerFlush;
 543     bool m_layerNeedsCompositingUpdate { false };
 544
 545     Timer m_paintRelatedMilestonesTimer;
 546
 547 #if !LOG_DISABLED
 548     int m_rootLayerUpdateCount { 0 };
 549     int m_obligateCompositedLayerCount { 0 }; // count of layer that have to be composited.
 550     int m_secondaryCompositedLayerCount { 0 }; // count of layers that have to be composited because of stacking or overlap.
 551     double m_obligatoryBackingStoreBytes { 0 };
 552     double m_secondaryBackingStoreBytes { 0 };
 553 #endif
 554
 555     Color m_rootExtendedBackgroundColor;
 556     Color m_lastDocumentBackgroundColor;
 557
 558     HashMap<ScrollingNodeID, RenderLayer*> m_scrollingNodeToLayerMap;
 559 };
 560
 561
 562 } // namespace WebCore
 563
 564 #endif // RenderLayerCompositor_h