Source/WebCore/rendering/RenderLayerBacking.h

   1 /*
   2  * Copyright (C) 2009, 2010, 2011 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 "FloatPoint.h"
  29 #include "FloatPoint3D.h"
  30 #include "GraphicsLayer.h"
  31 #include "GraphicsLayerClient.h"
  32 #include "RenderLayer.h"
  33 #include "ScrollingCoordinator.h"
  34
  35 namespace WebCore {
  36
  37 class KeyframeList;
  38 class PaintedContentsInfo;
  39 class RenderLayerCompositor;
  40 class TiledBacking;
  41 class TransformationMatrix;
  42
  43 enum CompositingLayerType {
  44     NormalCompositingLayer, // non-tiled layer with backing store
  45     TiledCompositingLayer, // tiled layer (always has backing store)
  46     MediaCompositingLayer, // layer that contains an image, video, webGL or plugin
  47     ContainerCompositingLayer // layer with no backing store
  48 };
  49
  50 // RenderLayerBacking controls the compositing behavior for a single RenderLayer.
  51 // It holds the various GraphicsLayers, and makes decisions about intra-layer rendering
  52 // optimizations.
  53 //
  54 // There is one RenderLayerBacking for each RenderLayer that is composited.
  55
  56 class RenderLayerBacking final : public GraphicsLayerClient {
  57     WTF_MAKE_NONCOPYABLE(RenderLayerBacking); WTF_MAKE_FAST_ALLOCATED;
  58 public:
  59     explicit RenderLayerBacking(RenderLayer&);
  60     ~RenderLayerBacking();
  61
  62 #if PLATFORM(IOS)
  63     void layerWillBeDestroyed();
  64 #endif
  65
  66     RenderLayer& owningLayer() const { return m_owningLayer; }
  67
  68     enum class UpdateAfterLayoutFlags {
  69         NeedsFullRepaint    = 1 << 0,
  70         IsUpdateRoot        = 1 << 1
  71     };
  72     void updateAfterLayout(OptionSet<UpdateAfterLayoutFlags>);
  73
  74     // Returns true if layer configuration changed.
  75     bool updateConfiguration();
  76
  77     // Update graphics layer position and bounds.
  78     void updateGeometry();
  79
  80     // Update state the requires that descendant layers have been updated.
  81     void updateAfterDescendants();
  82
  83     // Update contents and clipping structure.
  84     void updateDrawsContent();
  85
  86     GraphicsLayer* graphicsLayer() const { return m_graphicsLayer.get(); }
  87
  88     // Layer to clip children
  89     bool hasClippingLayer() const { return (m_childContainmentLayer && !m_isFrameLayerWithTiledBacking); }
  90     GraphicsLayer* clippingLayer() const { return !m_isFrameLayerWithTiledBacking ? m_childContainmentLayer.get() : nullptr; }
  91
  92     // Layer to get clipped by ancestor
  93     bool hasAncestorClippingLayer() const { return m_ancestorClippingLayer != nullptr; }
  94     GraphicsLayer* ancestorClippingLayer() const { return m_ancestorClippingLayer.get(); }
  95
  96     GraphicsLayer* contentsContainmentLayer() const { return m_contentsContainmentLayer.get(); }
  97
  98     GraphicsLayer* foregroundLayer() const { return m_foregroundLayer.get(); }
  99     GraphicsLayer* backgroundLayer() const { return m_backgroundLayer.get(); }
 100     bool backgroundLayerPaintsFixedRootBackground() const { return m_backgroundLayerPaintsFixedRootBackground; }
 101
 102     bool requiresBackgroundLayer() const { return m_requiresBackgroundLayer; }
 103     void setRequiresBackgroundLayer(bool);
 104
 105     bool hasScrollingLayer() const { return m_scrollingLayer != nullptr; }
 106     GraphicsLayer* scrollingLayer() const { return m_scrollingLayer.get(); }
 107     GraphicsLayer* scrollingContentsLayer() const { return m_scrollingContentsLayer.get(); }
 108
 109     void detachFromScrollingCoordinator(OptionSet<LayerScrollCoordinationRole>);
 110
 111     ScrollingNodeID scrollingNodeIDForRole(LayerScrollCoordinationRole role) const
 112     {
 113         switch (role) {
 114         case Scrolling:
 115             return m_scrollingNodeID;
 116         case ViewportConstrained:
 117             return m_viewportConstrainedNodeID;
 118         }
 119         return 0;
 120     }
 121
 122     void setScrollingNodeIDForRole(ScrollingNodeID nodeID, LayerScrollCoordinationRole role)
 123     {
 124         switch (role) {
 125         case Scrolling:
 126             m_scrollingNodeID = nodeID;
 127             break;
 128         case ViewportConstrained:
 129             m_viewportConstrainedNodeID = nodeID;
 130             setIsScrollCoordinatedWithViewportConstrainedRole(nodeID);
 131             break;
 132         }
 133     }
 134
 135     ScrollingNodeID scrollingNodeIDForChildren() const { return m_scrollingNodeID ? m_scrollingNodeID : m_viewportConstrainedNodeID; }
 136
 137     void setIsScrollCoordinatedWithViewportConstrainedRole(bool);
 138
 139     bool hasMaskLayer() const { return m_maskLayer != 0; }
 140     bool hasChildClippingMaskLayer() const { return m_childClippingMaskLayer != nullptr; }
 141
 142     GraphicsLayer* parentForSublayers() const;
 143     GraphicsLayer* childForSuperlayers() const;
 144
 145     // RenderLayers with backing normally short-circuit paintLayer() because
 146     // their content is rendered via callbacks from GraphicsLayer. However, the document
 147     // layer is special, because it has a GraphicsLayer to act as a container for the GraphicsLayers
 148     // for descendants, but its contents usually render into the window (in which case this returns true).
 149     // This returns false for other layers, and when the document layer actually needs to paint into its backing store
 150     // for some reason.
 151     bool paintsIntoWindow() const;
 152
 153     // Returns true for a composited layer that has no backing store of its own, so
 154     // paints into some ancestor layer.
 155     bool paintsIntoCompositedAncestor() const { return !m_requiresOwnBackingStore; }
 156
 157     void setRequiresOwnBackingStore(bool);
 158
 159     void setContentsNeedDisplay(GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
 160     // r is in the coordinate space of the layer's render object
 161     void setContentsNeedDisplayInRect(const LayoutRect&, GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
 162
 163     // Notification from the renderer that its content changed.
 164     void contentChanged(ContentChangeType);
 165
 166     // Interface to start, finish, suspend and resume animations and transitions
 167     bool startTransition(double, CSSPropertyID, const RenderStyle* fromStyle, const RenderStyle* toStyle);
 168     void transitionPaused(double timeOffset, CSSPropertyID);
 169     void transitionFinished(CSSPropertyID);
 170
 171     bool startAnimation(double timeOffset, const Animation* anim, const KeyframeList& keyframes);
 172     void animationPaused(double timeOffset, const String& name);
 173     void animationSeeked(double timeOffset, const String& name);
 174     void animationFinished(const String& name);
 175
 176     void suspendAnimations(MonotonicTime = MonotonicTime());
 177     void resumeAnimations();
 178
 179     LayoutRect compositedBounds() const;
 180     void setCompositedBounds(const LayoutRect&);
 181     void updateCompositedBounds();
 182
 183     void updateAfterWidgetResize();
 184     void positionOverflowControlsLayers();
 185     bool hasUnpositionedOverflowControlsLayers() const;
 186
 187     bool isFrameLayerWithTiledBacking() const { return m_isFrameLayerWithTiledBacking; }
 188
 189     WEBCORE_EXPORT TiledBacking* tiledBacking() const;
 190     void adjustTiledBackingCoverage();
 191     void setTiledBackingHasMargins(bool hasExtendedBackgroundOnLeftAndRight, bool hasExtendedBackgroundOnTopAndBottom);
 192
 193     void updateDebugIndicators(bool showBorder, bool showRepaintCounter);
 194     bool paintsSubpixelAntialiasedText() const { return m_paintsSubpixelAntialiasedText; }
 195
 196     // GraphicsLayerClient interface
 197     void tiledBackingUsageChanged(const GraphicsLayer*, bool /*usingTiledBacking*/) override;
 198     void notifyAnimationStarted(const GraphicsLayer*, const String& animationKey, MonotonicTime startTime) override;
 199     void notifyFlushRequired(const GraphicsLayer*) override;
 200     void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
 201
 202     void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintBehavior) override;
 203
 204     float deviceScaleFactor() const override;
 205     float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
 206
 207     bool paintsOpaquelyAtNonIntegralScales(const GraphicsLayer*) const override;
 208
 209     float pageScaleFactor() const override;
 210     float zoomedOutPageScaleFactor() const override;
 211     void didCommitChangesForLayer(const GraphicsLayer*) const override;
 212     bool getCurrentTransform(const GraphicsLayer*, TransformationMatrix&) const override;
 213
 214     bool isTrackingRepaints() const override;
 215     bool shouldSkipLayerInDump(const GraphicsLayer*, LayerTreeAsTextBehavior) const override;
 216     bool shouldDumpPropertyForLayer(const GraphicsLayer*, const char* propertyName) const override;
 217
 218     bool shouldAggressivelyRetainTiles(const GraphicsLayer*) const override;
 219     bool shouldTemporarilyRetainTileCohorts(const GraphicsLayer*) const override;
 220     bool useGiantTiles() const override;
 221     void logFilledVisibleFreshTile(unsigned) override;
 222     bool needsPixelAligment() const override { return !m_isMainFrameRenderViewLayer; }
 223
 224     LayoutSize subpixelOffsetFromRenderer() const { return m_subpixelOffsetFromRenderer; }
 225
 226 #if PLATFORM(IOS)
 227     bool needsIOSDumpRenderTreeMainFrameRenderViewLayerIsAlwaysOpaqueHack(const GraphicsLayer&) const override;
 228 #endif
 229
 230 #ifndef NDEBUG
 231     void verifyNotPainting() override;
 232 #endif
 233
 234     WEBCORE_EXPORT LayoutRect contentsBox() const;
 235
 236     // For informative purposes only.
 237     WEBCORE_EXPORT CompositingLayerType compositingLayerType() const;
 238
 239     GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
 240     GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
 241     GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
 242
 243     bool canCompositeFilters() const { return m_canCompositeFilters; }
 244 #if ENABLE(FILTERS_LEVEL_2)
 245     bool canCompositeBackdropFilters() const { return m_canCompositeBackdropFilters; }
 246 #endif
 247
 248     // Return an estimate of the backing store area (in pixels) allocated by this object's GraphicsLayers.
 249     WEBCORE_EXPORT double backingStoreMemoryEstimate() const;
 250
 251     // For testing only.
 252     WEBCORE_EXPORT void setUsesDisplayListDrawing(bool);
 253     WEBCORE_EXPORT String displayListAsText(DisplayList::AsTextFlags) const;
 254
 255     WEBCORE_EXPORT void setIsTrackingDisplayListReplay(bool);
 256     WEBCORE_EXPORT String replayDisplayListAsText(DisplayList::AsTextFlags) const;
 257
 258 private:
 259     friend class PaintedContentsInfo;
 260
 261     FloatRect backgroundBoxForSimpleContainerPainting() const;
 262
 263     void createPrimaryGraphicsLayer();
 264     void destroyGraphicsLayers();
 265
 266     void willDestroyLayer(const GraphicsLayer*);
 267
 268     LayoutRect compositedBoundsIncludingMargin() const;
 269
 270     std::unique_ptr<GraphicsLayer> createGraphicsLayer(const String&, GraphicsLayer::Type = GraphicsLayer::Type::Normal);
 271
 272     RenderLayerModelObject& renderer() const { return m_owningLayer.renderer(); }
 273     RenderBox* renderBox() const { return m_owningLayer.renderBox(); }
 274     RenderLayerCompositor& compositor() const { return m_owningLayer.compositor(); }
 275
 276     void updateInternalHierarchy();
 277     bool updateAncestorClippingLayer(bool needsAncestorClip);
 278     bool updateDescendantClippingLayer(bool needsDescendantClip);
 279     bool updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer);
 280     bool updateForegroundLayer(bool needsForegroundLayer);
 281     bool updateBackgroundLayer(bool needsBackgroundLayer);
 282     void updateMaskingLayer(bool hasMask, bool hasClipPath);
 283     bool requiresHorizontalScrollbarLayer() const;
 284     bool requiresVerticalScrollbarLayer() const;
 285     bool requiresScrollCornerLayer() const;
 286     bool updateScrollingLayers(bool scrollingLayers);
 287
 288     void updateChildClippingStrategy(bool needsDescendantsClippingLayer);
 289
 290     void updateMaskingLayerGeometry();
 291
 292     void updateRootLayerConfiguration();
 293
 294     void setBackgroundLayerPaintsFixedRootBackground(bool);
 295
 296     GraphicsLayerPaintingPhase paintingPhaseForPrimaryLayer() const;
 297
 298     LayoutSize contentOffsetInCompostingLayer() const;
 299     // Result is transform origin in device pixels.
 300     FloatPoint3D computeTransformOriginForPainting(const LayoutRect& borderBox) const;
 301
 302     void updateOpacity(const RenderStyle&);
 303     void updateTransform(const RenderStyle&);
 304     void updateFilters(const RenderStyle&);
 305 #if ENABLE(FILTERS_LEVEL_2)
 306     void updateBackdropFilters(const RenderStyle&);
 307     void updateBackdropFiltersGeometry();
 308 #endif
 309 #if ENABLE(CSS_COMPOSITING)
 310     void updateBlendMode(const RenderStyle&);
 311 #endif
 312     void updateCustomAppearance(const RenderStyle&);
 313
 314     // Return the opacity value that this layer should use for compositing.
 315     float compositingOpacity(float rendererOpacity) const;
 316     Color rendererBackgroundColor() const;
 317
 318     bool isMainFrameRenderViewLayer() const;
 319
 320     bool paintsBoxDecorations() const;
 321     bool paintsContent(RenderLayer::PaintedContentRequest&) const;
 322
 323     void updateDrawsContent(PaintedContentsInfo&);
 324
 325     // Returns true if this compositing layer has no visible content.
 326     bool isSimpleContainerCompositingLayer(PaintedContentsInfo&) const;
 327     // Returns true if this layer has content that needs to be rendered by painting into the backing store.
 328     bool containsPaintedContent(PaintedContentsInfo&) const;
 329     // Returns true if the RenderLayer just contains an image that we can composite directly.
 330     bool isDirectlyCompositedImage() const;
 331     void updateImageContents(PaintedContentsInfo&);
 332
 333     void updateDirectlyCompositedBoxDecorations(PaintedContentsInfo&, bool& didUpdateContentsRect);
 334     void updateDirectlyCompositedBackgroundColor(PaintedContentsInfo&, bool& didUpdateContentsRect);
 335     void updateDirectlyCompositedBackgroundImage(PaintedContentsInfo&, bool& didUpdateContentsRect);
 336
 337     void resetContentsRect();
 338
 339     bool isPaintDestinationForDescendantLayers(RenderLayer::PaintedContentRequest&) const;
 340     bool hasVisibleNonCompositedDescendants() const;
 341
 342     bool shouldClipCompositedBounds() const;
 343
 344     bool hasTiledBackingFlatteningLayer() const { return (m_childContainmentLayer && m_isFrameLayerWithTiledBacking); }
 345     GraphicsLayer* tileCacheFlatteningLayer() const { return m_isFrameLayerWithTiledBacking ? m_childContainmentLayer.get() : nullptr; }
 346
 347     void paintIntoLayer(const GraphicsLayer*, GraphicsContext&, const IntRect& paintDirtyRect, OptionSet<PaintBehavior>, GraphicsLayerPaintingPhase);
 348
 349     static CSSPropertyID graphicsLayerToCSSProperty(AnimatedPropertyID);
 350     static AnimatedPropertyID cssToGraphicsLayerProperty(CSSPropertyID);
 351
 352     bool canIssueSetNeedsDisplay() const { return !paintsIntoWindow() && !paintsIntoCompositedAncestor(); }
 353     LayoutRect computeParentGraphicsLayerRect(RenderLayer* compositedAncestor, LayoutSize& ancestorClippingLayerOffset) const;
 354     LayoutRect computePrimaryGraphicsLayerRect(const LayoutRect& parentGraphicsLayerRect) const;
 355
 356     RenderLayer& m_owningLayer;
 357
 358     std::unique_ptr<GraphicsLayer> m_ancestorClippingLayer; // Only used if we are clipped by an ancestor which is not a stacking context.
 359     std::unique_ptr<GraphicsLayer> m_contentsContainmentLayer; // Only used if we have a background layer; takes the transform.
 360     std::unique_ptr<GraphicsLayer> m_graphicsLayer;
 361     std::unique_ptr<GraphicsLayer> m_foregroundLayer; // Only used in cases where we need to draw the foreground separately.
 362     std::unique_ptr<GraphicsLayer> m_backgroundLayer; // Only used in cases where we need to draw the background separately.
 363     std::unique_ptr<GraphicsLayer> m_childContainmentLayer; // Only used if we have clipping on a stacking context with compositing children, or if the layer has a tile cache.
 364     std::unique_ptr<GraphicsLayer> m_maskLayer; // Only used if we have a mask and/or clip-path.
 365     std::unique_ptr<GraphicsLayer> m_childClippingMaskLayer; // Only used if we have to clip child layers or accelerated contents with border radius or clip-path.
 366
 367     std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
 368     std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
 369     std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
 370
 371     std::unique_ptr<GraphicsLayer> m_scrollingLayer; // Only used if the layer is using composited scrolling.
 372     std::unique_ptr<GraphicsLayer> m_scrollingContentsLayer; // Only used if the layer is using composited scrolling.
 373
 374     LayoutRect m_compositedBounds;
 375     LayoutSize m_subpixelOffsetFromRenderer; // This is the subpixel distance between the primary graphics layer and the associated renderer's bounds.
 376     LayoutSize m_compositedBoundsOffsetFromGraphicsLayer; // This is the subpixel distance between the primary graphics layer and the render layer bounds.
 377
 378     ScrollingNodeID m_viewportConstrainedNodeID { 0 };
 379     ScrollingNodeID m_scrollingNodeID { 0 };
 380
 381     bool m_artificiallyInflatedBounds { false }; // bounds had to be made non-zero to make transform-origin work
 382     bool m_isMainFrameRenderViewLayer { false };
 383     bool m_isFrameLayerWithTiledBacking { false };
 384     bool m_requiresOwnBackingStore { true };
 385     bool m_canCompositeFilters { false };
 386 #if ENABLE(FILTERS_LEVEL_2)
 387     bool m_canCompositeBackdropFilters { false };
 388 #endif
 389     bool m_backgroundLayerPaintsFixedRootBackground { false };
 390     bool m_requiresBackgroundLayer { false };
 391     bool m_paintsSubpixelAntialiasedText { false }; // This is for logging only.
 392 };
 393
 394 enum CanvasCompositingStrategy {
 395     UnacceleratedCanvas,
 396     CanvasPaintedToLayer,
 397     CanvasAsLayerContents
 398 };
 399 CanvasCompositingStrategy canvasCompositingStrategy(const RenderObject&);
 400
 401 WTF::TextStream& operator<<(WTF::TextStream&, const RenderLayerBacking&);
 402
 403 } // namespace WebCore