Convert LayoutObject renderer names.

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 79 matching lines @@
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 namespace {
 
-static bool gModifyRenderTreeStructureAnyState = false;
+static bool gModifyLayoutTreeStructureAnyState = false;
 
 static bool gDisablePaintInvalidationStateAsserts = false;
 
 } // namespace
 
 using namespace HTMLNames;
 
 #if ENABLE(ASSERT)
 
 LayoutObject::SetLayoutNeededForbiddenScope::SetLayoutNeededForbiddenScope(LayoutObject& layoutObject)
@@ skipping 35 matching lines @@
 }
 
 void LayoutObject::operator delete(void* ptr)
 {
     ASSERT(isMainThread());
     partitionFree(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.
     // Otherwise acts as if we didn't support this feature.
     const ContentData* contentData = style.contentData();
     if (contentData && !contentData->next() && contentData->isImage() && !element->isPseudoElement()) {
         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)));
             image->setIsGeneratedContent();
         } else {
             image->setImageResource(LayoutImageResource::create());
         }
         image->setStyleInternal(nullptr);
         return image;
     }
@@ skipping 119 matching lines @@
         return !isTable();
     if (newChild->isTableRow())
         return !isTableSection();
     if (newChild->isTableCell())
         return !isTableRow();
     return false;
 }
 
 void LayoutObject::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
-    ASSERT(isAllowedToModifyRenderTreeStructure(document()));
+    ASSERT(isAllowedToModifyLayoutTreeStructure(document()));
 
     LayoutObjectChildList* children = virtualChildren();
     ASSERT(children);
     if (!children)
         return;
 
     if (requiresAnonymousTableWrappers(newChild)) {
         // Generate an anonymous table or reuse existing one from previous child
         // Per: 17.2.1 Anonymous table objects 3. Generate missing parents
         // http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
         LayoutTable* table;
         LayoutObject* afterChild = beforeChild ? beforeChild->previousSibling() : children->lastChild();
         if (afterChild && afterChild->isAnonymous() && afterChild->isTable() && !afterChild->isBeforeContent()) {
             table = toLayoutTable(afterChild);
         } else {
             table = LayoutTable::createAnonymousWithParent(this);
             addChild(table, beforeChild);
         }
         table->addChild(newChild);
     } else {
         children->insertChildNode(this, newChild, 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
     //   know that it's inside a "hidden SVG subtree", and thus paints, even if it shouldn't.
     // To avoid the problem alltogether, detect early if we're inside a hidden SVG subtree
     // and stop creating layers at all for these cases - they're not used anyways.
     if (newChild->hasLayer() && !layerCreationAllowedForSubtree())
         toLayoutBoxModelObject(newChild)->layer()->removeOnlyThisLayer();
 }
 
 void LayoutObject::removeChild(LayoutObject* oldChild)
 {
-    ASSERT(isAllowedToModifyRenderTreeStructure(document()));
+    ASSERT(isAllowedToModifyLayoutTreeStructure(document()));
 
     LayoutObjectChildList* children = virtualChildren();
     ASSERT(children);
     if (!children)
         return;
 
     children->removeChildNode(this, oldChild);
 }
 
 LayoutObject* LayoutObject::nextInPreOrder() const
@@ skipping 176 matching lines @@
 
     return 0;
 }
 
 DeprecatedPaintLayer* LayoutObject::enclosingLayer() const
 {
     for (const LayoutObject* current = this; current; current = current->parent()) {
         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;
 }
 
 bool LayoutObject::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     LayoutBox* enclosingBox = this->enclosingBox();
     if (!enclosingBox)
         return false;
 
@@ skipping 54 matching lines @@
     // Not in the middle of layout so have to find the thread the slow way.
     LayoutObject* curr = const_cast<LayoutObject*>(this);
     while (curr) {
         if (curr->isLayoutFlowThread())
             return toLayoutFlowThread(curr);
         curr = curr->containingBlock();
     }
     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();
 }
 
 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;
 
     // In case scrollbars got repositioned (which will typically happen if the layout object got
     // resized), we cannot skip invalidation.
     if (hasNonCompositedScrollbars())
         return false;
 
     if (RuntimeEnabledFeatures::slimmingPaintEnabled() && isDocumentElement())
         return !hasBoxEffect();
 
