RenderLayerCompositor.h [plain text]
#ifndef RenderLayerCompositor_h
#define RenderLayerCompositor_h
#include "ChromeClient.h"
#include "GraphicsLayerClient.h"
#include "GraphicsLayerUpdater.h"
#include "RenderLayer.h"
#include <wtf/HashMap.h>
namespace WebCore {
class FixedPositionViewportConstraints;
class GraphicsLayer;
class GraphicsLayerUpdater;
class RenderEmbeddedObject;
class RenderNamedFlowFragment;
class RenderVideo;
class RenderWidget;
class ScrollingCoordinator;
class StickyPositionViewportConstraints;
class TiledBacking;
typedef unsigned LayerTreeFlags;
enum CompositingUpdateType {
CompositingUpdateAfterStyleChange,
CompositingUpdateAfterLayout,
CompositingUpdateOnHitTest,
CompositingUpdateOnScroll,
CompositingUpdateOnCompositedScroll
};
enum {
CompositingReasonNone = 0,
CompositingReason3DTransform = 1 << 0,
CompositingReasonVideo = 1 << 1,
CompositingReasonCanvas = 1 << 2,
CompositingReasonPlugin = 1 << 3,
CompositingReasonIFrame = 1 << 4,
CompositingReasonBackfaceVisibilityHidden = 1 << 5,
CompositingReasonClipsCompositingDescendants = 1 << 6,
CompositingReasonAnimation = 1 << 7,
CompositingReasonFilters = 1 << 8,
CompositingReasonPositionFixed = 1 << 9,
CompositingReasonPositionSticky = 1 << 10,
CompositingReasonOverflowScrollingTouch = 1 << 11,
CompositingReasonStacking = 1 << 12,
CompositingReasonOverlap = 1 << 13,
CompositingReasonNegativeZIndexChildren = 1 << 14,
CompositingReasonTransformWithCompositedDescendants = 1 << 15,
CompositingReasonOpacityWithCompositedDescendants = 1 << 16,
CompositingReasonMaskWithCompositedDescendants = 1 << 17,
CompositingReasonReflectionWithCompositedDescendants = 1 << 18,
CompositingReasonFilterWithCompositedDescendants = 1 << 19,
CompositingReasonBlendingWithCompositedDescendants = 1 << 20,
CompositingReasonPerspective = 1 << 21,
CompositingReasonPreserve3D = 1 << 22,
CompositingReasonRoot = 1 << 23,
CompositingReasonIsolatesCompositedBlendingDescendants = 1 << 24,
};
typedef unsigned CompositingReasons;
class RenderLayerCompositor : public GraphicsLayerClient, public GraphicsLayerUpdaterClient {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit RenderLayerCompositor(RenderView&);
~RenderLayerCompositor();
bool inCompositingMode() const { return m_compositing; }
void enableCompositingMode(bool enable = true);
bool inForcedCompositingMode() const { return m_forceCompositingMode; }
bool hasAcceleratedCompositing() const { return m_hasAcceleratedCompositing; }
bool canRender3DTransforms() const;
void cacheAcceleratedCompositingFlags();
void setCompositingLayersNeedRebuild(bool needRebuild = true);
bool compositingLayersNeedRebuild() const { return m_compositingLayersNeedRebuild; }
void scheduleLayerFlush(bool canThrottle);
void flushPendingLayerChanges(bool isFlushRoot = true);
RenderLayerCompositor* enclosingCompositorFlushingLayers() const;
void didFlushChangesForLayer(RenderLayer&, const GraphicsLayer*);
void didChangeVisibleRect();
void updateCompositingLayers(CompositingUpdateType, RenderLayer* updateRoot = nullptr);
void scheduleCompositingLayerUpdate();
enum CompositingChangeRepaint { CompositingChangeRepaintNow, CompositingChangeWillRepaintLater };
bool updateLayerCompositingState(RenderLayer&, CompositingChangeRepaint = CompositingChangeRepaintNow);
void updateCompositingDescendantGeometry(RenderLayer& compositingAncestor, RenderLayer&, bool compositedChildrenOnly);
bool clippedByAncestor(RenderLayer&) const;
bool clipsCompositingDescendants(const RenderLayer&) const;
bool needsContentsCompositingLayer(const RenderLayer&) const;
bool supportsFixedRootBackgroundCompositing() const;
bool needsFixedRootBackgroundLayer(const RenderLayer&) const;
GraphicsLayer* fixedRootBackgroundLayer() const;
void repaintOnCompositingChange(RenderLayer&);
void repaintInCompositedAncestor(RenderLayer&, const LayoutRect&);
void layerWasAdded(RenderLayer& parent, RenderLayer& child);
void layerWillBeRemoved(RenderLayer& parent, RenderLayer& child);
void layerStyleChanged(RenderLayer&, const RenderStyle* oldStyle);
RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer&) const;
void repaintCompositedLayers();
bool requiresOwnBackingStore(const RenderLayer&, const RenderLayer* compositingAncestorLayer, const LayoutRect& layerCompositedBoundsInAncestor, const LayoutRect& ancestorCompositedBounds) const;
RenderLayer& rootRenderLayer() const;
GraphicsLayer* rootGraphicsLayer() const;
GraphicsLayer* scrollLayer() const;
GraphicsLayer* clipLayer() const;
GraphicsLayer* rootContentLayer() const;
#if ENABLE(RUBBER_BANDING)
GraphicsLayer* headerLayer() const;
GraphicsLayer* footerLayer() const;
#endif
enum RootLayerAttachment {
RootLayerUnattached,
RootLayerAttachedViaChromeClient,
RootLayerAttachedViaEnclosingFrame
};
RootLayerAttachment rootLayerAttachment() const { return m_rootLayerAttachment; }
void updateRootLayerAttachment();
void updateRootLayerPosition();
void setIsInWindow(bool);
void clearBackingForAllLayers();
void layerBecameComposited(const RenderLayer&) { ++m_compositedLayerCount; }
void layerBecameNonComposited(const RenderLayer&);
#if ENABLE(VIDEO)
bool canAccelerateVideoRendering(RenderVideo&) const;
#endif
bool has3DContent() const;
static bool allowsIndependentlyCompositedFrames(const FrameView*);
bool shouldPropagateCompositingToEnclosingFrame() const;
static RenderLayerCompositor* frameContentsCompositor(RenderWidget*);
static bool parentFrameContentLayers(RenderWidget*);
void frameViewDidChangeLocation(const IntPoint& contentsOffset);
void frameViewDidChangeSize();
void frameViewDidScroll();
void frameViewDidAddOrRemoveScrollbars();
void frameViewDidLayout();
void rootFixedBackgroundsChanged();
void scrollingLayerDidChange(RenderLayer&);
void fixedRootBackgroundLayerChanged();
String layerTreeAsText(LayerTreeFlags);
virtual float deviceScaleFactor() const override;
virtual float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
virtual float pageScaleFactor() const override;
virtual float zoomedOutPageScaleFactor() const override;
virtual void didCommitChangesForLayer(const GraphicsLayer*) const override;
virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
void layerTiledBackingUsageChanged(const GraphicsLayer*, bool );
bool acceleratedDrawingEnabled() const { return m_acceleratedDrawingEnabled; }
void deviceOrPageScaleFactorChanged();
void windowScreenDidChange(PlatformDisplayID);
GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
#if ENABLE(RUBBER_BANDING)
GraphicsLayer* layerForOverhangAreas() const { return m_layerForOverhangAreas.get(); }
GraphicsLayer* layerForContentShadow() const { return m_contentShadowLayer.get(); }
GraphicsLayer* updateLayerForTopOverhangArea(bool wantsLayer);
GraphicsLayer* updateLayerForBottomOverhangArea(bool wantsLayer);
GraphicsLayer* updateLayerForHeader(bool wantsLayer);
GraphicsLayer* updateLayerForFooter(bool wantsLayer);
#endif
ScrollableArea* scrollableAreaForScrollLayerID(ScrollingNodeID) const;
void updateScrollCoordinatedStatus(RenderLayer&);
void removeFromScrollCoordinatedLayers(RenderLayer&);
void willRemoveScrollingLayerWithBacking(RenderLayer&, RenderLayerBacking&);
void didAddScrollingLayer(RenderLayer&);
#if PLATFORM(IOS)
void registerAllViewportConstrainedLayers();
void unregisterAllViewportConstrainedLayers();
void registerAllScrollingLayers();
void unregisterAllScrollingLayers();
#endif
void resetTrackedRepaintRects();
void setTracksRepaints(bool);
void setShouldReevaluateCompositingAfterLayout() { m_reevaluateCompositingAfterLayout = true; }
bool viewHasTransparentBackground(Color* backgroundColor = 0) const;
bool hasNonMainLayersWithTiledBacking() const { return m_layersWithTiledBackingCount; }
CompositingReasons reasonsForCompositing(const RenderLayer&) const;
void setLayerFlushThrottlingEnabled(bool);
void disableLayerFlushThrottlingTemporarilyForInteraction();
void didPaintBacking(RenderLayerBacking*);
void setRootExtendedBackgroundColor(const Color&);
Color rootExtendedBackgroundColor() const { return m_rootExtendedBackgroundColor; }
void startTrackingLayerFlushes();
unsigned layerFlushCount() const;
private:
class OverlapMap;
virtual void notifyAnimationStarted(const GraphicsLayer*, double) override { }
virtual void notifyFlushRequired(const GraphicsLayer*) override;
virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&) override;
virtual void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const override;
virtual bool isTrackingRepaints() const override;
virtual void flushLayersSoon(GraphicsLayerUpdater&) override;
bool needsToBeComposited(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
bool requiresCompositingLayer(const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
bool canBeComposited(const RenderLayer&) const;
bool updateBacking(RenderLayer&, CompositingChangeRepaint shouldRepaint);
void clearBackingForLayerIncludingDescendants(RenderLayer&);
void setIsInWindowForLayerIncludingDescendants(RenderLayer&, bool isInWindow);
void recursiveRepaintLayer(RenderLayer&);
void addToOverlapMap(OverlapMap&, RenderLayer&, LayoutRect& layerBounds, bool& boundsComputed);
void addToOverlapMapRecursive(OverlapMap&, RenderLayer&, RenderLayer* ancestorLayer = nullptr);
void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>&);
void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer&, OverlapMap*, struct CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
void computeRegionCompositingRequirements(RenderNamedFlowFragment*, OverlapMap*, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
void computeCompositingRequirementsForNamedFlowFixed(RenderLayer&, OverlapMap*, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
void rebuildCompositingLayerTree(RenderLayer&, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
void rebuildRegionCompositingLayerTree(RenderNamedFlowFragment*, Vector<GraphicsLayer*>& childList, int depth);
void rebuildCompositingLayerTreeForNamedFlowFixed(RenderLayer&, Vector<GraphicsLayer*>& childList, int depth);
void updateLayerTreeGeometry(RenderLayer&, int depth);
void setCompositingParent(RenderLayer& childLayer, RenderLayer* parentLayer);
void removeCompositedChildren(RenderLayer&);
bool layerHas3DContent(const RenderLayer&) const;
bool isRunningAcceleratedTransformAnimation(RenderLayerModelObject&) const;
void appendOverlayLayers(Vector<GraphicsLayer*>&);
bool hasAnyAdditionalCompositedLayers(const RenderLayer& rootLayer) const;
void ensureRootLayer();
void destroyRootLayer();
void attachRootLayer(RootLayerAttachment);
void detachRootLayer();
void rootLayerAttachmentChanged();
void updateOverflowControlsLayers();
void updateScrollLayerPosition();
FloatPoint positionForClipLayer() const;
void notifyIFramesOfCompositingChange();
bool isFlushingLayers() const { return m_flushingLayers; }
void updateScrollCoordinatedLayersAfterFlushIncludingSubframes();
void updateScrollCoordinatedLayersAfterFlush();
Page* page() const;
GraphicsLayerFactory* graphicsLayerFactory() const;
ScrollingCoordinator* scrollingCoordinator() const;
#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const override;
#endif
bool requiresCompositingForAnimation(RenderLayerModelObject&) const;
bool requiresCompositingForTransform(RenderLayerModelObject&) const;
bool requiresCompositingForBackfaceVisibility(RenderLayerModelObject&) const;
bool requiresCompositingForVideo(RenderLayerModelObject&) const;
bool requiresCompositingForCanvas(RenderLayerModelObject&) const;
bool requiresCompositingForPlugin(RenderLayerModelObject&) const;
bool requiresCompositingForFrame(RenderLayerModelObject&) const;
bool requiresCompositingForFilters(RenderLayerModelObject&) const;
bool requiresCompositingForScrollableFrame() const;
bool requiresCompositingForPosition(RenderLayerModelObject&, const RenderLayer&, RenderLayer::ViewportConstrainedNotCompositedReason* = 0) const;
bool requiresCompositingForOverflowScrolling(const RenderLayer&) const;
bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
#if PLATFORM(IOS)
bool requiresCompositingForScrolling(const RenderLayer&) const;
void updateCustomLayersAfterFlush();
ChromeClient* chromeClient() const;
#endif
enum ScrollCoordinationReason {
FixedOrSticky = 1 << 0,
Scrolling = 1 << 1
};
typedef unsigned ScrollCoordinationReasons;
void updateScrollCoordinationForThisFrame(ScrollingNodeID);
ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, ScrollingNodeID parentNodeID);
void updateScrollCoordinatedLayer(RenderLayer&, ScrollCoordinationReasons);
void detachScrollCoordinatedLayer(RenderLayer&);
void reattachSubframeScrollLayers();
FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer&) const;
bool requiresScrollLayer(RootLayerAttachment) const;
bool requiresHorizontalScrollbarLayer() const;
bool requiresVerticalScrollbarLayer() const;
bool requiresScrollCornerLayer() const;
#if ENABLE(RUBBER_BANDING)
bool requiresOverhangAreasLayer() const;
bool requiresContentShadowLayer() const;
#endif
bool hasCoordinatedScrolling() const;
bool isAsyncScrollableStickyLayer(const RenderLayer&, const RenderLayer** enclosingAcceleratedOverflowLayer = nullptr) const;
bool isViewportConstrainedFixedOrStickyLayer(const RenderLayer&) const;
bool shouldCompositeOverflowControls() const;
void scheduleLayerFlushNow();
bool isThrottlingLayerFlushes() const;
void startInitialLayerFlushTimerIfNeeded();
void startLayerFlushTimerIfNeeded();
void layerFlushTimerFired(Timer<RenderLayerCompositor>&);
void paintRelatedMilestonesTimerFired(Timer<RenderLayerCompositor>&);
#if !LOG_DISABLED
const char* logReasonsForCompositing(const RenderLayer&);
void logLayerInfo(const RenderLayer&, int depth);
#endif
bool mainFrameBackingIsTiled() const;
private:
RenderView& m_renderView;
std::unique_ptr<GraphicsLayer> m_rootContentLayer;
Timer<RenderLayerCompositor> m_updateCompositingLayersTimer;
bool m_hasAcceleratedCompositing;
ChromeClient::CompositingTriggerFlags m_compositingTriggers;
bool m_showDebugBorders;
bool m_showRepaintCounter;
bool m_acceleratedDrawingEnabled;
mutable bool m_reevaluateCompositingAfterLayout;
bool m_compositing;
bool m_compositingLayersNeedRebuild;
bool m_flushingLayers;
bool m_shouldFlushOnReattach;
bool m_forceCompositingMode;
bool m_inPostLayoutUpdate; bool m_subframeScrollLayersNeedReattach;
bool m_isTrackingRepaints;
int m_compositedLayerCount { 0 };
unsigned m_layersWithTiledBackingCount { 0 };
unsigned m_layerFlushCount { 0 };
RootLayerAttachment m_rootLayerAttachment;
std::unique_ptr<GraphicsLayer> m_clipLayer;
std::unique_ptr<GraphicsLayer> m_scrollLayer;
#if PLATFORM(IOS)
HashSet<RenderLayer*> m_scrollingLayers;
HashSet<RenderLayer*> m_scrollingLayersNeedingUpdate;
#endif
HashSet<RenderLayer*> m_scrollCoordinatedLayers;
HashSet<RenderLayer*> m_scrollCoordinatedLayersNeedingUpdate;
std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
#if ENABLE(RUBBER_BANDING)
std::unique_ptr<GraphicsLayer> m_layerForOverhangAreas;
std::unique_ptr<GraphicsLayer> m_contentShadowLayer;
std::unique_ptr<GraphicsLayer> m_layerForTopOverhangArea;
std::unique_ptr<GraphicsLayer> m_layerForBottomOverhangArea;
std::unique_ptr<GraphicsLayer> m_layerForHeader;
std::unique_ptr<GraphicsLayer> m_layerForFooter;
#endif
std::unique_ptr<GraphicsLayerUpdater> m_layerUpdater;
Timer<RenderLayerCompositor> m_layerFlushTimer;
bool m_layerFlushThrottlingEnabled;
bool m_layerFlushThrottlingTemporarilyDisabledForInteraction;
bool m_hasPendingLayerFlush;
Timer<RenderLayerCompositor> m_paintRelatedMilestonesTimer;
#if !LOG_DISABLED
int m_rootLayerUpdateCount { 0 };
int m_obligateCompositedLayerCount { 0 }; int m_secondaryCompositedLayerCount { 0 }; double m_obligatoryBackingStoreBytes { 0 };
double m_secondaryBackingStoreBytes { 0 };
#endif
Color m_rootExtendedBackgroundColor;
HashMap<ScrollingNodeID, RenderLayer*> m_scrollingNodeToLayerMap;
};
}
#endif // RenderLayerCompositor_h