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