-    return rendererHasNoBoxEffectObsolete(*this);
+    return layoutObjectHasNoBoxEffectObsolete(*this);
 }
 
 LayoutBlock* LayoutObject::firstLineBlock() const
 {
     return 0;
 }
 
 static inline bool objectIsRelayoutBoundary(const LayoutObject* object)
 {
     // FIXME: In future it may be possible to broaden these conditions in order to improve performance.
@@ skipping 63 matching lines @@
             object->setNeedsSimplifiedNormalFlowLayout(true);
             ASSERT(!object->isSetNeedsLayoutForbidden());
         } else {
             if (object->normalChildNeedsLayout())
                 return;
             object->setNormalChildNeedsLayout(true);
             ASSERT(!object->isSetNeedsLayoutForbidden());
         }
 
         if (layouter) {
-            layouter->addRendererToLayout(object);
+            layouter->recordObjectMarkedForLayout(object);
             if (object == layouter->root())
                 return;
         }
 
         if (object == newRoot)
             return;
 
         last = object;
         if (scheduleRelayout && objectIsRelayoutBoundary(last))
             break;
@@ skipping 595 matching lines @@
     setPreviousPositionFromPaintInvalidationBacking(newLocation);
 
     PaintInvalidationReason invalidationReason = paintInvalidationReason(paintInvalidationContainer, oldBounds, oldLocation, newBounds, newLocation);
 
     // We need to invalidate the selection before checking for whether we are doing a full invalidation.
     // This is because we need to update the old rect regardless.
     invalidateSelectionIfNeeded(paintInvalidationContainer, invalidationReason);
 
     // 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;
 
     TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "LayoutObject::invalidatePaintIfNeeded()",
         "object", this->debugName().ascii(),
         "info", jsonObjectForOldAndNewRects(oldBounds, oldLocation, newBounds, newLocation));
 
     if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
         bool boxDecorationBackgroundObscured = boxDecorationBackgroundIsKnownToBeObscured();
         if (!isFullPaintInvalidationReason(invalidationReason) && boxDecorationBackgroundObscured != m_bitfields.lastBoxDecorationBackgroundObscured())
@@ skipping 29 matching lines @@
     if (shouldDoFullPaintInvalidation())
         return m_bitfields.fullPaintInvalidationReason();
 
     // If the bounds are the same then we know that none of the statements below
     // can match, so we can early out since we will not need to do any
     // invalidation.
     if (oldBounds == newBounds)
         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;
 
     // This covers the case where we mark containing blocks for layout
     // and they change size but don't have anything to paint. This is
     // a pretty common case for <body> as we add / remove children
     // (and the default background is done by FrameView).
     if (skipInvalidationWhenLaidOutChildren())
         return PaintInvalidationNone;
 
