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 : public GraphicsLayerClient, public GraphicsLayerUpdaterClient {
  96     WTF_MAKE_FAST_ALLOCATED;
  97 public:
  98     explicit RenderLayerCompositor(RenderView&);
  99     ~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     // 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     void 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
 144     // Update the compositing state of the given layer. Returns true if that state changed.
 145     enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
 146     bool updateLayerCompositingState(RenderLayer&, CompositingChangeRepaint = CompositingChangeRepaintNow);
 147
 148     // Update the geometry for compositing children of compositingAncestor.
 149     void updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer&, bool compositedChildrenOnly);
 150
 151     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
 152     bool clippedByAncestor(RenderLayer&) const;
 153     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
 154     bool clipsCompositingDescendants(const RenderLayer&) const;
 155
 156     // Whether the given layer needs an extra 'contents' layer.
 157     bool needsContentsCompositingLayer(const RenderLayer&) const;
 158
 159     bool supportsFixedRootBackgroundCompositing() const;
 160     bool needsFixedRootBackgroundLayer(const RenderLayer&) const;
 161     GraphicsLayer* fixedRootBackgroundLayer() const;
 162
 163     // Return the bounding box required for compositing layer and its childern, relative to ancestorLayer.
 164     // If layerBoundingBox is not 0, on return it contains the bounding box of this layer only.
 165     LayoutRect calculateCompositedBounds(const RenderLayer&, const RenderLayer& ancestorLayer) const;
 166
 167     // Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
 168     void repaintOnCompositingChange(RenderLayer&);
 169
 170     void repaintInCompositedAncestor(RenderLayer&, const LayoutRect&);
 171
 172     // Notify us that a layer has been added or removed
 173     void layerWasAdded(RenderLayer& parent, RenderLayer& child);
 174     void layerWillBeRemoved(RenderLayer& parent, RenderLayer& child);
 175
 176     // Get the nearest ancestor layer that has overflow or clip, but is not a stacking context
 177     RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer&) const;
 178
 179     // Repaint parts of all composited layers that intersect the given absolute rectangle (or the entire layer if the pointer is null).
 180     void repaintCompositedLayers(const IntRect* = 0);
 181
 182     // Returns true if the given layer needs it own backing store.
 183     bool requiresOwnBackingStore(const RenderLayer&, const RenderLayer* compositingAncestorLayer, const LayoutRect& layerCompositedBoundsInAncestor, const LayoutRect& ancestorCompositedBounds) const;
 184
 185     RenderLayer& rootRenderLayer() const;
 186     GraphicsLayer* rootGraphicsLayer() const;
 187     GraphicsLayer* scrollLayer() const;
 188
 189 #if ENABLE(RUBBER_BANDING)
 190     GraphicsLayer* headerLayer() const;
 191     GraphicsLayer* footerLayer() const;
 192 #endif
 193
 194     enum RootLayerAttachment {
 195         RootLayerUnattached,
 196         RootLayerAttachedViaChromeClient,
 197         RootLayerAttachedViaEnclosingFrame
 198     };
 199
 200     RootLayerAttachment rootLayerAttachment() const { return m_rootLayerAttachment; }
 201     void updateRootLayerAttachment();
 202     void updateRootLayerPosition();
 203
 204     void setIsInWindow(bool);
 205
 206     void clearBackingForAllLayers();
 207
 208     void layerBecameComposited(const RenderLayer&) { ++m_compositedLayerCount; }
 209     void layerBecameNonComposited(const RenderLayer&);
 210
 211 #if ENABLE(VIDEO)
 212     // Use by RenderVideo to ask if it should try to use accelerated compositing.
 213     bool canAccelerateVideoRendering(RenderVideo&) const;
 214 #endif
 215
 216     // Walk the tree looking for layers with 3d transforms. Useful in case you need
 217     // to know if there is non-affine content, e.g. for drawing into an image.
 218     bool has3DContent() const;
 219
 220     // Most platforms connect compositing layer trees between iframes and their parent document.
 221     // Some (currently just Mac) allow iframes to do their own compositing.
 222     static bool allowsIndependentlyCompositedFrames(const FrameView*);
 223     bool shouldPropagateCompositingToEnclosingFrame() const;
 224
 225     static RenderLayerCompositor* frameContentsCompositor(RenderWidget*);
 226     // Return true if the layers changed.
 227     static bool parentFrameContentLayers(RenderWidget*);
 228
 229     // Update the geometry of the layers used for clipping and scrolling in frames.
 230     void frameViewDidChangeLocation(const IntPoint& contentsOffset);
 231     void frameViewDidChangeSize();
 232     void frameViewDidScroll();
 233     void frameViewDidAddOrRemoveScrollbars();
 234     void frameViewDidLayout();
 235     void rootFixedBackgroundsChanged();
 236
 237     void scrollingLayerDidChange(RenderLayer&);
 238     void fixedRootBackgroundLayerChanged();
 239
 240     String layerTreeAsText(LayerTreeFlags);
 241
 242     virtual float deviceScaleFactor() const override;
 243     virtual float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
 244     virtual float pageScaleFactor() const override;
 245     virtual float zoomedOutPageScaleFactor() const override;
 246
 247     virtual void didCommitChangesForLayer(const GraphicsLayer*) const override;
 248     virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
 249
 250     void layerTiledBackingUsageChanged(const GraphicsLayer*, bool /*usingTiledBacking*/);
 251
 252     bool keepLayersPixelAligned() const;
 253     bool acceleratedDrawingEnabled() const { return m_acceleratedDrawingEnabled; }
 254
 255     void deviceOrPageScaleFactorChanged();
 256
 257     void windowScreenDidChange(PlatformDisplayID);
 258
 259     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
 260     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
 261     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
 262 #if ENABLE(RUBBER_BANDING)
 263     GraphicsLayer* layerForOverhangAreas() const { return m_layerForOverhangAreas.get(); }
 264     GraphicsLayer* layerForContentShadow() const { return m_contentShadowLayer.get(); }
 265
 266     GraphicsLayer* updateLayerForTopOverhangArea(bool wantsLayer);
 267     GraphicsLayer* updateLayerForBottomOverhangArea(bool wantsLayer);
 268     GraphicsLayer* updateLayerForHeader(bool wantsLayer);
 269     GraphicsLayer* updateLayerForFooter(bool wantsLayer);
 270 #endif
 271
 272     ScrollableArea* scrollableAreaForScrollLayerID(ScrollingNodeID) const;
 273
 274     void updateScrollCoordinatedStatus(RenderLayer&);
 275     void removeFromScrollCoordinatedLayers(RenderLayer&);
 276
 277     void willRemoveScrollingLayer(RenderLayer&);
 278     void didAddScrollingLayer(RenderLayer&);
 279
 280 #if PLATFORM(IOS)
 281     void registerAllViewportConstrainedLayers();
 282     void unregisterAllViewportConstrainedLayers();
 283
 284     void registerAllScrollingLayers();
 285     void unregisterAllScrollingLayers();
 286 #endif
 287
 288     void resetTrackedRepaintRects();
 289     void setTracksRepaints(bool);
 290
 291     void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
 292
 293     bool viewHasTransparentBackground(Color* backgroundColor = 0) const;
 294
 295     bool hasNonMainLayersWithTiledBacking() const { return m_layersWithTiledBackingCount; }
 296
 297     CompositingReasons reasonsForCompositing(const RenderLayer&) const;
 298
 299     void setLayerFlushThrottlingEnabled(bool);
 300     void disableLayerFlushThrottlingTemporarilyForInteraction();
 301
 302     void didPaintBacking(RenderLayerBacking*);
 303
 304     void setRootExtendedBackgroundColor(const Color&);
 305     Color rootExtendedBackgroundColor() const { return m_rootExtendedBackgroundColor; }
 306
 307 private:
 308     class OverlapMap;
 309
 310     // GraphicsLayerClient implementation
 311     virtual void notifyAnimationStarted(const GraphicsLayer*, double) override { }
 312     virtual void notifyFlushRequired(const GraphicsLayer*) override;
 313     virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&) override;
 314     virtual void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const override;
 315     virtual bool isTrackingRepaints() const override;
 316
 317     // GraphicsLayerUpdaterClient implementation
 318     virtual void flushLayersSoon(GraphicsLayerUpdater*) override;
 319
 320     // Whether the given RL needs a compositing layer.
 321     bool needsToBeComposited(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
 322     // Whether the layer has an intrinsic need for compositing layer.
 323     bool requiresCompositingLayer(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
 324     // Whether the layer could ever be composited.
 325     bool canBeComposited(const RenderLayer&) const;
 326
 327     // Make or destroy the backing for this layer; returns true if backing changed.
 328     bool updateBacking(RenderLayer&, CompositingChangeRepaint shouldRepaint);
 329
 330     void clearBackingForLayerIncludingDescendants(RenderLayer&);
 331
 332     // Repaint the given rect (which is layer's coords), and regions of child layers that intersect that rect.
 333     void recursiveRepaintLayer(RenderLayer&, const IntRect* = nullptr);
 334
 335     void addToOverlapMap(OverlapMap&, RenderLayer&, IntRect& layerBounds, bool& boundsComputed);
 336     void addToOverlapMapRecursive(OverlapMap&, RenderLayer&, RenderLayer* ancestorLayer = nullptr);
 337
 338     void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>&);
 339
 340     // Returns true if any layer's compositing changed
 341     void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap*, struct CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
 342
 343     void computeRegionCompositingRequirements(RenderNamedFlowFragment*, OverlapMap*, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
 344
 345     void computeCompositingRequirementsForNamedFlowFixed(RenderLayer&, OverlapMap*, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
 346
 347     // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
 348     void rebuildCompositingLayerTree(RenderLayer&, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
 349
 350     // Recurses down the RenderFlowThread tree, parenting descendant compositing layers and collecting an array of child
 351     // layers for the current compositing layer corresponding to the anonymous region (that belongs to the region's parent).
 352     void rebuildRegionCompositingLayerTree(RenderNamedFlowFragment*, Vector<GraphicsLayer*>& childList, int depth);
 353
 354     void rebuildCompositingLayerTreeForNamedFlowFixed(RenderLayer&, Vector<GraphicsLayer*>& childList, int depth);
 355
 356     // Recurses down the tree, updating layer geometry only.
 357     void updateLayerTreeGeometry(RenderLayer&, int depth);
 358
 359     // Hook compositing layers together
 360     void setCompositingParent(RenderLayer& childLayer, RenderLayer* parentLayer);
 361     void removeCompositedChildren(RenderLayer&);
 362
 363     bool layerHas3DContent(const RenderLayer&) const;
 364     bool isRunningAcceleratedTransformAnimation(RenderLayerModelObject&) const;
 365
 366     void appendOverlayLayers(Vector<GraphicsLayer*>&);
 367     bool hasAnyAdditionalCompositedLayers(const RenderLayer& rootLayer) const;
 368
 369     void ensureRootLayer();
 370     void destroyRootLayer();
 371
 372     void attachRootLayer(RootLayerAttachment);
 373     void detachRootLayer();
 374
 375     void rootLayerAttachmentChanged();
 376
 377     void updateOverflowControlsLayers();
 378
 379     void updateScrollLayerPosition();
 380
 381     void notifyIFramesOfCompositingChange();
 382
 383     bool isFlushingLayers() const { return m_flushingLayers; }
 384
 385     Page* page() const;
 386     TiledBacking* pageTiledBacking() const;
 387
 388     GraphicsLayerFactory* graphicsLayerFactory() const;
 389     ScrollingCoordinator* scrollingCoordinator() const;
 390
 391     // Whether a running transition or animation enforces the need for a compositing layer.
 392     bool requiresCompositingForAnimation(RenderLayerModelObject&) const;
 393     bool requiresCompositingForTransform(RenderLayerModelObject&) const;
 394     bool requiresCompositingForBackfaceVisibility(RenderLayerModelObject&) const;
 395     bool requiresCompositingForVideo(RenderLayerModelObject&) const;
 396     bool requiresCompositingForCanvas(RenderLayerModelObject&) const;
 397     bool requiresCompositingForPlugin(RenderLayerModelObject&) const;
 398     bool requiresCompositingForFrame(RenderLayerModelObject&) const;
 399     bool requiresCompositingForFilters(RenderLayerModelObject&) const;
 400     bool requiresCompositingForScrollableFrame() const;
 401     bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
 402     bool requiresCompositingForOverflowScrolling(const RenderLayer&) const;
 403     bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
 404
 405 #if PLATFORM(IOS)
 406     bool requiresCompositingForScrolling(const RenderLayer&) const;
 407
 408     void updateCustomLayersAfterFlush();
 409
 410     ChromeClient* chromeClient() const;
 411
 412 #endif
 413
 414     enum ScrollCoordinationReason {
 415         FixedOrSticky = 1 << 0,
 416         Scrolling = 1 << 1
 417     };
 418     typedef unsigned ScrollCoordinationReasons;
 419
 420     void updateScrollCoordinatedLayer(RenderLayer&, ScrollCoordinationReasons);
 421     void detachScrollCoordinatedLayer(RenderLayer&);
 422
 423     FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
 424     StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer&) const;
 425
 426     bool requiresScrollLayer(RootLayerAttachment) const;
 427     bool requiresHorizontalScrollbarLayer() const;
 428     bool requiresVerticalScrollbarLayer() const;
 429     bool requiresScrollCornerLayer() const;
 430 #if ENABLE(RUBBER_BANDING)
 431     bool requiresOverhangAreasLayer() const;
 432     bool requiresContentShadowLayer() const;
 433 #endif
 434
 435     bool hasCoordinatedScrolling() const;
 436     bool shouldCompositeOverflowControls() const;
 437
 438     void scheduleLayerFlushNow();
 439     bool isThrottlingLayerFlushes() const;
 440     void startInitialLayerFlushTimerIfNeeded();
 441     void startLayerFlushTimerIfNeeded();
 442     void layerFlushTimerFired(Timer<RenderLayerCompositor>&);
 443
 444     void paintRelatedMilestonesTimerFired(Timer<RenderLayerCompositor>&);
 445
 446 #if !LOG_DISABLED
 447     const char* logReasonsForCompositing(const RenderLayer&);
 448     void logLayerInfo(const RenderLayer&, int depth);
 449 #endif
 450
 451     bool mainFrameBackingIsTiled() const;
 452
 453 private:
 454     RenderView& m_renderView;
 455     std::unique_ptr<GraphicsLayer> m_rootContentLayer;
 456     Timer<RenderLayerCompositor> m_updateCompositingLayersTimer;
 457
 458     bool m_hasAcceleratedCompositing;
 459     ChromeClient::CompositingTriggerFlags m_compositingTriggers;
 460
 461     int m_compositedLayerCount;
 462     bool m_showDebugBorders;
 463     bool m_showRepaintCounter;
 464     bool m_acceleratedDrawingEnabled;
 465
 466     // When true, we have to wait until layout has happened before we can decide whether to enter compositing mode,
 467     // because only then do we know the final size of plugins and iframes.
 468     mutable bool m_reevaluateCompositingAfterLayout;
 469
 470     bool m_compositing;
 471     bool m_compositingLayersNeedRebuild;
 472     bool m_flushingLayers;
 473     bool m_shouldFlushOnReattach;
 474     bool m_forceCompositingMode;
 475     bool m_inPostLayoutUpdate; // true when it's OK to trust layout information (e.g. layer sizes and positions)
 476
 477     bool m_isTrackingRepaints; // Used for testing.
 478
 479     unsigned m_layersWithTiledBackingCount;
 480
 481     RootLayerAttachment m_rootLayerAttachment;
 482
 483     // Enclosing clipping layer for iframe content
 484     std::unique_ptr<GraphicsLayer> m_clipLayer;
 485     std::unique_ptr<GraphicsLayer> m_scrollLayer;
 486
 487 #if PLATFORM(IOS)
 488     HashSet<RenderLayer*> m_scrollingLayers;
 489     HashSet<RenderLayer*> m_scrollingLayersNeedingUpdate;
 490 #endif
 491     HashSet<RenderLayer*> m_scrollCoordinatedLayers;
 492     HashSet<RenderLayer*> m_scrollCoordinatedLayersNeedingUpdate;
 493
 494     // Enclosing layer for overflow controls and the clipping layer
 495     std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
 496
 497     // Layers for overflow controls
 498     std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
 499     std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
 500     std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
 501 #if ENABLE(RUBBER_BANDING)
 502     std::unique_ptr<GraphicsLayer> m_layerForOverhangAreas;
 503     std::unique_ptr<GraphicsLayer> m_contentShadowLayer;
 504     std::unique_ptr<GraphicsLayer> m_layerForTopOverhangArea;
 505     std::unique_ptr<GraphicsLayer> m_layerForBottomOverhangArea;
 506     std::unique_ptr<GraphicsLayer> m_layerForHeader;
 507     std::unique_ptr<GraphicsLayer> m_layerForFooter;
 508 #endif
 509
 510     std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater; // Updates tiled layer visible area periodically while animations are running.
 511
 512     Timer<RenderLayerCompositor> m_layerFlushTimer;
 513     bool m_layerFlushThrottlingEnabled;
 514     bool m_layerFlushThrottlingTemporarilyDisabledForInteraction;
 515     bool m_hasPendingLayerFlush;
 516
 517     Timer<RenderLayerCompositor> m_paintRelatedMilestonesTimer;
 518
 519 #if !LOG_DISABLED
 520     int m_rootLayerUpdateCount;
 521     int m_obligateCompositedLayerCount; // count of layer that have to be composited.
 522     int m_secondaryCompositedLayerCount; // count of layers that have to be composited because of stacking or overlap.
 523     double m_obligatoryBackingStoreBytes;
 524     double m_secondaryBackingStoreBytes;
 525 #endif
 526
 527     Color m_rootExtendedBackgroundColor;
 528
 529     HashMap<ScrollingNodeID, RenderLayer*> m_scrollingNodeToLayerMap;
 530 };
 531
 532
 533 } // namespace WebCore
 534
 535 #endif // RenderLayerCompositor_h