#pragma once
#include "ClipRect.h"
#include "GraphicsLayer.h"
#include "LayerFragment.h"
#include "PaintInfo.h"
#include "RenderBox.h"
#include "RenderPtr.h"
#include "ScrollableArea.h"
#include <memory>
namespace WebCore {
class ClipRects;
class ClipRectsCache;
class FilterEffectRenderer;
class FilterEffectRendererHelper;
class FilterOperations;
class HitTestRequest;
class HitTestResult;
class HitTestingTransformState;
class RenderFlowThread;
class RenderGeometryMap;
class RenderLayerBacking;
class RenderLayerCompositor;
class RenderMarquee;
class RenderNamedFlowFragment;
class RenderReplica;
class RenderScrollbarPart;
class RenderStyle;
class RenderView;
class Scrollbar;
class TransformationMatrix;
enum BorderRadiusClippingRule { IncludeSelfForBorderRadius, DoNotIncludeSelfForBorderRadius };
enum IncludeSelfOrNot { IncludeSelf, ExcludeSelf };
enum RepaintStatus {
NeedsNormalRepaint,
NeedsFullRepaint,
NeedsFullRepaintForPositionedMovementLayout
};
enum ClipRectsType {
PaintingClipRects, RootRelativeClipRects, AbsoluteClipRects, NumCachedClipRectsTypes,
AllClipRectTypes,
TemporaryClipRects
};
enum ShouldRespectOverflowClip {
IgnoreOverflowClip,
RespectOverflowClip
};
enum ShouldApplyRootOffsetToFragments {
ApplyRootOffsetToFragments,
IgnoreRootOffsetForFragments
};
enum LayerScrollCoordinationRole {
ViewportConstrained = 1 << 0,
Scrolling = 1 << 1
};
typedef unsigned LayerScrollCoordinationRoles;
enum class RequestState {
Unknown,
DontCare,
False,
True,
Undetermined
};
class RenderLayer final : public ScrollableArea {
WTF_MAKE_FAST_ALLOCATED;
public:
friend class RenderReplica;
explicit RenderLayer(RenderLayerModelObject&);
virtual ~RenderLayer();
#if PLATFORM(IOS)
void willBeDestroyed();
#endif
String name() const;
RenderLayerModelObject& renderer() const { return m_renderer; }
RenderBox* renderBox() const { return is<RenderBox>(renderer()) ? &downcast<RenderBox>(renderer()) : nullptr; }
RenderLayer* parent() const { return m_parent; }
RenderLayer* previousSibling() const { return m_previous; }
RenderLayer* nextSibling() const { return m_next; }
RenderLayer* firstChild() const { return m_first; }
RenderLayer* lastChild() const { return m_last; }
void addChild(RenderLayer* newChild, RenderLayer* beforeChild = nullptr);
RenderLayer* removeChild(RenderLayer*);
Page& page() const { return renderer().page(); }
void removeOnlyThisLayer();
void insertOnlyThisLayer();
void repaintIncludingDescendants();
void setBackingNeedsRepaint(GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
void setBackingNeedsRepaintInRect(const LayoutRect&, GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
void repaintIncludingNonCompositingDescendants(RenderLayerModelObject* repaintContainer);
void styleChanged(StyleDifference, const RenderStyle* oldStyle);
RenderMarquee* marquee() const { return m_marquee.get(); }
bool isNormalFlowOnly() const { return m_isNormalFlowOnly; }
bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
bool cannotBlitToWindow() const;
bool isTransparent() const { return renderer().isTransparent() || renderer().hasMask(); }
bool hasReflection() const { return renderer().hasReflection(); }
bool isReflection() const { return renderer().isReplica(); }
RenderReplica* reflection() const { return m_reflection.get(); }
RenderLayer* reflectionLayer() const;
const RenderLayer* root() const
{
const RenderLayer* curr = this;
while (curr->parent())
curr = curr->parent();
return curr;
}
const LayoutPoint& location() const { return m_topLeft; }
void setLocation(const LayoutPoint& p) { m_topLeft = p; }
const IntSize& size() const { return m_layerSize; }
void setSize(const IntSize& size) { m_layerSize = size; }
LayoutRect rect() const { return LayoutRect(location(), size()); }
int scrollWidth() const;
int scrollHeight() const;
void panScrollFromPoint(const IntPoint&);
enum ScrollOffsetClamping {
ScrollOffsetUnclamped,
ScrollOffsetClamped
};
void scrollByRecursively(const IntSize& delta, ScrollOffsetClamping = ScrollOffsetUnclamped, ScrollableArea** scrolledArea = nullptr);
WEBCORE_EXPORT void scrollToOffset(const ScrollOffset&, ScrollOffsetClamping = ScrollOffsetUnclamped);
void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(ScrollOffset(x, scrollOffset().y()), clamp); }
void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(ScrollOffset(scrollOffset().x(), y), clamp); }
void scrollToXPosition(int x, ScrollOffsetClamping = ScrollOffsetUnclamped);
void scrollToYPosition(int y, ScrollOffsetClamping = ScrollOffsetUnclamped);
void setPostLayoutScrollPosition(std::optional<ScrollPosition>);
void applyPostLayoutScrollPositionIfNeeded();
ScrollOffset scrollOffset() const { return scrollOffsetFromPosition(m_scrollPosition); }
IntSize scrollableContentsSize() const;
void availableContentSizeChanged(AvailableSizeChangeReason) override;
void scrollRectToVisible(SelectionRevealMode, const LayoutRect& absoluteRect, bool insideFixed, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
bool scrollsOverflow() const;
bool hasScrollbars() const { return m_hBar || m_vBar; }
void setHasHorizontalScrollbar(bool);
void setHasVerticalScrollbar(bool);
Ref<Scrollbar> createScrollbar(ScrollbarOrientation);
void destroyScrollbar(ScrollbarOrientation);
bool hasHorizontalScrollbar() const { return horizontalScrollbar(); }
bool hasVerticalScrollbar() const { return verticalScrollbar(); }
ScrollPosition scrollPosition() const override { return m_scrollPosition; }
Scrollbar* horizontalScrollbar() const override { return m_hBar.get(); }
Scrollbar* verticalScrollbar() const override { return m_vBar.get(); }
ScrollableArea* enclosingScrollableArea() const override;
bool isScrollableOrRubberbandable() override;
bool hasScrollableOrRubberbandableAncestor() override;
#if ENABLE(CSS_SCROLL_SNAP)
void updateSnapOffsets() override;
#endif
#if PLATFORM(IOS)
#if ENABLE(TOUCH_EVENTS)
bool handleTouchEvent(const PlatformTouchEvent&) override;
bool isTouchScrollable() const override { return true; }
#endif
bool isOverflowScroll() const override { return true; }
void didStartScroll() override;
void didEndScroll() override;
void didUpdateScroll() override;
void setIsUserScroll(bool isUserScroll) override { m_inUserScroll = isUserScroll; }
bool isInUserScroll() const { return m_inUserScroll; }
bool requiresScrollBoundsOriginUpdate() const { return m_requiresScrollBoundsOriginUpdate; }
void setRequiresScrollBoundsOriginUpdate(bool requiresUpdate = true) { m_requiresScrollBoundsOriginUpdate = requiresUpdate; }
bool hasAcceleratedTouchScrolling() const;
bool hasTouchScrollableOverflow() const;
#else
bool hasAcceleratedTouchScrolling() const { return false; }
bool hasTouchScrollableOverflow() const { return false; }
#endif
bool usesAcceleratedScrolling() const;
int verticalScrollbarWidth(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
int horizontalScrollbarHeight(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
bool hasOverflowControls() const;
bool isPointInResizeControl(const IntPoint& absolutePoint) const;
bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;
void paintOverflowControls(GraphicsContext&, const IntPoint&, const IntRect& damageRect, bool paintingOverlayControls = false);
void paintScrollCorner(GraphicsContext&, const IntPoint&, const IntRect& damageRect);
void paintResizer(GraphicsContext&, const LayoutPoint&, const LayoutRect& damageRect);
void updateScrollInfoAfterLayout();
bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
void autoscroll(const IntPoint&);
bool canResize() const;
void resize(const PlatformMouseEvent&, const LayoutSize&);
bool inResizeMode() const { return m_inResizeMode; }
void setInResizeMode(bool b) { m_inResizeMode = b; }
bool isRootLayer() const { return m_isRootLayer; }
RenderLayerCompositor& compositor() const;
void contentChanged(ContentChangeType);
bool canRender3DTransforms() const;
enum UpdateLayerPositionsFlag {
CheckForRepaint = 1 << 0,
NeedsFullRepaintInBacking = 1 << 1,
IsCompositingUpdateRoot = 1 << 2,
UpdateCompositingLayers = 1 << 3,
UpdatePagination = 1 << 4,
SeenTransformedLayer = 1 << 5,
Seen3DTransformedLayer = 1 << 6
};
typedef unsigned UpdateLayerPositionsFlags;
static const UpdateLayerPositionsFlags defaultFlags = CheckForRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers;
void updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, UpdateLayerPositionsFlags);
void updateLayerPositionsAfterOverflowScroll();
void updateLayerPositionsAfterDocumentScroll();
void positionNewlyCreatedOverflowControls();
bool hasCompositedLayerInEnclosingPaginationChain() const;
enum PaginationInclusionMode { ExcludeCompositedPaginatedLayers, IncludeCompositedPaginatedLayers };
RenderLayer* enclosingPaginationLayer(PaginationInclusionMode mode) const
{
if (mode == ExcludeCompositedPaginatedLayers && hasCompositedLayerInEnclosingPaginationChain())
return nullptr;
return m_enclosingPaginationLayer;
}
void updateTransform();
#if ENABLE(CSS_COMPOSITING)
void updateBlendMode();
#endif
const LayoutSize& offsetForInFlowPosition() const { return m_offsetForInFlowPosition; }
void clearClipRectsIncludingDescendants(ClipRectsType typeToClear = AllClipRectTypes);
void clearClipRects(ClipRectsType typeToClear = AllClipRectTypes);
void addBlockSelectionGapsBounds(const LayoutRect&);
void clearBlockSelectionGapsBounds();
void repaintBlockSelectionGaps();
bool isStackingContext() const { return isStackingContext(&renderer().style()); }
bool isStackingContainer() const { return isStackingContext() || needsCompositedScrolling(); }
RenderLayer* stackingContainer() const;
RenderLayer* enclosingStackingContainer() { return isStackingContainer() ? this : stackingContainer(); }
void dirtyZOrderLists();
void dirtyStackingContainerZOrderLists();
Vector<RenderLayer*>* posZOrderList() const
{
ASSERT(!m_zOrderListsDirty);
ASSERT(isStackingContainer() || !m_posZOrderList);
return m_posZOrderList.get();
}
bool hasNegativeZOrderList() const { return negZOrderList() && negZOrderList()->size(); }
Vector<RenderLayer*>* negZOrderList() const
{
ASSERT(!m_zOrderListsDirty);
ASSERT(isStackingContainer() || !m_negZOrderList);
return m_negZOrderList.get();
}
void dirtyNormalFlowList();
Vector<RenderLayer*>* normalFlowList() const { ASSERT(!m_normalFlowListDirty); return m_normalFlowList.get(); }
void updateLayerListsIfNeeded();
void updateDescendantsLayerListsIfNeeded(bool recursive);
bool hasVisibleContent() const { return m_hasVisibleContent; }
bool hasVisibleDescendant() const { return m_hasVisibleDescendant; }
void setHasVisibleContent();
void dirtyVisibleContentStatus();
bool hasVisibleBoxDecorationsOrBackground() const;
bool hasVisibleBoxDecorations() const;
struct PaintedContentRequest {
void makeStatesUndetermined()
{
if (hasPaintedContent == RequestState::Unknown)
hasPaintedContent = RequestState::Undetermined;
if (hasSubpixelAntialiasedText == RequestState::Unknown)
hasSubpixelAntialiasedText = RequestState::Undetermined;
}
void setHasPaintedContent() { hasPaintedContent = RequestState::True; }
void setHasSubpixelAntialiasedText() { hasSubpixelAntialiasedText = RequestState::True; }
bool needToDeterminePaintedContentState() const { return hasPaintedContent == RequestState::Unknown; }
bool needToDetermineSubpixelAntialiasedTextState() const { return hasSubpixelAntialiasedText == RequestState::Unknown; }
bool probablyHasPaintedContent() const { return hasPaintedContent == RequestState::True || hasPaintedContent == RequestState::Undetermined; }
bool probablyHasSubpixelAntialiasedText() const { return hasSubpixelAntialiasedText == RequestState::True || hasSubpixelAntialiasedText == RequestState::Undetermined; }
bool isSatisfied() const { return hasPaintedContent != RequestState::Unknown && hasSubpixelAntialiasedText != RequestState::Unknown; }
RequestState hasPaintedContent { RequestState::Unknown };
RequestState hasSubpixelAntialiasedText { RequestState::DontCare };
};
bool isVisuallyNonEmpty(PaintedContentRequest* = nullptr) const;
bool hasNonEmptyChildRenderers(PaintedContentRequest&) const;
bool hasSelfPaintingLayerDescendant() const { return m_hasSelfPaintingLayerDescendant; }
bool hasOutOfFlowPositionedDescendant() const { return m_hasOutOfFlowPositionedDescendant; }
RenderLayer* enclosingAncestorForPosition(EPosition) const;
RenderLayer* enclosingScrollableLayer() const;
RenderLayer* clippingRootForPainting() const;
RenderLayer* enclosingOverflowClipLayer(IncludeSelfOrNot) const;
RenderLayer* enclosingCompositingLayer(IncludeSelfOrNot = IncludeSelf) const;
RenderLayer* enclosingCompositingLayerForRepaint(IncludeSelfOrNot = IncludeSelf) const;
RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(ExcludeSelf); }
RenderLayer* enclosingFilterLayer(IncludeSelfOrNot = IncludeSelf) const;
RenderLayer* enclosingFilterRepaintLayer() const;
void setFilterBackendNeedsRepaintingInRect(const LayoutRect&);
bool hasAncestorWithFilterOutsets() const;
bool canUseConvertToLayerCoords() const
{
return !renderer().hasTransform() && !renderer().isSVGRoot();
}
enum ColumnOffsetAdjustment { DontAdjustForColumns, AdjustForColumns };
void convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location, ColumnOffsetAdjustment adjustForColumns = DontAdjustForColumns) const;
LayoutPoint convertToLayerCoords(const RenderLayer* ancestorLayer, const LayoutPoint&, ColumnOffsetAdjustment adjustForColumns = DontAdjustForColumns) const;
LayoutSize offsetFromAncestor(const RenderLayer*, ColumnOffsetAdjustment = DontAdjustForColumns) const;
int zIndex() const { return renderer().style().zIndex(); }
enum PaintLayerFlag {
PaintLayerHaveTransparency = 1 << 0,
PaintLayerAppliedTransform = 1 << 1,
PaintLayerTemporaryClipRects = 1 << 2,
PaintLayerPaintingReflection = 1 << 3,
PaintLayerPaintingOverlayScrollbars = 1 << 4,
PaintLayerPaintingCompositingBackgroundPhase = 1 << 5,
PaintLayerPaintingCompositingForegroundPhase = 1 << 6,
PaintLayerPaintingCompositingMaskPhase = 1 << 7,
PaintLayerPaintingCompositingClipPathPhase = 1 << 8,
PaintLayerPaintingCompositingScrollingPhase = 1 << 9,
PaintLayerPaintingOverflowContents = 1 << 10,
PaintLayerPaintingRootBackgroundOnly = 1 << 11,
PaintLayerPaintingSkipRootBackground = 1 << 12,
PaintLayerPaintingChildClippingMaskPhase = 1 << 13,
PaintLayerPaintingCompositingAllPhases = PaintLayerPaintingCompositingBackgroundPhase | PaintLayerPaintingCompositingForegroundPhase
};
typedef unsigned PaintLayerFlags;
enum class SecurityOriginPaintPolicy { AnyOrigin, AccessibleOriginOnly };
void paint(GraphicsContext&, const LayoutRect& damageRect, const LayoutSize& subpixelOffset = LayoutSize(), PaintBehavior = PaintBehaviorNormal,
RenderObject* subtreePaintRoot = nullptr, PaintLayerFlags = 0, SecurityOriginPaintPolicy = SecurityOriginPaintPolicy::AnyOrigin);
bool hitTest(const HitTestRequest&, HitTestResult&);
bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
void paintOverlayScrollbars(GraphicsContext&, const LayoutRect& damageRect, PaintBehavior, RenderObject* subtreePaintRoot = nullptr);
void paintNamedFlowThreadInsideRegion(GraphicsContext&, RenderNamedFlowFragment*, LayoutRect, LayoutPoint, PaintBehavior = PaintBehaviorNormal, PaintLayerFlags = 0);
struct ClipRectsContext {
ClipRectsContext(const RenderLayer* inRootLayer, ClipRectsType inClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize, ShouldRespectOverflowClip inRespectOverflowClip = RespectOverflowClip)
: rootLayer(inRootLayer)
, clipRectsType(inClipRectsType)
, overlayScrollbarSizeRelevancy(inOverlayScrollbarSizeRelevancy)
, respectOverflowClip(inRespectOverflowClip)
{ }
const RenderLayer* rootLayer;
ClipRectsType clipRectsType;
OverlayScrollbarSizeRelevancy overlayScrollbarSizeRelevancy;
ShouldRespectOverflowClip respectOverflowClip;
};
void calculateRects(const ClipRectsContext&, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
ClipRect& backgroundRect, ClipRect& foregroundRect, const LayoutSize& offsetFromRoot) const;
void collectFragments(LayerFragments&, const RenderLayer* rootLayer, const LayoutRect& dirtyRect,
PaginationInclusionMode,
ClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy, ShouldRespectOverflowClip, const LayoutSize& offsetFromRoot,
const LayoutRect* layerBoundingBox = nullptr, ShouldApplyRootOffsetToFragments = IgnoreRootOffsetForFragments);
LayoutRect childrenClipRect() const; LayoutRect selfClipRect() const; LayoutRect localClipRect(bool& clipExceedsBounds) const;
bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot, const LayoutRect* cachedBoundingBox = nullptr) const;
enum CalculateLayerBoundsFlag {
IncludeSelfTransform = 1 << 0,
UseLocalClipRectIfPossible = 1 << 1,
IncludeLayerFilterOutsets = 1 << 2,
ExcludeHiddenDescendants = 1 << 3,
DontConstrainForMask = 1 << 4,
IncludeCompositedDescendants = 1 << 5,
UseFragmentBoxesExcludingCompositing = 1 << 6,
UseFragmentBoxesIncludingCompositing = 1 << 7,
DefaultCalculateLayerBoundsFlags = IncludeSelfTransform | UseLocalClipRectIfPossible | IncludeLayerFilterOutsets | UseFragmentBoxesExcludingCompositing
};
typedef unsigned CalculateLayerBoundsFlags;
LayoutRect boundingBox(const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot = LayoutSize(), CalculateLayerBoundsFlags = 0) const;
LayoutRect localBoundingBox(CalculateLayerBoundsFlags = 0) const;
WEBCORE_EXPORT IntRect absoluteBoundingBox() const;
FloatRect absoluteBoundingBoxForPainting() const;
LayoutRect overlapBounds() const { return overlapBoundsIncludeChildren() ? calculateLayerBounds(this, LayoutSize()) : localBoundingBox(); }
bool getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(LayoutRect&) const;
bool overlapBoundsIncludeChildren() const { return hasFilter() && renderer().style().filter().hasFilterThatMovesPixels(); }
LayoutRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, CalculateLayerBoundsFlags = DefaultCalculateLayerBoundsFlags) const;
bool hasComputedRepaintRect() const { return m_hasComputedRepaintRect; }
LayoutRect repaintRect() const { ASSERT(hasComputedRepaintRect()); return m_repaintRect; }
LayoutRect repaintRectIncludingNonCompositingDescendants() const;
void setRepaintStatus(RepaintStatus status) { m_repaintStatus = status; }
RepaintStatus repaintStatus() const { return static_cast<RepaintStatus>(m_repaintStatus); }
LayoutUnit staticInlinePosition() const { return m_staticInlinePosition; }
LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
void setStaticInlinePosition(LayoutUnit position) { m_staticInlinePosition = position; }
void setStaticBlockPosition(LayoutUnit position) { m_staticBlockPosition = position; }
#if PLATFORM(IOS)
bool adjustForIOSCaretWhenScrolling() const { return m_adjustForIOSCaretWhenScrolling; }
void setAdjustForIOSCaretWhenScrolling(bool adjustForIOSCaretWhenScrolling) { m_adjustForIOSCaretWhenScrolling = adjustForIOSCaretWhenScrolling; }
#endif
bool hasTransform() const { return renderer().hasTransform(); }
TransformationMatrix* transform() const { return m_transform.get(); }
TransformationMatrix currentTransform(RenderStyle::ApplyTransformOrigin = RenderStyle::IncludeTransformOrigin) const;
TransformationMatrix renderableTransform(PaintBehavior) const;
TransformationMatrix perspectiveTransform() const;
FloatPoint perspectiveOrigin() const;
bool preserves3D() const { return renderer().style().transformStyle3D() == TransformStyle3DPreserve3D; }
bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
void filterNeedsRepaint();
bool hasFilter() const { return renderer().hasFilter(); }
bool hasBackdropFilter() const
{
#if ENABLE(FILTERS_LEVEL_2)
return renderer().hasBackdropFilter();
#else
return false;
#endif
}
#if ENABLE(CSS_COMPOSITING)
bool hasBlendMode() const { return renderer().hasBlendMode(); }
BlendMode blendMode() const { return static_cast<BlendMode>(m_blendMode); }
bool isolatesCompositedBlending() const { return m_hasNotIsolatedCompositedBlendingDescendants && isStackingContext(); }
bool hasNotIsolatedCompositedBlendingDescendants() const { return m_hasNotIsolatedCompositedBlendingDescendants; }
void setHasNotIsolatedCompositedBlendingDescendants(bool hasNotIsolatedCompositedBlendingDescendants)
{
m_hasNotIsolatedCompositedBlendingDescendants = hasNotIsolatedCompositedBlendingDescendants;
}
bool isolatesBlending() const { return hasNotIsolatedBlendingDescendants() && isStackingContext(); }
bool hasNotIsolatedBlendingDescendants() const { return m_hasNotIsolatedBlendingDescendants; }
bool hasNotIsolatedBlendingDescendantsStatusDirty() const { return m_hasNotIsolatedBlendingDescendantsStatusDirty; }
#else
bool hasBlendMode() const { return false; }
bool isolatesCompositedBlending() const { return false; }
bool isolatesBlending() const { return false; }
bool hasNotIsolatedBlendingDescendantsStatusDirty() const { return false; }
#endif
bool isComposited() const { return m_backing != 0; }
bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
bool hasCompositedMask() const;
RenderLayerBacking* backing() const { return m_backing.get(); }
RenderLayerBacking* ensureBacking();
void clearBacking(bool layerBeingDestroyed = false);
GraphicsLayer* layerForScrolling() const override;
GraphicsLayer* layerForHorizontalScrollbar() const override;
GraphicsLayer* layerForVerticalScrollbar() const override;
GraphicsLayer* layerForScrollCorner() const override;
bool usesCompositedScrolling() const override;
bool usesAsyncScrolling() const override;
WEBCORE_EXPORT bool needsCompositedScrolling() const;
bool paintsWithTransparency(PaintBehavior paintBehavior) const
{
return (isTransparent() || hasBlendMode() || (isolatesBlending() && !renderer().isDocumentElementRenderer())) && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());
}
bool paintsWithTransform(PaintBehavior) const;
bool shouldPaintMask(PaintBehavior, PaintLayerFlags) const;
bool shouldApplyClipPath(PaintBehavior, PaintLayerFlags) const;
bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const;
bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; }
void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; }
bool paintsWithFilters() const;
bool requiresFullLayerImageForFilters() const;
FilterEffectRenderer* filterRenderer() const;
#if !ASSERT_DISABLED
bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
#endif
Element* enclosingElement() const;
enum ViewportConstrainedNotCompositedReason {
NoNotCompositedReason,
NotCompositedForBoundsOutOfView,
NotCompositedForNonViewContainer,
NotCompositedForNoVisibleContent,
};
void setViewportConstrainedNotCompositedReason(ViewportConstrainedNotCompositedReason reason) { m_viewportConstrainedNotCompositedReason = reason; }
ViewportConstrainedNotCompositedReason viewportConstrainedNotCompositedReason() const { return static_cast<ViewportConstrainedNotCompositedReason>(m_viewportConstrainedNotCompositedReason); }
bool isRenderFlowThread() const { return renderer().isRenderFlowThread(); }
bool isOutOfFlowRenderFlowThread() const { return renderer().isOutOfFlowRenderFlowThread(); }
bool isInsideFlowThread() const { return renderer().flowThreadState() != RenderObject::NotInsideFlowThread; }
bool isInsideOutOfFlowThread() const { return renderer().flowThreadState() == RenderObject::InsideOutOfFlowThread; }
bool isDirtyRenderFlowThread() const
{
ASSERT(isRenderFlowThread());
return m_zOrderListsDirty || m_normalFlowListDirty;
}
bool isFlowThreadCollectingGraphicsLayersUnderRegions() const;
RenderLayer* enclosingFlowThreadAncestor() const;
bool shouldPlaceBlockDirectionScrollbarOnLeft() const final { return renderer().shouldPlaceBlockDirectionScrollbarOnLeft(); }
private:
enum CollectLayersBehavior { StopAtStackingContexts, StopAtStackingContainers };
struct LayerPaintingInfo {
LayerPaintingInfo(RenderLayer* inRootLayer, const LayoutRect& inDirtyRect, PaintBehavior inPaintBehavior, const LayoutSize& inSubpixelOffset, RenderObject* inSubtreePaintRoot = nullptr, OverlapTestRequestMap* inOverlapTestRequests = nullptr, bool inRequireSecurityOriginAccessForWidgets = false)
: rootLayer(inRootLayer)
, subtreePaintRoot(inSubtreePaintRoot)
, paintDirtyRect(inDirtyRect)
, subpixelOffset(inSubpixelOffset)
, overlapTestRequests(inOverlapTestRequests)
, paintBehavior(inPaintBehavior)
, requireSecurityOriginAccessForWidgets(inRequireSecurityOriginAccessForWidgets)
{ }
RenderLayer* rootLayer;
RenderObject* subtreePaintRoot; LayoutRect paintDirtyRect; LayoutSize subpixelOffset;
OverlapTestRequestMap* overlapTestRequests; PaintBehavior paintBehavior;
bool requireSecurityOriginAccessForWidgets;
bool clipToDirtyRect { true };
};
Ref<ClipRects> updateClipRects(const ClipRectsContext&);
void calculateClipRects(const ClipRectsContext&, ClipRects&) const;
ClipRects* clipRects(const ClipRectsContext&) const;
void updateZOrderLists();
void rebuildZOrderLists();
void rebuildZOrderLists(CollectLayersBehavior, std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&);
void clearZOrderLists();
void updateNormalFlowList();
bool isStackingContext(const RenderStyle* style) const { return !style->hasAutoZIndex() || isRootLayer() || m_forcedStackingContext; }
bool isDirtyStackingContainer() const { return m_zOrderListsDirty && isStackingContainer(); }
void setAncestorChainHasSelfPaintingLayerDescendant();
void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
bool acceleratedCompositingForOverflowScrollEnabled() const;
void updateDescendantsAreContiguousInStackingOrder();
void updateDescendantsAreContiguousInStackingOrderRecursive(const HashMap<const RenderLayer*, int>&, int& minIndex, int& maxIndex, int& count, bool firstIteration);
void computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* = nullptr);
void computeRepaintRectsIncludingDescendants();
void clearRepaintRects();
LayoutRect clipRectRelativeToAncestor(RenderLayer* ancestor, LayoutSize offsetFromAncestor, const LayoutRect& constrainingRect) const;
void clipToRect(GraphicsContext&, const LayerPaintingInfo&, const ClipRect&, BorderRadiusClippingRule = IncludeSelfForBorderRadius);
void restoreClip(GraphicsContext&, const LayerPaintingInfo&, const ClipRect&);
bool shouldRepaintAfterLayout() const;
void updateSelfPaintingLayer();
void updateStackingContextsAfterStyleChange(const RenderStyle* oldStyle);
void updateScrollbarsAfterStyleChange(const RenderStyle* oldStyle);
void updateScrollbarsAfterLayout();
void setAncestorChainHasOutOfFlowPositionedDescendant(RenderBlock* containingBlock);
void dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
void updateOutOfFlowPositioned(const RenderStyle* oldStyle);
void updateNeedsCompositedScrolling();
bool updateLayerPosition();
void updateLayerPositions(RenderGeometryMap* = nullptr, UpdateLayerPositionsFlags = defaultFlags);
enum UpdateLayerPositionsAfterScrollFlag {
NoFlag = 0,
IsOverflowScroll = 1 << 0,
HasSeenViewportConstrainedAncestor = 1 << 1,
HasSeenAncestorWithOverflowClip = 1 << 2,
HasChangedAncestor = 1 << 3
};
typedef unsigned UpdateLayerPositionsAfterScrollFlags;
void updateLayerPositionsAfterScroll(RenderGeometryMap*, UpdateLayerPositionsAfterScrollFlags = NoFlag);
ScrollOffset clampScrollOffset(const ScrollOffset&) const;
RenderLayer* enclosingPaginationLayerInSubtree(const RenderLayer* rootLayer, PaginationInclusionMode) const;
void setNextSibling(RenderLayer* next) { m_next = next; }
void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
void setParent(RenderLayer* parent);
void setFirstChild(RenderLayer* first) { m_first = first; }
void setLastChild(RenderLayer* last) { m_last = last; }
LayoutPoint renderBoxLocation() const { return is<RenderBox>(renderer()) ? downcast<RenderBox>(renderer()).location() : LayoutPoint(); }
void collectLayers(bool includeHiddenLayers, CollectLayersBehavior, std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&);
void updateCompositingAndLayerListsIfNeeded();
bool setupFontSubpixelQuantization(GraphicsContext&, bool& didQuantizeFonts);
Path computeClipPath(const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, WindRule&) const;
bool setupClipPath(GraphicsContext&, const LayerPaintingInfo&, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
class FilterInfo;
std::pair<FilterInfo*, std::unique_ptr<FilterEffectRendererHelper>> filterPainter(GraphicsContext&, PaintLayerFlags) const;
bool hasFilterThatIsPainting(GraphicsContext&, PaintLayerFlags) const;
std::unique_ptr<FilterEffectRendererHelper> setupFilters(GraphicsContext&, LayerPaintingInfo&, PaintLayerFlags, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
void applyFilters(FilterEffectRendererHelper*, GraphicsContext& originalContext, const LayerPaintingInfo&, const LayerFragments&);
void paintLayer(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
void paintFixedLayersInNamedFlows(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
void paintLayerContentsAndReflection(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
void paintLayerByApplyingTransform(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags, const LayoutSize& translationOffset = LayoutSize());
void paintLayerContents(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
void paintList(Vector<RenderLayer*>*, GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
void updatePaintingInfoForFragments(LayerFragments&, const LayerPaintingInfo&, PaintLayerFlags, bool shouldPaintContent, const LayoutSize& offsetFromRoot);
void paintBackgroundForFragments(const LayerFragments&, GraphicsContext&, GraphicsContext& transparencyLayerContext,
const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo&, PaintBehavior, RenderObject* paintingRootForRenderer);
void paintForegroundForFragments(const LayerFragments&, GraphicsContext&, GraphicsContext& transparencyLayerContext,
const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo&, PaintBehavior, RenderObject* paintingRootForRenderer);
void paintForegroundForFragmentsWithPhase(PaintPhase, const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, PaintBehavior, RenderObject* paintingRootForRenderer);
void paintOutlineForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, PaintBehavior, RenderObject* paintingRootForRenderer);
void paintOverflowControlsForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&);
void paintMaskForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, PaintBehavior, RenderObject* paintingRootForRenderer);
void paintChildClippingMaskForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, PaintBehavior, RenderObject* paintingRootForRenderer);
void paintTransformedLayerIntoFragments(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
RenderLayer* transparentPaintingAncestor();
void beginTransparencyLayers(GraphicsContext&, const LayerPaintingInfo&, const LayoutRect& dirtyRect);
RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
const LayoutRect& hitTestRect, const HitTestLocation&, bool appliedTransform,
const HitTestingTransformState* = nullptr, double* zOffset = nullptr);
RenderLayer* hitTestLayerByApplyingTransform(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = nullptr, double* zOffset = nullptr,
const LayoutSize& translationOffset = LayoutSize());
RenderLayer* hitTestList(Vector<RenderLayer*>*, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
const LayoutRect& hitTestRect, const HitTestLocation&,
const HitTestingTransformState*, double* zOffsetForDescendants, double* zOffset,
const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
RenderLayer* hitTestFixedLayersInNamedFlows(RenderLayer* rootLayer,
const HitTestRequest&, HitTestResult&,
const LayoutRect& hitTestRect, const HitTestLocation&,
const HitTestingTransformState*,
double* zOffsetForDescendants, double* zOffset,
const HitTestingTransformState* unflattenedTransformState,
bool depthSortDescendants);
Ref<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
const LayoutRect& hitTestRect, const HitTestLocation&,
const HitTestingTransformState* containerTransformState,
const LayoutSize& translationOffset = LayoutSize()) const;
bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutRect& layerBounds, const HitTestLocation&, HitTestFilter) const;
bool hitTestContentsForFragments(const LayerFragments&, const HitTestRequest&, HitTestResult&, const HitTestLocation&, HitTestFilter, bool& insideClipRect) const;
bool hitTestResizerInFragments(const LayerFragments&, const HitTestLocation&) const;
RenderLayer* hitTestTransformedLayerInFragments(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = nullptr, double* zOffset = nullptr);
bool listBackgroundIsKnownToBeOpaqueInRect(const Vector<RenderLayer*>*, const LayoutRect&) const;
void computeScrollDimensions();
bool hasHorizontalOverflow() const;
bool hasVerticalOverflow() const;
bool hasScrollableHorizontalOverflow() const;
bool hasScrollableVerticalOverflow() const;
bool showsOverflowControls() const;
bool shouldBeNormalFlowOnly() const;
bool shouldBeSelfPaintingLayer() const;
int scrollOffset(ScrollbarOrientation) const override;
void invalidateScrollbarRect(Scrollbar&, const IntRect&) override;
void invalidateScrollCornerRect(const IntRect&) override;
bool isActive() const override;
bool isScrollCornerVisible() const override;
IntRect scrollCornerRect() const override;
IntRect convertFromScrollbarToContainingView(const Scrollbar&, const IntRect&) const override;
IntRect convertFromContainingViewToScrollbar(const Scrollbar&, const IntRect&) const override;
IntPoint convertFromScrollbarToContainingView(const Scrollbar&, const IntPoint&) const override;
IntPoint convertFromContainingViewToScrollbar(const Scrollbar&, const IntPoint&) const override;
int scrollSize(ScrollbarOrientation) const override;
void setScrollOffset(const ScrollOffset&) override;
IntRect visibleContentRectInternal(VisibleContentRectIncludesScrollbars, VisibleContentRectBehavior) const override;
IntSize visibleSize() const override;
IntSize contentsSize() const override;
IntSize overhangAmount() const override;
IntPoint lastKnownMousePosition() const override;
bool isHandlingWheelEvent() const override;
bool shouldSuspendScrollAnimations() const override;
IntRect scrollableAreaBoundingBox(bool* isInsideFixed = nullptr) const override;
bool isRubberBandInProgress() const override;
bool forceUpdateScrollbarsOnMainThreadForPerformanceTesting() const override;
#if ENABLE(CSS_SCROLL_SNAP)
bool isScrollSnapInProgress() const override;
#endif
bool usesMockScrollAnimator() const override;
void logMockScrollAnimatorMessage(const String&) const override;
#if PLATFORM(IOS)
void registerAsTouchEventListenerForScrolling();
void unregisterAsTouchEventListenerForScrolling();
#endif
LayoutRect scrollCornerAndResizerRect() const;
void scrollTo(const ScrollPosition&);
void updateCompositingLayersAfterScroll();
IntSize scrollbarOffset(const Scrollbar&) const;
void updateScrollableAreaSet(bool hasOverflow);
bool allowsCurrentScroll() const;
void dirtyAncestorChainVisibleDescendantStatus();
void setAncestorChainHasVisibleDescendant();
void updateDescendantDependentFlags(HashSet<const RenderObject*>* outOfFlowDescendantContainingBlocks = nullptr);
bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
bool hasTransformedAncestor() const { return m_hasTransformedAncestor; }
bool has3DTransformedAncestor() const { return m_has3DTransformedAncestor; }
void dirty3DTransformedDescendantStatus();
bool update3DTransformedDescendantStatus();
void createReflection();
void removeReflection();
RenderStyle createReflectionStyle();
bool paintingInsideReflection() const { return m_paintingInsideReflection; }
void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; }
void updateOrRemoveFilterClients();
void updateOrRemoveFilterEffectRenderer();
#if ENABLE(CSS_COMPOSITING)
void updateAncestorChainHasBlendingDescendants();
void dirtyAncestorChainHasBlendingDescendants();
#endif
Ref<ClipRects> parentClipRects(const ClipRectsContext&) const;
ClipRect backgroundClipRect(const ClipRectsContext&) const;
RenderLayer* enclosingTransformedAncestor() const;
LayoutRect getRectToExpose(const LayoutRect& visibleRect, const LayoutRect& exposeRect, bool insideFixed, const ScrollAlignment& alignX, const ScrollAlignment& alignY) const;
LayoutPoint absoluteToContents(const LayoutPoint&) const;
void positionOverflowControls(const IntSize&);
void updateScrollCornerStyle();
void updateResizerStyle();
void drawPlatformResizerImage(GraphicsContext&, const LayoutRect& resizerCornerRect);
void updatePagination();
void setHasCompositingDescendant(bool b) { m_hasCompositingDescendant = b; }
enum class IndirectCompositingReason {
None,
Stacking,
Overlap,
BackgroundLayer,
GraphicalEffect, Perspective,
Preserve3D
};
void setIndirectCompositingReason(IndirectCompositingReason reason) { m_indirectCompositingReason = static_cast<unsigned>(reason); }
IndirectCompositingReason indirectCompositingReason() const { return static_cast<IndirectCompositingReason>(m_indirectCompositingReason); }
bool mustCompositeForIndirectReasons() const { return m_indirectCompositingReason; }
bool canBeStackingContainer() const;
friend class RenderLayerBacking;
friend class RenderLayerCompositor;
friend class RenderLayerModelObject;
LayoutUnit overflowTop() const;
LayoutUnit overflowBottom() const;
LayoutUnit overflowLeft() const;
LayoutUnit overflowRight() const;
IntRect rectForHorizontalScrollbar(const IntRect& borderBoxRect) const;
IntRect rectForVerticalScrollbar(const IntRect& borderBoxRect) const;
LayoutUnit verticalScrollbarStart(int minX, int maxX) const;
LayoutUnit horizontalScrollbarStart(int minX) const;
bool overflowControlsIntersectRect(const IntRect& localRect) const;
RenderLayer* hitTestFlowThreadIfRegionForFragments(const LayerFragments&, RenderLayer*, const HitTestRequest&, HitTestResult&,
const LayoutRect&, const HitTestLocation&,
const HitTestingTransformState*, double* zOffsetForDescendants,
double* zOffset, const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
void paintFlowThreadIfRegionForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
bool mapLayerClipRectsToFragmentationLayer(ClipRects&) const;
RenderNamedFlowFragment* currentRenderNamedFlowFragment() const;
const bool m_isRootLayer : 1;
const bool m_forcedStackingContext : 1;
bool m_inResizeMode : 1;
bool m_scrollDimensionsDirty : 1;
bool m_zOrderListsDirty : 1;
bool m_normalFlowListDirty: 1;
bool m_isNormalFlowOnly : 1;
bool m_isSelfPaintingLayer : 1;
bool m_hasSelfPaintingLayerDescendant : 1;
bool m_hasSelfPaintingLayerDescendantDirty : 1;
bool m_hasOutOfFlowPositionedDescendant : 1;
bool m_hasOutOfFlowPositionedDescendantDirty : 1;
bool m_needsCompositedScrolling : 1;
bool m_descendantsAreContiguousInStackingOrder : 1;
bool m_usedTransparency : 1; bool m_paintingInsideReflection : 1; bool m_inOverflowRelayout : 1;
unsigned m_repaintStatus : 2;
bool m_visibleContentStatusDirty : 1;
bool m_hasVisibleContent : 1;
bool m_visibleDescendantStatusDirty : 1;
bool m_hasVisibleDescendant : 1;
bool m_registeredScrollableArea : 1;
bool m_3DTransformedDescendantStatusDirty : 1;
bool m_has3DTransformedDescendant : 1; bool m_hasCompositingDescendant : 1;
bool m_hasTransformedAncestor : 1;
bool m_has3DTransformedAncestor : 1;
unsigned m_indirectCompositingReason : 3;
unsigned m_viewportConstrainedNotCompositedReason : 2;
#if PLATFORM(IOS)
bool m_adjustForIOSCaretWhenScrolling : 1;
#if ENABLE(IOS_TOUCH_EVENTS)
bool m_registeredAsTouchEventListenerForScrolling : 1;
#endif
bool m_inUserScroll : 1;
bool m_requiresScrollBoundsOriginUpdate : 1;
#endif
bool m_containsDirtyOverlayScrollbars : 1;
bool m_updatingMarqueePosition : 1;
#if !ASSERT_DISABLED
bool m_layerListMutationAllowed : 1;
#endif
bool m_hasFilterInfo : 1;
bool m_hasComputedRepaintRect : 1;
#if ENABLE(CSS_COMPOSITING)
unsigned m_blendMode : 5;
bool m_hasNotIsolatedCompositedBlendingDescendants : 1;
bool m_hasNotIsolatedBlendingDescendants : 1;
bool m_hasNotIsolatedBlendingDescendantsStatusDirty : 1;
#endif
RenderLayerModelObject& m_renderer;
RenderLayer* m_parent;
RenderLayer* m_previous;
RenderLayer* m_next;
RenderLayer* m_first;
RenderLayer* m_last;
LayoutRect m_repaintRect; LayoutRect m_outlineBox;
LayoutSize m_offsetForInFlowPosition;
LayoutPoint m_topLeft;
IntSize m_layerSize;
ScrollPosition m_scrollPosition;
std::optional<ScrollPosition> m_postLayoutScrollPosition;
IntSize m_scrollSize;
RefPtr<Scrollbar> m_hBar;
RefPtr<Scrollbar> m_vBar;
std::unique_ptr<Vector<RenderLayer*>> m_posZOrderList;
std::unique_ptr<Vector<RenderLayer*>> m_negZOrderList;
std::unique_ptr<Vector<RenderLayer*>> m_normalFlowList;
std::unique_ptr<ClipRectsCache> m_clipRectsCache;
IntPoint m_cachedOverlayScrollbarOffset;
std::unique_ptr<RenderMarquee> m_marquee;
LayoutUnit m_staticInlinePosition;
LayoutUnit m_staticBlockPosition;
std::unique_ptr<TransformationMatrix> m_transform;
RenderPtr<RenderReplica> m_reflection;
RenderPtr<RenderScrollbarPart> m_scrollCorner;
RenderPtr<RenderScrollbarPart> m_resizer;
RenderLayer* m_enclosingPaginationLayer;
IntRect m_blockSelectionGapsBounds;
std::unique_ptr<RenderLayerBacking> m_backing;
};
inline void RenderLayer::clearZOrderLists()
{
ASSERT(!isStackingContainer());
ASSERT(m_layerListMutationAllowed);
m_posZOrderList = nullptr;
m_negZOrderList = nullptr;
}
inline void RenderLayer::updateZOrderLists()
{
if (!m_zOrderListsDirty)
return;
if (!isStackingContainer()) {
clearZOrderLists();
m_zOrderListsDirty = false;
return;
}
rebuildZOrderLists();
}
#if !ASSERT_DISABLED
class LayerListMutationDetector {
public:
LayerListMutationDetector(RenderLayer* layer)
: m_layer(layer)
, m_previousMutationAllowedState(layer->layerListMutationAllowed())
{
m_layer->setLayerListMutationAllowed(false);
}
~LayerListMutationDetector()
{
m_layer->setLayerListMutationAllowed(m_previousMutationAllowedState);
}
private:
RenderLayer* m_layer;
bool m_previousMutationAllowedState;
};
#endif
void makeMatrixRenderable(TransformationMatrix&, bool has3DRendering);
bool compositedWithOwnBackingStore(const RenderLayer&);
}
#if ENABLE(TREE_DEBUGGING)
void showLayerTree(const WebCore::RenderLayer*);
void showLayerTree(const WebCore::RenderObject*);
#endif