@@ skipping 198 matching lines @@
 {
     return selectionColor(CSSPropertyWebkitTextEmphasisColor);
 }
 
 void LayoutObject::selectionStartEnd(int& spos, int& epos) const
 {
     view()->selectionStartEnd(spos, epos);
 }
 
 // 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)
 {
     // We have gone from not affecting the inline status of the parent flow to suddenly
     // having an impact.  See if there is a mismatch between the parent flow's
     // childrenInline() state and our state.
     object->setInline(object->style()->isDisplayInlineType());
     if (object->isInline() != object->parent()->childrenInline()) {
         if (!object->isInline()) {
             toLayoutBoxModelObject(object->parent())->childBecameNonInline(object);
@@ skipping 125 matching lines @@
 
     updateShapeImage(oldStyle ? oldStyle->shapeOutside() : 0, m_style->shapeOutside());
 
     bool doesNotNeedLayoutOrPaintInvalidation = !m_parent;
 
     styleDidChange(diff, oldStyle.get());
 
     // 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;
 
     // Now that the layer (if any) has been updated, we need to adjust the diff again,
     // check whether we should layout now, and decide if we need to invalidate paints.
     StyleDifference updatedDiff = adjustStyleDifference(diff);
 
     if (!diff.needsFullLayout()) {
         if (updatedDiff.needsFullLayout())
             setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::StyleChange);
         else if (updatedDiff.needsPositionedMovementLayout())
             setNeedsPositionedMovementLayout();
     }
 
     if (diff.transformChanged() && !needsLayout()) {
         if (LayoutBlock* container = containingBlock())
             container->setNeedsOverflowRecalcAfterStyleChange();
     }
 
     if (updatedDiff.needsPaintInvalidationLayer())
         toLayoutBoxModelObject(this)->layer()->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
     else if (diff.needsPaintInvalidationObject() || updatedDiff.needsPaintInvalidationObject())
         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)
 {
     if (m_style) {
         // If our z-index changes value or our visibility changes,
         // we need to dirty our stacking context's z-order list.
         bool visibilityChanged = m_style->visibility() != newStyle.visibility()
             || m_style->zIndex() != newStyle.zIndex()
             || m_style->hasAutoZIndex() != newStyle.hasAutoZIndex();
@@ skipping 17 matching lines @@
         } else if (isOutOfFlowPositioned() && (m_style->position() != newStyle.position())) {
             // For changes in positioning styles, we need to conceivably remove ourselves
             // from the positioned objects list.
             toLayoutBox(this)->removeFloatingOrPositionedChildFromBlockLists();
         }
 
         s_affectsParentBlock = isFloatingOrOutOfFlowPositioned()
             && (!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);
             clearPositionedState();
         }
     } else {
         s_affectsParentBlock = false;
     }
 
     if (view()->frameView()) {
         bool shouldBlitOnFixedBackgroundImage = false;
         if (RuntimeEnabledFeatures::fastMobileScrollingEnabled()) {
             // On low-powered/mobile devices, preventing blitting on a scroll can cause noticeable delays
             // when scrolling a page with a fixed background image. As an optimization, assuming there are
             // no fixed positoned elements on the page, we can acclerate scrolling (via blitting) if we
             // ignore the CSS property "background-attachment: fixed".
             shouldBlitOnFixedBackgroundImage = true;
         }
         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())
                     newStyleSlowScroll = false;
 
                 if (oldStyleSlowScroll && m_style->hasEntirelyFixedBackground())
                     oldStyleSlowScroll = false;
             }
         }
 
@@ skipping 274 matching lines @@
 FloatPoint LayoutObject::localToInvalidationBackingPoint(const LayoutPoint& localPoint, DeprecatedPaintLayer** backingLayer)
 {
     const LayoutBoxModelObject* paintInvalidationContainer = containerForPaintInvalidation();
     ASSERT(paintInvalidationContainer);
     ASSERT(paintInvalidationContainer->layer());
 
     if (backingLayer)
         *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;
 
     DeprecatedPaintLayer::mapPointToPaintBackingCoordinates(paintInvalidationContainer, containerPoint);
     return containerPoint;
 }
 
 LayoutSize LayoutObject::offsetFromContainer(const LayoutObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
@@ skipping 37 matching lines @@
 {
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = 0;
 
     return LayoutRect();
 }
 
 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;
 
     if (!hasLayer()) {
         LayoutObject* container = this->container();
         currentLayer = container->enclosingLayer();
         if (container && currentLayer->layoutObject() != container) {
             layerOffset.move(container->offsetFromAncestorContainer(currentLayer->layoutObject()));
             // If the layer itself is scrolled, we have to undo the subtraction of its scroll
             // offset since we want the offset relative to the scrolling content, not the
             // element itself.
             if (currentLayer->layoutObject()->hasOverflowClip())
                 layerOffset.move(currentLayer->layoutBox()->scrolledContentOffset());
         }
     }
 
     this->addLayerHitTestRects(layerRects, currentLayer, layerOffset, LayoutRect());
 }
 
 void LayoutObject::addLayerHitTestRects(LayerHitTestRects& layerRects, const DeprecatedPaintLayer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
 {
     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;
     LayoutRect newContainerRect;
     computeSelfHitTestRects(ownRects, layerOffset);
 
     // When we get to have a lot of rects on a layer, the performance cost of tracking those
     // rects outweighs the benefit of doing compositor thread hit testing.
     // FIXME: This limit needs to be low due to the O(n^2) algorithm in
     // WebLayer::setTouchEventHandlerRegion - crbug.com/300282.
     const size_t maxRectsPerLayer = 100;
 
     LayerHitTestRects::iterator iter = layerRects.find(currentLayer);
     Vector<LayoutRect>* iterValue;
     if (iter == layerRects.end())
         iterValue = &layerRects.add(currentLayer, Vector<LayoutRect>()).storedValue->value;
     else
         iterValue = &iter->value;
     for (size_t i = 0; i < ownRects.size(); i++) {
         if (!containerRect.contains(ownRects[i])) {
             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;
             }
             if (newContainerRect.isEmpty())
                 newContainerRect = ownRects[i];
         }
     }
     if (newContainerRect.isEmpty())
         newContainerRect = containerRect;
@@ skipping 15 matching lines @@
 bool LayoutObject::isRooted() const
 {
     const LayoutObject* object = this;
     while (object->parent() && !object->hasLayer())
         object = object->parent();
     if (object->hasLayer())
         return toLayoutBoxModelObject(object)->layer()->root()->isRootLayer();
     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)
             return bodyObject;
     }
 
     return this;
 }
 
 RespectImageOrientationEnum LayoutObject::shouldRespectImageOrientation() const
