Source/core/layout/LayoutObject.cpp - Issue 1095043003: Convert LayoutObject renderer names.

Unified Diff: Source/core/layout/LayoutObject.cpp

Issue 1095043003: Convert LayoutObject renderer names. (Closed) Base URL: svn://svn.chromium.org/blink/trunk

Patch Set: Created 5 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

Index: Source/core/layout/LayoutObject.cpp

diff --git a/Source/core/layout/LayoutObject.cpp b/Source/core/layout/LayoutObject.cpp

index 42e24d180e37902637798d3b3d1ddc2e09387728..142ceaf88a30c592c77d82bc0174ea3e77659b0d 100644

--- a/Source/core/layout/LayoutObject.cpp

+++ b/Source/core/layout/LayoutObject.cpp

@@ -97,7 +97,7 @@ namespace blink {

namespace {

-static bool gModifyRenderTreeStructureAnyState = false;

+static bool gModifyLayoutTreeStructureAnyState = false;

static bool gDisablePaintInvalidationStateAsserts = false;

@@ -153,7 +153,7 @@ void LayoutObject::operator delete(void* ptr)

LayoutObject* LayoutObject::createObject(Element* element, const ComputedStyle& style)

{

- ASSERT(isAllowedToModifyRenderTreeStructure(element->document()));

+ ASSERT(isAllowedToModifyLayoutTreeStructure(element->document()));

// Minimal support for content properties replacing an entire element.

// Works only if we have exactly one piece of content and it's a URL.

@@ -163,7 +163,7 @@ LayoutObject* LayoutObject::createObject(Element* element, const ComputedStyle&

LayoutImage* image = new LayoutImage(element);

// LayoutImageResourceStyleImage requires a style being present on the image but we don't want to

// trigger a style change now as the node is not fully attached. Moving this code to style change

- // doesn't make sense as it should be run once at renderer creation.

+ // doesn't make sense as it should be run once at layoutObject creation.

image->setStyleInternal(const_cast<ComputedStyle*>(&style));

if (const StyleImage* styleImage = toImageContentData(contentData)->image()) {

image->setImageResource(LayoutImageResourceStyleImage::create(const_cast<StyleImage*>(styleImage)));

@@ -303,7 +303,7 @@ bool LayoutObject::requiresAnonymousTableWrappers(const LayoutObject* newChild)

void LayoutObject::addChild(LayoutObject* newChild, LayoutObject* beforeChild)

{

- ASSERT(isAllowedToModifyRenderTreeStructure(document()));

+ ASSERT(isAllowedToModifyLayoutTreeStructure(document()));

LayoutObjectChildList* children = virtualChildren();

ASSERT(children);

@@ -330,8 +330,8 @@ void LayoutObject::addChild(LayoutObject* newChild, LayoutObject* beforeChild)

if (newChild->isText() && newChild->style()->textTransform() == CAPITALIZE)

toLayoutText(newChild)->transformText();

- // SVG creates renderers for <g display="none">, as SVG requires children of hidden

- // <g>s to have renderers - at least that's how our implementation works. Consider:

+ // SVG creates layoutObjects for <g display="none">, as SVG requires children of hidden

+ // <g>s to have layoutObjects - at least that's how our implementation works. Consider:

// <g display="none"><foreignObject><body style="position: relative">FOO...

// - layerTypeRequired() would return true for the <body>, creating a new Layer

// - when the document is painted, both layers are painted. The <body> layer doesn't

@@ -344,7 +344,7 @@ void LayoutObject::addChild(LayoutObject* newChild, LayoutObject* beforeChild)

void LayoutObject::removeChild(LayoutObject* oldChild)

{

- ASSERT(isAllowedToModifyRenderTreeStructure(document()));

+ ASSERT(isAllowedToModifyLayoutTreeStructure(document()));

LayoutObjectChildList* children = virtualChildren();

ASSERT(children);

@@ -541,7 +541,7 @@ DeprecatedPaintLayer* LayoutObject::enclosingLayer() const

if (current->hasLayer())

return toLayoutBoxModelObject(current)->layer();

}

- // FIXME: we should get rid of detached render subtrees, at which point this code should

+ // FIXME: we should get rid of detached layout subtrees, at which point this code should

// not be reached. crbug.com/411429

return 0;

}

@@ -616,9 +616,9 @@ LayoutFlowThread* LayoutObject::locateFlowThreadContainingBlock() const

return 0;

}

-// FIXME: This could be used when changing the size of a renderer without children to skip some invalidations.

+// FIXME: This could be used when changing the size of a layoutObject without children to skip some invalidations.

// FIXME: This is incorrect for document element. Remove this when we enable slimming paint.

-static inline bool rendererHasNoBoxEffectObsolete(const LayoutObject& object)

+static inline bool layoutObjectHasNoBoxEffectObsolete(const LayoutObject& object)

{

return !object.style()->hasVisualOverflowingEffect() && !object.style()->hasBorder() && !object.style()->hasBackground();

}

@@ -628,7 +628,7 @@ bool LayoutObject::skipInvalidationWhenLaidOutChildren() const

if (!neededLayoutBecauseOfChildren())

return false;

- // SVG renderers need to be invalidated when their children are laid out.

+ // SVG layoutObjects need to be invalidated when their children are laid out.

// LayoutBlocks with line boxes are responsible to invalidate them so we can't ignore them.

if (isSVG() || (isLayoutBlockFlow() && toLayoutBlockFlow(this)->firstLineBox()))

return false;

@@ -641,7 +641,7 @@ bool LayoutObject::skipInvalidationWhenLaidOutChildren() const

if (RuntimeEnabledFeatures::slimmingPaintEnabled() && isDocumentElement())

return !hasBoxEffect();

- return rendererHasNoBoxEffectObsolete(*this);

+ return layoutObjectHasNoBoxEffectObsolete(*this);

}

LayoutBlock* LayoutObject::firstLineBlock() const

@@ -725,7 +725,7 @@ void LayoutObject::markContainerChainForLayout(bool scheduleRelayout, LayoutObje

}

if (layouter) {

- layouter->addRendererToLayout(object);

+ layouter->recordObjectMarkedForLayout(object);

if (object == layouter->root())

return;

}

@@ -1341,8 +1341,8 @@ PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(PaintInvalidationS

// If we are set to do a full paint invalidation that means the LayoutView will issue

// paint invalidations. We can then skip issuing of paint invalidations for the child

- // renderers as they'll be covered by the LayoutView.

- // However, slimming paint mode requires paint invalidation of the child renderers.

+ // layoutObjects as they'll be covered by the LayoutView.

+ // However, slimming paint mode requires paint invalidation of the child layoutObjects.

if (view()->doingFullPaintInvalidation() && !RuntimeEnabledFeatures::slimmingPaintEnabled())

return invalidationReason;

@@ -1392,7 +1392,7 @@ PaintInvalidationReason LayoutObject::paintInvalidationReason(const LayoutBoxMod

return PaintInvalidationNone;

// If we shifted, we don't know the exact reason so we are conservative and trigger a full invalidation. Shifting could

- // be caused by some layout property (left / top) or some in-flow renderer inserted / removed before us in the tree.

+ // be caused by some layout property (left / top) or some in-flow layoutObject inserted / removed before us in the tree.

if (newBounds.location() != oldBounds.location())

return PaintInvalidationBoundsChange;

@@ -1611,7 +1611,7 @@ void LayoutObject::selectionStartEnd(int& spos, int& epos) const

}

// Called when an object that was floating or positioned becomes a normal flow object

-// again. We have to make sure the render tree updates as needed to accommodate the new

+// again. We have to make sure the layout tree updates as needed to accommodate the new

// normal flow object.

static inline void handleDynamicFloatPositionChange(LayoutObject* object)

{

@@ -1757,7 +1757,7 @@ void LayoutObject::setStyle(PassRefPtr<ComputedStyle> style)

// FIXME: |this| might be destroyed here. This can currently happen for a LayoutTextFragment when

// its first-letter block gets an update in LayoutTextFragment::styleDidChange. For LayoutTextFragment(s),

// we will safely bail out with the doesNotNeedLayoutOrPaintInvalidation flag. We might want to broaden

- // this condition in the future as we move renderer changes out of layout and into style changes.

+ // this condition in the future as we move layoutObject changes out of layout and into style changes.

if (doesNotNeedLayoutOrPaintInvalidation)

return;

@@ -1783,9 +1783,9 @@ void LayoutObject::setStyle(PassRefPtr<ComputedStyle> style)

setShouldDoFullPaintInvalidation();

}

-static inline bool rendererHasBackground(const LayoutObject* renderer)

+static inline bool layoutObjectHasBackground(const LayoutObject* layoutObject)

{

- return renderer && renderer->hasBackground();

+ return layoutObject && layoutObject->hasBackground();

}

void LayoutObject::styleWillChange(StyleDifference diff, const ComputedStyle& newStyle)

@@ -1823,7 +1823,7 @@ void LayoutObject::styleWillChange(StyleDifference diff, const ComputedStyle& ne

&& (!newStyle.isFloating() && !newStyle.hasOutOfFlowPosition())

&& parent() && (parent()->isLayoutBlockFlow() || parent()->isLayoutInline());

- // Clearing these bits is required to avoid leaving stale renderers.

+ // Clearing these bits is required to avoid leaving stale layoutObjects.

// FIXME: We shouldn't need that hack if our logic was totally correct.

if (diff.needsLayout()) {

setFloating(false);

@@ -1845,7 +1845,7 @@ void LayoutObject::styleWillChange(StyleDifference diff, const ComputedStyle& ne

bool newStyleSlowScroll = !shouldBlitOnFixedBackgroundImage && newStyle.hasFixedBackgroundImage();

bool oldStyleSlowScroll = m_style && !shouldBlitOnFixedBackgroundImage && m_style->hasFixedBackgroundImage();

- bool drawsRootBackground = isDocumentElement() || (isBody() && !rendererHasBackground(document().documentElement()->layoutObject()));

+ bool drawsRootBackground = isDocumentElement() || (isBody() && !layoutObjectHasBackground(document().documentElement()->layoutObject()));

if (drawsRootBackground && !shouldBlitOnFixedBackgroundImage) {

if (view()->compositor()->supportsFixedRootBackgroundCompositing()) {

if (newStyleSlowScroll && newStyle.hasEntirelyFixedBackground())

@@ -2140,7 +2140,7 @@ FloatPoint LayoutObject::localToInvalidationBackingPoint(const LayoutPoint& loca

*backingLayer = paintInvalidationContainer->layer();

FloatPoint containerPoint = localToContainerPoint(FloatPoint(localPoint), paintInvalidationContainer, TraverseDocumentBoundaries);

- // A renderer can have no invalidation backing if it is from a detached frame,

+ // A layoutObject can have no invalidation backing if it is from a detached frame,

// or when forced compositing is disabled.

if (paintInvalidationContainer->layer()->compositingState() == NotComposited)

return containerPoint;

@@ -2198,7 +2198,7 @@ LayoutRect LayoutObject::localCaretRect(InlineBox*, int, LayoutUnit* extraWidthT

void LayoutObject::computeLayerHitTestRects(LayerHitTestRects& layerRects) const

{

// Figure out what layer our container is in. Any offset (or new layer) for this

- // renderer within it's container will be applied in addLayerHitTestRects.

+ // layoutObject within it's container will be applied in addLayerHitTestRects.

LayoutPoint layerOffset;

const DeprecatedPaintLayer* currentLayer = 0;

@@ -2223,7 +2223,7 @@ void LayoutObject::addLayerHitTestRects(LayerHitTestRects& layerRects, const Dep

ASSERT(currentLayer);

ASSERT(currentLayer == this->enclosingLayer());

- // Compute the rects for this renderer only and add them to the results.

+ // Compute the rects for this layoutObject only and add them to the results.

// Note that we could avoid passing the offset and instead adjust each result, but this

// seems slightly simpler.

Vector<LayoutRect> ownRects;

@@ -2247,7 +2247,7 @@ void LayoutObject::addLayerHitTestRects(LayerHitTestRects& layerRects, const Dep

iterValue->append(ownRects[i]);

if (iterValue->size() > maxRectsPerLayer) {

// Just mark the entire layer instead, and switch to walking the layer

- // tree instead of the render tree.

+ // tree instead of the layout tree.

layerRects.remove(currentLayer);

currentLayer->addLayerHitTestRects(layerRects);

return;

@@ -2283,14 +2283,14 @@ bool LayoutObject::isRooted() const

return false;

}

-LayoutObject* LayoutObject::rendererForRootBackground()

+LayoutObject* LayoutObject::layoutObjectForRootBackground()

{

ASSERT(isDocumentElement());

if (!hasBackground() && isHTMLHtmlElement(node())) {

// Locate the <body> element using the DOM. This is easier than trying

- // to crawl around a render tree with potential :before/:after content and

+ // to crawl around a layout tree with potential :before/:after content and

// anonymous blocks created by inline <body> tags etc. We can locate the <body>

- // render object very easily via the DOM.

+ // layout object very easily via the DOM.

HTMLElement* body = document().body();

LayoutObject* bodyObject = isHTMLBodyElement(body) ? body->layoutObject() : 0;

if (bodyObject)

@@ -2392,7 +2392,7 @@ void LayoutObject::willBeDestroyed()

children->destroyLeftoverChildren();

if (LocalFrame* frame = this->frame()) {

- // If this renderer is being autoscrolled, stop the autoscrolling.

+ // If this layoutObject is being autoscrolled, stop the autoscrolling.

if (frame->page())

frame->page()->autoscrollController().stopAutoscrollIfNeeded(this);

@@ -2407,15 +2407,15 @@ void LayoutObject::willBeDestroyed()

remove();

- // The remove() call above may invoke axObjectCache()->childrenChanged() on the parent, which may require the AX render

- // object for this renderer. So we remove the AX render object now, after the renderer is removed.

+ // The remove() call above may invoke axObjectCache()->childrenChanged() on the parent, which may require the AX layout

+ // object for this layoutObject. So we remove the AX layout object now, after the layoutObject is removed.

if (AXObjectCache* cache = document().existingAXObjectCache())

cache->remove(this);

- // If this renderer had a parent, remove should have destroyed any counters

- // attached to this renderer and marked the affected other counters for

+ // If this layoutObject had a parent, remove should have destroyed any counters

+ // attached to this layoutObject and marked the affected other counters for

// reevaluation. This apparently redundant check is here for the case when

- // this renderer had no parent at the time remove() was called.

+ // this layoutObject had no parent at the time remove() was called.

if (hasCounterNodeMap())

LayoutCounter::destroyCounterNodes(*this);

@@ -2490,7 +2490,7 @@ void LayoutObject::willBeRemovedFromTree()

removeFromLayoutFlowThread();

- // Update cached boundaries in SVG renderers if a child is removed.

+ // Update cached boundaries in SVG layoutObjects if a child is removed.

if (parent()->isSVG())

parent()->setNeedsBoundariesUpdate();

}

@@ -2506,24 +2506,24 @@ void LayoutObject::removeFromLayoutFlowThread()

// Pass in the flow thread so that we don't have to look it up for all the children.

// If we're a column spanner, we need to use our parent to find the flow thread, since a spanner

// doesn't have the flow thread in its containing block chain. We still need to notify the flow

- // thread when the renderer removed happens to be a spanner, so that we get rid of the spanner

+ // thread when the layoutObject removed happens to be a spanner, so that we get rid of the spanner

// placeholder, and column sets around the placeholder get merged.

LayoutFlowThread* flowThread = isColumnSpanAll() ? parent()->flowThreadContainingBlock() : flowThreadContainingBlock();

removeFromLayoutFlowThreadRecursive(flowThread);

}

-void LayoutObject::removeFromLayoutFlowThreadRecursive(LayoutFlowThread* renderFlowThread)

+void LayoutObject::removeFromLayoutFlowThreadRecursive(LayoutFlowThread* layoutFlowThread)

{

if (const LayoutObjectChildList* children = virtualChildren()) {

for (LayoutObject* child = children->firstChild(); child; child = child->nextSibling()) {

if (child->isLayoutFlowThread())

continue; // Don't descend into inner fragmentation contexts.

- child->removeFromLayoutFlowThreadRecursive(child->isLayoutFlowThread() ? toLayoutFlowThread(child) : renderFlowThread);

+ child->removeFromLayoutFlowThreadRecursive(child->isLayoutFlowThread() ? toLayoutFlowThread(child) : layoutFlowThread);

}

- if (renderFlowThread && renderFlowThread != this)

- renderFlowThread->flowThreadDescendantWillBeRemoved(this);

+ if (layoutFlowThread && layoutFlowThread != this)

+ layoutFlowThread->flowThreadDescendantWillBeRemoved(this);

setFlowThreadState(NotInsideFlowThread);

RELEASE_ASSERT(!spannerPlaceholder());

}

@@ -2549,7 +2549,7 @@ void LayoutObject::destroyAndCleanupAnonymousWrappers()

break;

if (destroyRootParent->slowFirstChild() != destroyRoot || destroyRootParent->slowLastChild() != destroyRoot)

- break; // Need to keep the anonymous parent, since it won't become empty by the removal of this renderer.

+ break; // Need to keep the anonymous parent, since it won't become empty by the removal of this layoutObject.

}

destroyRoot->destroy();

@@ -2656,11 +2656,11 @@ void LayoutObject::updateHitTestResult(HitTestResult& result, const LayoutPoint&

Node* node = this->node();

- // If we hit the anonymous renderers inside generated content we should

+ // If we hit the anonymous layoutObjects inside generated content we should

// actually hit the generated content so walk up to the PseudoElement.

if (!node && parent() && parent()->isBeforeOrAfterContent()) {

- for (LayoutObject* renderer = parent(); renderer && !node; renderer = renderer->parent())

- node = renderer->node();

+ for (LayoutObject* layoutObject = parent(); layoutObject && !node; layoutObject = layoutObject->parent())

+ node = layoutObject->node();

}

if (node) {

@@ -2710,28 +2710,28 @@ enum StyleCacheState {

Uncached

};

-static PassRefPtr<ComputedStyle> firstLineStyleForCachedUncachedType(StyleCacheState type, const LayoutObject* renderer, ComputedStyle* style)

+static PassRefPtr<ComputedStyle> firstLineStyleForCachedUncachedType(StyleCacheState type, const LayoutObject* layoutObject, ComputedStyle* style)

{

- const LayoutObject* rendererForFirstLineStyle = renderer;

- if (renderer->isBeforeOrAfterContent())

- rendererForFirstLineStyle = renderer->parent();

+ const LayoutObject* layoutObjectForFirstLineStyle = layoutObject;

+ if (layoutObject->isBeforeOrAfterContent())

+ layoutObjectForFirstLineStyle = layoutObject->parent();

- if (rendererForFirstLineStyle->isLayoutBlockFlow() || rendererForFirstLineStyle->isLayoutButton()) {

- if (LayoutBlock* firstLineBlock = rendererForFirstLineStyle->firstLineBlock()) {

+ if (layoutObjectForFirstLineStyle->isLayoutBlockFlow() || layoutObjectForFirstLineStyle->isLayoutButton()) {

+ if (LayoutBlock* firstLineBlock = layoutObjectForFirstLineStyle->firstLineBlock()) {

if (type == Cached)

return firstLineBlock->getCachedPseudoStyle(FIRST_LINE, style);

- return firstLineBlock->getUncachedPseudoStyle(PseudoStyleRequest(FIRST_LINE), style, firstLineBlock == renderer ? style : 0);

+ return firstLineBlock->getUncachedPseudoStyle(PseudoStyleRequest(FIRST_LINE), style, firstLineBlock == layoutObject ? style : 0);

}

- } else if (!rendererForFirstLineStyle->isAnonymous() && rendererForFirstLineStyle->isLayoutInline()

- && !rendererForFirstLineStyle->node()->isFirstLetterPseudoElement()) {

- const ComputedStyle* parentStyle = rendererForFirstLineStyle->parent()->firstLineStyle();

- if (parentStyle != rendererForFirstLineStyle->parent()->style()) {

+ } else if (!layoutObjectForFirstLineStyle->isAnonymous() && layoutObjectForFirstLineStyle->isLayoutInline()

+ && !layoutObjectForFirstLineStyle->node()->isFirstLetterPseudoElement()) {

+ const ComputedStyle* parentStyle = layoutObjectForFirstLineStyle->parent()->firstLineStyle();

+ if (parentStyle != layoutObjectForFirstLineStyle->parent()->style()) {

if (type == Cached) {

// A first-line style is in effect. Cache a first-line style for ourselves.

- rendererForFirstLineStyle->mutableStyleRef().setHasPseudoStyle(FIRST_LINE_INHERITED);

- return rendererForFirstLineStyle->getCachedPseudoStyle(FIRST_LINE_INHERITED, parentStyle);

+ layoutObjectForFirstLineStyle->mutableStyleRef().setHasPseudoStyle(FIRST_LINE_INHERITED);

+ return layoutObjectForFirstLineStyle->getCachedPseudoStyle(FIRST_LINE_INHERITED, parentStyle);

}

- return rendererForFirstLineStyle->getUncachedPseudoStyle(PseudoStyleRequest(FIRST_LINE_INHERITED), parentStyle, style);

+ return layoutObjectForFirstLineStyle->getUncachedPseudoStyle(PseudoStyleRequest(FIRST_LINE_INHERITED), parentStyle, style);

}

return nullptr;

@@ -2892,7 +2892,7 @@ void LayoutObject::addAnnotatedRegions(Vector<AnnotatedRegionValue>& regions)

void LayoutObject::collectAnnotatedRegions(Vector<AnnotatedRegionValue>& regions)

{

- // RenderTexts don't have their own style, they just use their parent's style,

+ // LayoutTexts don't have their own style, they just use their parent's style,

// so we don't want to include them.

if (isText())

return;

@@ -2957,10 +2957,10 @@ int LayoutObject::nextOffset(int current) const

bool LayoutObject::isInert() const

{

- const LayoutObject* renderer = this;

- while (!renderer->node())

- renderer = renderer->parent();

- return renderer->node()->isInert();

+ const LayoutObject* layoutObject = this;

+ while (!layoutObject->node())

+ layoutObject = layoutObject->parent();

+ return layoutObject->node()->isInert();

}

// touch-action applies to all elements with both width AND height properties.

@@ -3019,7 +3019,7 @@ Element* LayoutObject::offsetParent() const

PositionWithAffinity LayoutObject::createPositionWithAffinity(int offset, EAffinity affinity)

{

- // If this is a non-anonymous renderer in an editable area, then it's simple.

+ // If this is a non-anonymous layoutObject in an editable area, then it's simple.

if (Node* node = nonPseudoNode()) {

if (!node->hasEditableStyle()) {

// If it can be found, we prefer a visually equivalent position that is editable.

@@ -3038,22 +3038,22 @@ PositionWithAffinity LayoutObject::createPositionWithAffinity(int offset, EAffin

// We don't want to cross the boundary between editable and non-editable

// regions of the document, but that is either impossible or at least

// extremely unlikely in any normal case because we stop as soon as we

- // find a single non-anonymous renderer.

+ // find a single non-anonymous layoutObject.

- // Find a nearby non-anonymous renderer.

+ // Find a nearby non-anonymous layoutObject.

LayoutObject* child = this;

while (LayoutObject* parent = child->parent()) {

// Find non-anonymous content after.

- for (LayoutObject* renderer = child->nextInPreOrder(parent); renderer; renderer = renderer->nextInPreOrder(parent)) {

- if (Node* node = renderer->nonPseudoNode())

+ for (LayoutObject* layoutObject = child->nextInPreOrder(parent); layoutObject; layoutObject = layoutObject->nextInPreOrder(parent)) {

+ if (Node* node = layoutObject->nonPseudoNode())

return PositionWithAffinity(firstPositionInOrBeforeNode(node), DOWNSTREAM);

}

// Find non-anonymous content before.

- for (LayoutObject* renderer = child->previousInPreOrder(); renderer; renderer = renderer->previousInPreOrder()) {

- if (renderer == parent)

+ for (LayoutObject* layoutObject = child->previousInPreOrder(); layoutObject; layoutObject = layoutObject->previousInPreOrder()) {

+ if (layoutObject == parent)

break;

- if (Node* node = renderer->nonPseudoNode())

+ if (Node* node = layoutObject->nonPseudoNode())

return PositionWithAffinity(lastPositionInOrAfterNode(node), DOWNSTREAM);

}

@@ -3094,8 +3094,8 @@ bool LayoutObject::canUpdateSelectionOnRootLineBoxes() const

void LayoutObject::setNeedsBoundariesUpdate()

{

- if (LayoutObject* renderer = parent())

- renderer->setNeedsBoundariesUpdate();

+ if (LayoutObject* layoutObject = parent())

+ layoutObject->setNeedsBoundariesUpdate();

}

FloatRect LayoutObject::objectBoundingBox() const

@@ -3229,20 +3229,20 @@ void LayoutObject::clearPaintInvalidationState(const PaintInvalidationState& pai

clearShouldInvalidateSelection();

}

-bool LayoutObject::isAllowedToModifyRenderTreeStructure(Document& document)

+bool LayoutObject::isAllowedToModifyLayoutTreeStructure(Document& document)

{

- return DeprecatedDisableModifyRenderTreeStructureAsserts::canModifyRenderTreeStateInAnyState()

- || document.lifecycle().stateAllowsRenderTreeMutations();

+ return DeprecatedDisableModifyLayoutTreeStructureAsserts::canModifyLayoutTreeStateInAnyState()

+ || document.lifecycle().stateAllowsLayoutTreeMutations();

}

-DeprecatedDisableModifyRenderTreeStructureAsserts::DeprecatedDisableModifyRenderTreeStructureAsserts()

- : m_disabler(gModifyRenderTreeStructureAnyState, true)

+DeprecatedDisableModifyLayoutTreeStructureAsserts::DeprecatedDisableModifyLayoutTreeStructureAsserts()

+ : m_disabler(gModifyLayoutTreeStructureAnyState, true)

{

}

-bool DeprecatedDisableModifyRenderTreeStructureAsserts::canModifyRenderTreeStateInAnyState()

+bool DeprecatedDisableModifyLayoutTreeStructureAsserts::canModifyLayoutTreeStateInAnyState()

{

- return gModifyRenderTreeStructureAnyState;

+ return gModifyLayoutTreeStructureAnyState;

}

DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()

« no previous file with comments | « Source/core/layout/LayoutObject.h ('k') | Source/core/layout/LayoutView.cpp » ('j') | no next file with comments »