Source/WebCore/rendering/RenderLayer.cpp - Issue 13913013: Only update composited scrolling state when necessary

Unified Diff: Source/WebCore/rendering/RenderLayer.cpp

Issue 13913013: Only update composited scrolling state when necessary (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: . Created 7 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« LayoutTests/compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html ('K') | « Source/WebCore/rendering/RenderLayer.h ('k') | Source/WebCore/rendering/RenderView.h » ('j') | Source/WebCore/rendering/RenderView.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: Source/WebCore/rendering/RenderLayer.cpp

diff --git a/Source/WebCore/rendering/RenderLayer.cpp b/Source/WebCore/rendering/RenderLayer.cpp

index 02526ae890406152bded2123cebea6f586d92108..3781c55e7d2c75a55888c6e12739d2ef44d75f91 100644

--- a/Source/WebCore/rendering/RenderLayer.cpp

+++ b/Source/WebCore/rendering/RenderLayer.cpp

@@ -149,6 +149,7 @@ RenderLayer::RenderLayer(RenderLayerModelObject* renderer)

, m_hasOutOfFlowPositionedDescendantDirty(true)

, m_needsCompositedScrolling(false)

, m_descendantsAreContiguousInStackingOrder(false)

+ , m_descendantsAreContiguousInStackingOrderDirty(true)

, m_isRootLayer(renderer->isRenderView())

, m_usedTransparency(false)

, m_paintingInsideReflection(false)

@@ -251,6 +252,7 @@ RenderLayer::~RenderLayer()

// we don't need to delete them ourselves.

clearBacking(true);

+ cancelScheduledCompositedScrollingUpdates();

if (m_scrollCorner)

m_scrollCorner->destroy();

@@ -595,7 +597,7 @@ bool RenderLayer::acceleratedCompositingForOverflowScrollEnabled() const

// And we would conclude that C could be promoted.

void RenderLayer::updateDescendantsAreContiguousInStackingOrder()

{

- if (!isStackingContext() || !acceleratedCompositingForOverflowScrollEnabled())

+ if (!m_descendantsAreContiguousInStackingOrderDirty || !isStackingContext() || !acceleratedCompositingForOverflowScrollEnabled())

return;

ASSERT(!m_normalFlowListDirty);

@@ -635,6 +637,8 @@ void RenderLayer::updateDescendantsAreContiguousInStackingOrder()

int count = 0;

bool firstIteration = true;

updateDescendantsAreContiguousInStackingOrderRecursive(lookup, minIndex, maxIndex, count, firstIteration);

+ m_descendantsAreContiguousInStackingOrderDirty = false;

}

void RenderLayer::updateDescendantsAreContiguousInStackingOrderRecursive(const HashMap<const RenderLayer*, int>& lookup, int& minIndex, int& maxIndex, int& count, bool firstIteration)

@@ -665,7 +669,7 @@ void RenderLayer::updateDescendantsAreContiguousInStackingOrderRecursive(const H

bool didUpdate = newValue != m_descendantsAreContiguousInStackingOrder;

m_descendantsAreContiguousInStackingOrder = newValue;

if (didUpdate)

- updateNeedsCompositedScrolling();

+ requestNeedsCompositedScrollingUpdate();

}

@@ -1030,6 +1034,9 @@ void RenderLayer::setAncestorChainHasVisibleDescendant()

void RenderLayer::updateDescendantDependentFlags(HashSet<const RenderObject*>* outOfFlowDescendantContainingBlocks)

{

if (m_visibleDescendantStatusDirty || m_hasSelfPaintingLayerDescendantDirty || m_hasOutOfFlowPositionedDescendantDirty) {

+ const bool hadVisibleDescendant = m_hasVisibleDescendant;

+ const bool hadOutOfFlowPositionedDescendant = m_hasOutOfFlowPositionedDescendant;

m_hasVisibleDescendant = false;

m_hasSelfPaintingLayerDescendant = false;

m_hasOutOfFlowPositionedDescendant = false;

@@ -1051,7 +1058,7 @@ void RenderLayer::updateDescendantDependentFlags(HashSet<const RenderObject*>* o

bool hasVisibleDescendant = child->m_hasVisibleContent || child->m_hasVisibleDescendant;

bool hasSelfPaintingLayerDescendant = child->isSelfPaintingLayer() || child->hasSelfPaintingLayerDescendant();

- bool hasOutOfFlowPositionedDescendant = !childOutOfFlowDescendantContainingBlocks.isEmpty();

+ bool hasOutOfFlowPositionedDescendant = !childOutOfFlowDescendantContainingBlocks.isEmpty() || child->hasOutOfFlowPositionedDescendant();

m_hasVisibleDescendant |= hasVisibleDescendant;

m_hasSelfPaintingLayerDescendant |= hasSelfPaintingLayerDescendant;

@@ -1066,14 +1073,14 @@ void RenderLayer::updateDescendantDependentFlags(HashSet<const RenderObject*>* o

m_visibleDescendantStatusDirty = false;

m_hasSelfPaintingLayerDescendantDirty = false;

- if (m_hasOutOfFlowPositionedDescendantDirty)

- updateNeedsCompositedScrolling();

m_hasOutOfFlowPositionedDescendantDirty = false;

+ if (m_hasVisibleDescendant != hadVisibleDescendant || m_hasOutOfFlowPositionedDescendant != hadOutOfFlowPositionedDescendant)

+ requestNeedsCompositedScrollingUpdate();

}

if (m_visibleContentStatusDirty) {

+ const bool hadVisibleContent = m_hasVisibleContent;

if (renderer()->style()->visibility() == VISIBLE)

m_hasVisibleContent = true;

else {

@@ -1101,6 +1108,8 @@ void RenderLayer::updateDescendantDependentFlags(HashSet<const RenderObject*>* o

}

m_visibleContentStatusDirty = false;

+ if (hadVisibleContent != m_hasVisibleContent)

+ requestNeedsCompositedScrollingUpdate();

}

@@ -1287,6 +1296,16 @@ RenderLayer* RenderLayer::stackingContainer() const

return layer;

}

+RenderLayer* RenderLayer::stackingContext() const

+ RenderLayer* layer = parent();

+ while (layer && !layer->isStackingContext())

+ layer = layer->parent();

+ ASSERT(!layer || layer->isStackingContext());

+ return layer;

static inline bool isPositionedContainer(RenderLayer* layer)

{

RenderLayerModelObject* layerRenderer = layer->renderer();

@@ -1679,6 +1698,17 @@ void RenderLayer::addChild(RenderLayer* child, RenderLayer* beforeChild)

// case where we're building up generated content layers. This is ok, since the lists will start

// off dirty in that case anyway.

child->dirtyStackingContainerZOrderLists();

+ child->requestDescendantsAreContiguousInStackingOrderUpdate();

+ // Adding an out of flow positioned descendant can only affect

+ // the opt-in decision for layers beneath and including our

+ // containing block.

+ RenderObject* containingBlock = child->renderer()->containingBlock();

+ for (RenderLayer* layer = child; layer; layer = layer->parent()) {

+ layer->requestNeedsCompositedScrollingUpdate();

+ if (layer->renderer() == containingBlock)

+ break;

+ }

}

child->updateDescendantDependentFlags();

@@ -1710,13 +1740,21 @@ RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)

if (m_last == oldChild)

m_last = oldChild->previousSibling();

+ oldChild->cancelScheduledCompositedScrollingUpdates();

if (oldChild->isNormalFlowOnly())

dirtyNormalFlowList();

- if (!oldChild->isNormalFlowOnly() || oldChild->firstChild()) {

+ if (!oldChild->isNormalFlowOnly() || oldChild->firstChild()) {

// Dirty the z-order list in which we are contained. When called via the

// reattachment process in removeOnlyThisLayer, the layer may already be disconnected

// from the main layer tree, so we need to null-check the |stackingContainer| value.

oldChild->dirtyStackingContainerZOrderLists();

+ requestDescendantsAreContiguousInStackingOrderUpdate();

+ // This could affect whether or not a layer has an out of flow

+ // positioned descendant so we need to schedule some updates.

+ for (RenderLayer* layer = this; layer; layer = layer->parent())

+ layer->requestNeedsCompositedScrollingUpdate();

}

if ((oldChild->renderer() && oldChild->renderer()->isOutOfFlowPositioned()) || oldChild->hasOutOfFlowPositionedDescendant())

@@ -1725,7 +1763,7 @@ RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)

oldChild->setPreviousSibling(0);

oldChild->setNextSibling(0);

oldChild->setParent(0);

oldChild->updateDescendantDependentFlags();

if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)

dirtyAncestorChainVisibleDescendantStatus();

@@ -1946,41 +1984,72 @@ bool RenderLayer::needsCompositedScrolling() const

void RenderLayer::updateNeedsCompositedScrolling()

{

- bool oldNeedsCompositedScrolling = m_needsCompositedScrolling;

+ bool needsCompositedScrolling = false;

FrameView* frameView = renderer()->view()->frameView();

- if (!frameView || !frameView->containsScrollableArea(this))

- m_needsCompositedScrolling = false;

- else {

+ if (frameView && frameView->containsScrollableArea(this)) {

+ updateDescendantDependentFlags();

bool forceUseCompositedScrolling = acceleratedCompositingForOverflowScrollEnabled()

&& canBeStackingContainer()

&& !hasOutOfFlowPositionedDescendant();

#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)

- m_needsCompositedScrolling = forceUseCompositedScrolling || renderer()->style()->useTouchOverflowScrolling();

+ needsCompositedScrolling = forceUseCompositedScrolling || renderer()->style()->useTouchOverflowScrolling();

#else

- m_needsCompositedScrolling = forceUseCompositedScrolling;

+ needsCompositedScrolling = forceUseCompositedScrolling;

#endif

- // We gather a boolean value for use with Google UMA histograms to

- // quantify the actual effects of a set of patches attempting to

- // relax composited scrolling requirements, thereby increasing the

- // number of composited overflow divs.

- if (acceleratedCompositingForOverflowScrollEnabled())

- HistogramSupport::histogramEnumeration("Renderer.NeedsCompositedScrolling", m_needsCompositedScrolling, 2);

}

- if (oldNeedsCompositedScrolling != m_needsCompositedScrolling) {

- updateSelfPaintingLayer();

- if (isStackingContainer())

- dirtyZOrderLists();

- else

- clearZOrderLists();

+ setNeedsCompositedScrolling(needsCompositedScrolling);

- dirtyStackingContainerZOrderLists();

+void RenderLayer::setNeedsCompositedScrolling(bool needsCompositedScrolling)

+ // We gather a boolean value for use with Google UMA histograms to

+ // quantify the actual effects of a set of patches attempting to

+ // relax composited scrolling requirements, thereby increasing the

+ // number of composited overflow divs.

+ if (acceleratedCompositingForOverflowScrollEnabled())

+ HistogramSupport::histogramEnumeration("Renderer.NeedsCompositedScrolling", needsCompositedScrolling, 2);

- compositor()->setShouldReevaluateCompositingAfterLayout();

- compositor()->setCompositingLayersNeedRebuild();

- }

+ if (m_needsCompositedScrolling == needsCompositedScrolling)

+ return;

+ m_needsCompositedScrolling = needsCompositedScrolling;

+ updateSelfPaintingLayer();

+ updateIsNormalFlowOnly();

Julien - ping for review 2013/04/09 21:06:43 Already mentioned somewhere else but isSelfPaintin

Ian Vollick 2013/04/12 03:53:14 Done.

+ if (isStackingContainer())

+ dirtyZOrderLists();

+ else

+ clearZOrderLists();

+ dirtyStackingContainerZOrderLists();

Julien - ping for review 2013/04/09 21:06:43 Wouldn't that dirty the z-order list of a stacking

Ian Vollick 2013/04/12 03:53:14 Should be ok, I think. This function starts lookin

+ compositor()->setShouldReevaluateCompositingAfterLayout();

+ compositor()->setCompositingLayersNeedRebuild();

+void RenderLayer::requestNeedsCompositedScrollingUpdate()

+ if (acceleratedCompositingForOverflowScrollEnabled())

+ ScopedCompositedScrollingUpdater(this, UpdateNeedsCompositedScrolling);

+void RenderLayer::requestDescendantsAreContiguousInStackingOrderUpdate()

+ if (acceleratedCompositingForOverflowScrollEnabled())

+ ScopedCompositedScrollingUpdater(this, UpdateDescendantsAreContiguousInStackingOrder);

+void RenderLayer::cancelScheduledCompositedScrollingUpdates() const

+ if (!renderer() || !renderer()->view())

+ return;

+ renderer()->view()->cancelScheduledCompositedScrollingUpdatesForLayer(const_cast<RenderLayer*>(this));

Julien - ping for review 2013/04/09 21:06:43 Couldn't cancelScheduledCompositedScrollingUpdates

Ian Vollick 2013/04/12 03:53:14 No longer applicable (yay).

}

static inline int adjustedScrollDelta(int beginningDelta) {

@@ -2275,7 +2344,7 @@ void RenderLayer::updateCompositingLayersAfterScroll()

// repositioning, so update compositing layers from there.

if (RenderLayer* compositingAncestor = stackingContainer()->enclosingCompositingLayer()) {

if (compositor()->compositingConsultsOverlap()) {

- if (usesCompositedScrolling() && !hasOutOfFlowPositionedDescendant())

+ if (usesCompositedScrolling())

compositor()->updateCompositingLayers(CompositingUpdateOnCompositedScroll, compositingAncestor);

else

compositor()->updateCompositingLayers(CompositingUpdateOnScroll, compositingAncestor);

@@ -5511,6 +5580,9 @@ void RenderLayer::dirtyZOrderLists()

m_negZOrderList->clear();

m_zOrderListsDirty = true;

+ m_descendantsAreContiguousInStackingOrderDirty = true;

+ requestDescendantsAreContiguousInStackingOrderUpdate();

if (!renderer()->documentBeingDestroyed()) {

compositor()->setCompositingLayersNeedRebuild();

if (acceleratedCompositingForOverflowScrollEnabled())

@@ -5520,9 +5592,18 @@ void RenderLayer::dirtyZOrderLists()

void RenderLayer::dirtyStackingContainerZOrderLists()

{

- RenderLayer* sc = stackingContainer();

- if (sc)

- sc->dirtyZOrderLists();

+ RenderLayer* stackingContainer = this->stackingContainer();

+ if (stackingContainer)

+ stackingContainer->dirtyZOrderLists();

+ // Any change that could affect our stacking container's z-order list could

+ // cause other RenderLayers in our stacking context to either opt in or out

+ // of composited scrolling. It is important that we make our stacking

+ // context aware of these z-order changes so the appropriate updating can

+ // happen.

+ RenderLayer* stackingContext = this->stackingContext();

+ if (stackingContext && stackingContext != stackingContainer)

+ stackingContext->dirtyZOrderLists();

}

void RenderLayer::dirtyNormalFlowList()

@@ -5533,6 +5614,7 @@ void RenderLayer::dirtyNormalFlowList()

m_normalFlowList->clear();

m_normalFlowListDirty = true;

+ requestDescendantsAreContiguousInStackingOrderUpdate();

if (!renderer()->documentBeingDestroyed()) {

compositor()->setCompositingLayersNeedRebuild();

if (acceleratedCompositingForOverflowScrollEnabled())

@@ -5540,6 +5622,22 @@ void RenderLayer::dirtyNormalFlowList()

}

+void RenderLayer::updateZOrderLists()

+ ScopedCompositedScrollingUpdater suspendCompositedScrollingUpdates(renderer()->view());

+ if (!m_zOrderListsDirty)

+ return;

+ if (!isStackingContainer()) {

+ clearZOrderLists();

+ m_zOrderListsDirty = false;

+ return;

+ }

+ rebuildZOrderLists();

void RenderLayer::rebuildZOrderLists()

{

ASSERT(m_layerListMutationAllowed);

@@ -5635,7 +5733,7 @@ void RenderLayer::collectLayers(bool includeHiddenLayers, CollectLayersBehavior

void RenderLayer::updateLayerListsIfNeeded()

{

- bool shouldUpdateDescendantsAreContiguousInStackingOrder = isStackingContext() && (m_zOrderListsDirty || m_normalFlowListDirty);

+ bool shouldUpdateDescendantsAreContiguousInStackingOrder = acceleratedCompositingForOverflowScrollEnabled() && isStackingContext() && (m_zOrderListsDirty || m_normalFlowListDirty) && m_descendantsAreContiguousInStackingOrderDirty;

updateZOrderLists();

updateNormalFlowList();

@@ -5741,6 +5839,18 @@ bool RenderLayer::shouldBeNormalFlowOnly() const

;

}

+void RenderLayer::updateIsNormalFlowOnly()

+ bool isNormalFlowOnly = shouldBeNormalFlowOnly();

+ if (isNormalFlowOnly != m_isNormalFlowOnly) {

Julien - ping for review 2013/04/09 21:06:43 Better with an early return.

Ian Vollick 2013/04/12 03:53:14 Done.

+ m_isNormalFlowOnly = isNormalFlowOnly;

+ RenderLayer* p = parent();

+ if (p)

+ p->dirtyNormalFlowList();

+ dirtyStackingContainerZOrderLists();

+ }

bool RenderLayer::shouldBeSelfPaintingLayer() const

{

return !isNormalFlowOnly()

@@ -5823,28 +5933,40 @@ bool RenderLayer::isVisuallyNonEmpty() const

return false;

}

-void RenderLayer::updateStackingContextsAfterStyleChange(const RenderStyle* oldStyle)

+void RenderLayer::updateVisibilityAfterStyleChange(const RenderStyle* oldStyle)

{

- if (!oldStyle)

- return;

+ EVisibility oldVisibility = VISIBLE;

+ if (oldStyle)

+ oldVisibility = oldStyle->visibility();

Julien - ping for review 2013/04/09 21:06:43 On one line? EVisibility oldVisibility = oldStyle

Ian Vollick 2013/04/12 03:53:14 Done.

- bool wasStackingContext = isStackingContext(oldStyle);

- bool isStackingContext = this->isStackingContext();

- if (isStackingContext != wasStackingContext) {

- dirtyStackingContainerZOrderLists();

- if (isStackingContext)

- dirtyZOrderLists();

- else

- clearZOrderLists();

- return;

+ if (oldVisibility != renderer()->style()->visibility()) {

Julien - ping for review 2013/04/09 21:06:43 Again, better with an early return.

Ian Vollick 2013/04/12 03:53:14 Done.

+ for (RenderLayer* layer = this; layer; layer = layer->parent())

+ layer->requestNeedsCompositedScrollingUpdate();

+ }

+void RenderLayer::updateStackingContextsAfterStyleChange(const RenderStyle* oldStyle)

+ bool wasStackingContext = false;

+ EVisibility oldVisibility = VISIBLE;

+ int oldZIndex = 0;

Julien - ping for review 2013/04/09 21:06:43 Ditto, those should be one liners.

Ian Vollick 2013/04/12 03:53:14 Done.

+ if (oldStyle) {

+ wasStackingContext = isStackingContext(oldStyle);

+ oldVisibility = oldStyle->visibility();

+ oldZIndex = oldStyle->zIndex();

}

// FIXME: RenderLayer already handles visibility changes through our visiblity dirty bits. This logic could

// likely be folded along with the rest.

- if (oldStyle->zIndex() != renderer()->style()->zIndex() || oldStyle->visibility() != renderer()->style()->visibility()) {

+ bool isStackingContext = this->isStackingContext();

+ if (isStackingContext != wasStackingContext

+ || oldVisibility != renderer()->style()->visibility()

+ || oldZIndex != renderer()->style()->zIndex()) {

dirtyStackingContainerZOrderLists();

- if (isStackingContext)

+ if (isStackingContainer())

dirtyZOrderLists();

+ requestNeedsCompositedScrollingUpdate();

}

@@ -5902,7 +6024,7 @@ void RenderLayer::setAncestorChainHasOutOfFlowPositionedDescendant(RenderObject*

layer->m_hasOutOfFlowPositionedDescendantDirty = false;

layer->m_hasOutOfFlowPositionedDescendant = true;

- layer->updateNeedsCompositedScrolling();

+ layer->requestNeedsCompositedScrollingUpdate();

if (layer->renderer() && layer->renderer() == containingBlock)

break;

@@ -5911,7 +6033,10 @@ void RenderLayer::setAncestorChainHasOutOfFlowPositionedDescendant(RenderObject*

void RenderLayer::dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus()

{

- m_hasOutOfFlowPositionedDescendantDirty = true;

+ if (m_hasOutOfFlowPositionedDescendant) {

+ m_hasOutOfFlowPositionedDescendantDirty = true;

+ requestNeedsCompositedScrollingUpdate();

+ }

if (parent())

parent()->dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();

}

@@ -5919,10 +6044,12 @@ void RenderLayer::dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus()

void RenderLayer::updateOutOfFlowPositioned(const RenderStyle* oldStyle)

{

bool wasOutOfFlowPositioned = oldStyle && (oldStyle->position() == AbsolutePosition || oldStyle->position() == FixedPosition);

- if (parent() && ((renderer() && renderer()->isOutOfFlowPositioned()) != wasOutOfFlowPositioned)) {

- parent()->dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();

- if (!renderer()->documentBeingDestroyed() && acceleratedCompositingForOverflowScrollEnabled())

- compositor()->setShouldReevaluateCompositingAfterLayout();

+ bool isOutOfFlowPositioned = renderer()->isOutOfFlowPositioned();

+ if (parent() && isOutOfFlowPositioned != wasOutOfFlowPositioned) {

+ if (isOutOfFlowPositioned)

+ parent()->setAncestorChainHasOutOfFlowPositionedDescendant(renderer()->containingBlock());

+ else

+ parent()->dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();

}

@@ -6006,15 +6133,6 @@ void RenderLayer::updateFilters(const RenderStyle* oldStyle, const RenderStyle*

void RenderLayer::styleChanged(StyleDifference, const RenderStyle* oldStyle)

{

- bool isNormalFlowOnly = shouldBeNormalFlowOnly();

- if (isNormalFlowOnly != m_isNormalFlowOnly) {

- m_isNormalFlowOnly = isNormalFlowOnly;

- RenderLayer* p = parent();

- if (p)

- p->dirtyNormalFlowList();

- dirtyStackingContainerZOrderLists();

- }

if (renderer()->style()->overflowX() == OMARQUEE && renderer()->style()->marqueeBehavior() != MNONE && renderer()->isBox()) {

if (!m_marquee)

m_marquee = adoptPtr(new RenderMarquee(this));

@@ -6027,6 +6145,7 @@ void RenderLayer::styleChanged(StyleDifference, const RenderStyle* oldStyle)

updateScrollbarsAfterStyleChange(oldStyle);

updateStackingContextsAfterStyleChange(oldStyle);

+ updateVisibilityAfterStyleChange(oldStyle);

// Overlay scrollbars can make this layer self-painting so we need

// to recompute the bit once scrollbars have been updated.

updateSelfPaintingLayer();

@@ -6064,8 +6183,6 @@ void RenderLayer::styleChanged(StyleDifference, const RenderStyle* oldStyle)

updateFilters(oldStyle, renderer()->style());

#endif

- updateNeedsCompositedScrolling();

const RenderStyle* newStyle = renderer()->style();

if (compositor()->updateLayerCompositingState(this)

|| needsCompositingLayersRebuiltForClip(oldStyle, newStyle)

@@ -6090,8 +6207,14 @@ void RenderLayer::updateScrollableAreaSet(bool hasOverflow)

if (HTMLFrameOwnerElement* owner = frame->ownerElement())

isVisibleToHitTest &= owner->renderer() && owner->renderer()->visibleToHitTesting();

- if (hasOverflow && isVisibleToHitTest ? frameView->addScrollableArea(this) : frameView->removeScrollableArea(this))

- updateNeedsCompositedScrolling();

+ bool updatedScrollableAreaSet = false;

+ if (hasOverflow && isVisibleToHitTest)

+ updatedScrollableAreaSet = frameView->addScrollableArea(this);

+ else

+ updatedScrollableAreaSet = frameView->removeScrollableArea(this);

+ if (updatedScrollableAreaSet)

+ requestNeedsCompositedScrollingUpdate();

}

void RenderLayer::updateScrollCornerStyle()