@@ skipping 81 matching lines @@
 }
 
 void LayoutObject::willBeDestroyed()
 {
     // Destroy any leftover anonymous children.
     LayoutObjectChildList* children = virtualChildren();
     if (children)
         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);
 
         if (frame->view() && frame->view()->viewportLayoutObject() == this)
             frame->view()->clearViewportLayoutObject();
     }
 
     // For accessibility management, notify the parent of the imminent change to its child set.
     // We do it now, before remove(), while the parent pointer is still available.
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->childrenChanged(this->parent());
 
     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);
 
     // Remove the handler if node had touch-action set. Handlers are not added
     // for text nodes so don't try removing for one too. Need to check if
     // m_style is null in cases of partial construction. Any handler we added
     // previously may have already been removed by the Document independently.
     if (node() && !node()->isTextNode() && m_style && m_style->touchAction() != TouchActionAuto) {
         EventHandlerRegistry& registry = document().frameHost()->eventHandlerRegistry();
@@ skipping 54 matching lines @@
         if (!layer)
             layer = parent()->enclosingLayer();
         removeLayers(layer);
     }
 
     if (isOutOfFlowPositioned() && parent()->childrenInline())
         parent()->dirtyLinesFromChangedChild(this);
 
     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();
 }
 
 void LayoutObject::removeFromLayoutFlowThread()
 {
     if (flowThreadState() == NotInsideFlowThread)
         return;
 
     // Sometimes we remove the element from the flow, but it's not destroyed at that time.
     // It's only until later when we actually destroy it and remove all the children from it.
     // Currently, that happens for firstLetter elements and list markers.
     // 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());
 }
 
 void LayoutObject::destroyAndCleanupAnonymousWrappers()
 {
     // If the tree is destroyed, there is no need for a clean-up phase.
     if (documentBeingDestroyed()) {
         destroy();
         return;
     }
 
     LayoutObject* destroyRoot = this;
     for (LayoutObject* destroyRootParent = destroyRoot->parent(); destroyRootParent && destroyRootParent->isAnonymous(); destroyRoot = destroyRootParent, destroyRootParent = destroyRootParent->parent()) {
         // Anonymous block continuations are tracked and destroyed elsewhere (see the bottom of LayoutBlock::removeChild)
         if (destroyRootParent->isLayoutBlock() && toLayoutBlock(destroyRootParent)->isAnonymousBlockContinuation())
             break;
         // A flow thread is tracked by its containing block. Whether its children are removed or not is irrelevant.
         if (destroyRootParent->isLayoutFlowThread())
             break;
         // Column spans are tracked elsewhere.
         if (destroyRootParent->isAnonymousColumnSpanBlock())
             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();
 
     // WARNING: |this| is deleted here.
 }
 
 void LayoutObject::destroy()
 {
     willBeDestroyed();
@@ skipping 86 matching lines @@
     return inside;
 }
 
 void LayoutObject::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 {
     if (result.innerNode())
         return;
 
     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) {
         result.setInnerNode(node);
         result.setLocalPoint(point);
     }
 }
 
 bool LayoutObject::nodeAtPoint(HitTestResult&, const HitTestLocation& /*locationInContainer*/, const LayoutPoint& /*accumulatedOffset*/, HitTestAction)
 {
@@ skipping 29 matching lines @@
 {
     setNormalChildNeedsLayout(true);
     layout();
 }
 
 enum StyleCacheState {
     Cached,
     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;
 }
 
 PassRefPtr<ComputedStyle> LayoutObject::uncachedFirstLineStyle(ComputedStyle* style) const
 {
     if (!document().styleEngine().usesFirstLineRules())
         return nullptr;
 
@@ skipping 140 matching lines @@
     FloatRect absBounds = localToAbsoluteQuad(localBounds).boundingBox();
 
     AnnotatedRegionValue region;
     region.draggable = style()->getDraggableRegionMode() == DraggableRegionDrag;
     region.bounds = LayoutRect(absBounds);
     regions.append(region);
 }
 
 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;
 
     addAnnotatedRegions(regions);
     for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextSibling())
         curr->collectAnnotatedRegions(regions);
 }
 
 bool LayoutObject::willRenderImage(ImageResource*)
@@ skipping 44 matching lines @@
     return current - 1;
 }
 
 int LayoutObject::nextOffset(int current) const
 {
     return current + 1;
 }
 
 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.
 // According to the CSS Box Model Spec (http://dev.w3.org/csswg/css-box/#the-width-and-height-properties)
 // width applies to all elements but non-replaced inline elements, table rows, and row groups and
 // height applies to all elements but non-replaced inline elements, table columns, and column groups.
 bool LayoutObject::supportsTouchAction() const
 {
     if (isInline() && !isReplaced())
         return false;
@@ skipping 38 matching lines @@
         // Webkit specific extension where offsetParent stops at zoom level changes.
         if (effectiveZoom != ancestor->style()->effectiveZoom())
             break;
     }
 
     return node && node->isElementNode() ? toElement(node) : 0;
 }
 
 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.
             Position position = createLegacyEditingPosition(node, offset);
             Position candidate = position.downstream(CanCrossEditingBoundary);
             if (candidate.deprecatedNode()->hasEditableStyle())
                 return PositionWithAffinity(candidate, affinity);
             candidate = position.upstream(CanCrossEditingBoundary);
             if (candidate.deprecatedNode()->hasEditableStyle())
                 return PositionWithAffinity(candidate, affinity);
         }
         // FIXME: Eliminate legacy editing positions
         return PositionWithAffinity(createLegacyEditingPosition(node, offset), affinity);
     }
 
     // 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);
         }
 
         // Use the parent itself unless it too is anonymous.
         if (Node* node = parent->nonPseudoNode())
             return PositionWithAffinity(firstPositionInOrBeforeNode(node), DOWNSTREAM);
 
         // Repeat at the next level up.
         child = parent;
     }
@@ skipping 20 matching lines @@
 {
     if (needsLayout())
         return false;
 
     const LayoutBlock* containingBlock = this->containingBlock();
     return containingBlock ? !containingBlock->needsLayout() : false;
 }
 
 void LayoutObject::setNeedsBoundariesUpdate()
 {
-    if (LayoutObject* renderer = parent())
-        renderer->setNeedsBoundariesUpdate();
+    if (LayoutObject* layoutObject = parent())
+        layoutObject->setNeedsBoundariesUpdate();
 }
 
 FloatRect LayoutObject::objectBoundingBox() const
 {
     ASSERT_NOT_REACHED();
     return FloatRect();
 }
 
 FloatRect LayoutObject::strokeBoundingBox() const
 {
@@ skipping 113 matching lines @@
     // booleans that are cleared below.
     ASSERT(paintInvalidationState.forceCheckForPaintInvalidation() || paintInvalidationStateIsDirty());
     clearShouldDoFullPaintInvalidation();
     setNeededLayoutBecauseOfChildren(false);
     setShouldInvalidateOverflowForPaint(false);
     clearLayoutDidGetCalledSinceLastFrame();
     clearMayNeedPaintInvalidation();
     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()
     : m_disabler(gDisablePaintInvalidationStateAsserts, true)
 {
 }
 
 // Since we're only painting non-composited layers, we know that they all share the same paintInvalidationContainer.
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
@@ skipping 38 matching lines @@
 {
     if (object1) {
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif