Convert Block code to layoutObject.

Source/core/layout/LayoutBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 352 matching lines @@
 }
 
 void LayoutBlock::invalidatePaintOfSubtreesIfNeeded(PaintInvalidationState& childPaintInvalidationState)
 {
     LayoutBox::invalidatePaintOfSubtreesIfNeeded(childPaintInvalidationState);
 
     // Take care of positioned objects. This is required as PaintInvalidationState keeps a single clip rect.
     if (TrackedLayoutBoxListHashSet* positionedObjects = this->positionedObjects()) {
         for (auto* box : *positionedObjects) {
 
-            // One of the renderers we're skipping over here may be the child's paint invalidation container,
+            // One of the layoutObjects we're skipping over here may be the child's paint invalidation container,
             // so we can't pass our own paint invalidation container along.
             const LayoutBoxModelObject& paintInvalidationContainerForChild = *box->containerForPaintInvalidation();
 
             // If it's a new paint invalidation container, we won't have properly accumulated the offset into the
             // PaintInvalidationState.
             // FIXME: Teach PaintInvalidationState to handle this case. crbug.com/371485
             if (paintInvalidationContainerForChild != childPaintInvalidationState.paintInvalidationContainer()) {
                 ForceHorriblySlowRectMapping slowRectMapping(&childPaintInvalidationState);
                 PaintInvalidationState disabledPaintInvalidationState(childPaintInvalidationState, *this, paintInvalidationContainerForChild);
                 box->invalidateTreeIfNeeded(disabledPaintInvalidationState);
                 continue;
             }
 
-            // If the positioned renderer is absolutely positioned and it is inside
+            // If the positioned layoutObject is absolutely positioned and it is inside
             // a relatively positioned inline element, we need to account for
             // the inline elements position in PaintInvalidationState.
             if (box->style()->position() == AbsolutePosition) {
                 LayoutObject* container = box->container(&paintInvalidationContainerForChild, 0);
                 if (container->isRelPositioned() && container->isLayoutInline()) {
                     // FIXME: We should be able to use PaintInvalidationState for this.
                     // Currently, we will place absolutely positioned elements inside
                     // relatively positioned inline blocks in the wrong location. crbug.com/371485
                     ForceHorriblySlowRectMapping slowRectMapping(&childPaintInvalidationState);
                     PaintInvalidationState disabledPaintInvalidationState(childPaintInvalidationState, *this, paintInvalidationContainerForChild);
@@ skipping 34 matching lines @@
 
 void LayoutBlock::addChildToContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     LayoutBlock* flow = continuationBefore(beforeChild);
     LayoutBoxModelObject* beforeChildParent = 0;
     if (beforeChild) {
         beforeChildParent = toLayoutBoxModelObject(beforeChild->parent());
         // Don't attempt to insert into something that isn't a LayoutBlockFlow (block
         // container). While the DOM nodes of |beforeChild| and |newChild| are siblings, there may
         // be anonymous table wrapper objects around |beforeChild| on the layout side. Therefore,
-        // find the nearest LayoutBlockFlow. If it turns out that the new renderer doesn't belong
+        // find the nearest LayoutBlockFlow. If it turns out that the new layoutObject doesn't belong
         // inside the anonymous table, this will make sure that it's really put on the outside. If
         // it turns out that it does belong inside it, the normal child insertion machinery will
         // make sure it ends up there, and at the right place too. We cannot just guess that it's
         // going to be right under the parent of |beforeChild|.
         while (beforeChildParent && !beforeChildParent->isLayoutBlockFlow()) {
             ASSERT(!beforeChildParent->virtualContinuation());
             ASSERT(beforeChildParent->isAnonymous());
             RELEASE_ASSERT(beforeChildParent != this);
             beforeChildParent = toLayoutBoxModelObject(beforeChildParent->parent());
         }
@@ skipping 100 matching lines @@
 }
 
 LayoutBlockFlow* LayoutBlock::containingColumnsBlock(bool allowAnonymousColumnBlock)
 {
     LayoutBlock* firstChildIgnoringAnonymousWrappers = 0;
     for (LayoutObject* curr = this; curr; curr = curr->parent()) {
         if (!curr->isLayoutBlock() || curr->isFloatingOrOutOfFlowPositioned() || curr->isTableCell() || curr->isDocumentElement() || curr->isLayoutView() || curr->hasOverflowClip()
             || curr->isInlineBlockOrInlineTable())
             return 0;
 
-        // FIXME: Renderers that do special management of their children (tables, buttons,
+        // FIXME: LayoutObjects that do special management of their children (tables, buttons,
         // lists, flexboxes, etc.) breaks when the flow is split through them. Disabling
         // multi-column for them to avoid this problem.)
         if (!curr->isLayoutBlockFlow() || curr->isListItem())
             return 0;
 
         LayoutBlockFlow* currBlock = toLayoutBlockFlow(curr);
         if (!currBlock->createsAnonymousWrapper())
             firstChildIgnoringAnonymousWrappers = currBlock;
 
         if (currBlock->style()->specifiesColumns() && (allowAnonymousColumnBlock || !currBlock->isAnonymousColumnsBlock()))
             return toLayoutBlockFlow(firstChildIgnoringAnonymousWrappers);
 
         if (currBlock->isAnonymousColumnSpanBlock())
             return 0;
     }
     return 0;
 }
 
 LayoutBlock* LayoutBlock::clone() const
 {
     LayoutBlock* cloneBlock;
     if (isAnonymousBlock()) {
         cloneBlock = createAnonymousBlock();
         cloneBlock->setChildrenInline(childrenInline());
     } else {
-        LayoutObject* cloneRenderer = toElement(node())->createLayoutObject(styleRef());
-        cloneBlock = toLayoutBlock(cloneRenderer);
+        LayoutObject* cloneLayoutObject = toElement(node())->createLayoutObject(styleRef());
+        cloneBlock = toLayoutBlock(cloneLayoutObject);
         cloneBlock->setStyle(mutableStyle());
 
         // This takes care of setting the right value of childrenInline in case
         // generated content is added to cloneBlock and 'this' does not have
         // generated content added yet.
         cloneBlock->setChildrenInline(cloneBlock->firstChild() ? cloneBlock->firstChild()->isInline() : childrenInline());
     }
     cloneBlock->setFlowThreadState(flowThreadState());
     return cloneBlock;
 }
@@ skipping 207 matching lines @@
         LayoutObject* beforeChildContainer = beforeChild->parent();
         while (beforeChildContainer->parent() != this)
             beforeChildContainer = beforeChildContainer->parent();
         ASSERT(beforeChildContainer);
 
         if (beforeChildContainer->isAnonymous()) {
             // If the requested beforeChild is not one of our children, then this is because
             // there is an anonymous container within this object that contains the beforeChild.
             LayoutObject* beforeChildAnonymousContainer = beforeChildContainer;
             if (beforeChildAnonymousContainer->isAnonymousBlock()
-                // Full screen renderers and full screen placeholders act as anonymous blocks, not tables:
+                // Full screen layoutObjects and full screen placeholders act as anonymous blocks, not tables:
                 || beforeChildAnonymousContainer->isLayoutFullScreen()
                 || beforeChildAnonymousContainer->isLayoutFullScreenPlaceholder()
                 ) {
                 // Insert the child into the anonymous block box instead of here.
                 if (newChild->isInline() || newChild->isFloatingOrOutOfFlowPositioned() || beforeChild->parent()->slowFirstChild() != beforeChild)
                     beforeChild->parent()->addChild(newChild, beforeChild);
                 else
                     addChild(newChild, beforeChild->parent());
                 return;
             }
@@ skipping 1554 matching lines @@
 // prevent crossing editable boundaries. This would require many tests.
 static PositionWithAffinity positionForPointRespectingEditingBoundaries(LayoutBlock* parent, LayoutBox* child, const LayoutPoint& pointInParentCoordinates)
 {
     LayoutPoint childLocation = child->location();
     if (child->isRelPositioned())
         childLocation += child->offsetForInFlowPosition();
 
     // FIXME: This is wrong if the child's writing-mode is different from the parent's.
     LayoutPoint pointInChildCoordinates(toLayoutPoint(pointInParentCoordinates - childLocation));
 
-    // If this is an anonymous renderer, we just recur normally
+    // If this is an anonymous layoutObject, we just recur normally
     Node* childNode = child->nonPseudoNode();
     if (!childNode)
         return child->positionForPoint(pointInChildCoordinates);
 
     // Otherwise, first make sure that the editability of the parent and child agree.
     // If they don't agree, then we return a visible position just before or after the child
     LayoutObject* ancestor = parent;
     while (ancestor && !ancestor->nonPseudoNode())
         ancestor = ancestor->parent();
 
@@ skipping 783 matching lines @@
     }
 
     // If we're not replaced, we'll only get called with PositionOfInteriorLineBoxes.
     // Note that inline-block counts as replaced here.
     ASSERT(linePositionMode == PositionOfInteriorLineBoxes);
 
     const FontMetrics& fontMetrics = style(firstLine)->fontMetrics();
     return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
 }
 
-LayoutUnit LayoutBlock::minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const
+LayoutUnit LayoutBlock::minLineHeightForReplacedObject(bool isFirstLine, LayoutUnit replacedHeight) const
 {
     if (!document().inNoQuirksMode() && replacedHeight)
         return replacedHeight;
 
     if (!(style(isFirstLine)->lineBoxContain() & LineBoxContainBlock))
         return LayoutUnit();
 
     return std::max<LayoutUnit>(replacedHeight, lineHeight(isFirstLine, isHorizontalWritingMode() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes));
 }
 
@@ skipping 307 matching lines @@
 }
 
 void LayoutBlock::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset) const
 {
     // For blocks inside inlines, we go ahead and include margins so that we run right up to the
     // inline boxes above and below us (thus getting merged with them to form a single irregular
     // shape).
     if (inlineElementContinuation()) {
         // FIXME: This check really isn't accurate.
         bool nextInlineHasLineBox = inlineElementContinuation()->firstLineBox();
-        // FIXME: This is wrong. The principal renderer may not be the continuation preceding this block.
+        // FIXME: This is wrong. The principal layoutObject may not be the continuation preceding this block.
         // FIXME: This is wrong for vertical writing-modes.
         // https://bugs.webkit.org/show_bug.cgi?id=46781
         bool prevInlineHasLineBox = toLayoutInline(inlineElementContinuation()->node()->layoutObject())->firstLineBox();
         LayoutUnit topMargin = prevInlineHasLineBox ? collapsedMarginBefore() : LayoutUnit();
         LayoutUnit bottomMargin = nextInlineHasLineBox ? collapsedMarginAfter() : LayoutUnit();
         LayoutRect rect(additionalOffset, size());
         rect.expandEdges(topMargin, 0, bottomMargin, 0);
 
         if (!rect.isEmpty())
             rects.append(rect);
@@ skipping 29 matching lines @@
             // It's common for this rect to be entirely contained in our box, so exclude that simple case.
             if (!rect.isEmpty() && (rects.isEmpty() || !rects[0].contains(rect)))
                 rects.append(rect);
         }
     }
 }
 
 LayoutBox* LayoutBlock::createAnonymousBoxWithSameTypeAs(const LayoutObject* parent) const
 {
     if (isAnonymousColumnsBlock())
-        return createAnonymousColumnsWithParentRenderer(parent);
+        return createAnonymousColumnsWithParent(parent);
     if (isAnonymousColumnSpanBlock())
-        return createAnonymousColumnSpanWithParentRenderer(parent);
-    return createAnonymousWithParentRendererAndDisplay(parent, style()->display());
+        return createAnonymousColumnSpanWithParent(parent);
+    return createAnonymousWithParentAndDisplay(parent, style()->display());
 }
 
 LayoutUnit LayoutBlock::nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule pageBoundaryRule) const
 {
     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
     if (!pageLogicalHeight)
         return logicalOffset;
 
     // The logicalOffset is in our coordinate space.  We can add in our pushed offset.
     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset);
@@ skipping 125 matching lines @@
     // whether or not authors specified quirky ems, since they're an implementation detail.
     return false;
 }
 
 const char* LayoutBlock::name() const
 {
     ASSERT_NOT_REACHED();
     return "LayoutBlock";
 }
 
-LayoutBlock* LayoutBlock::createAnonymousWithParentRendererAndDisplay(const LayoutObject* parent, EDisplay display)
+LayoutBlock* LayoutBlock::createAnonymousWithParentAndDisplay(const LayoutObject* parent, EDisplay display)
 {
     // FIXME: Do we need to convert all our inline displays to block-type in the anonymous logic ?
     EDisplay newDisplay;
     LayoutBlock* newBox = 0;
     if (display == FLEX || display == INLINE_FLEX) {
         newBox = LayoutFlexibleBox::createAnonymous(&parent->document());
         newDisplay = FLEX;
     } else {
         newBox = LayoutBlockFlow::createAnonymous(&parent->document());
         newDisplay = BLOCK;
     }
 
     RefPtr<ComputedStyle> newStyle = ComputedStyle::createAnonymousStyleWithDisplay(parent->styleRef(), newDisplay);
     parent->updateAnonymousChildStyle(*newBox, *newStyle);
     newBox->setStyle(newStyle.release());
     return newBox;
 }
 
-LayoutBlockFlow* LayoutBlock::createAnonymousColumnsWithParentRenderer(const LayoutObject* parent)
+LayoutBlockFlow* LayoutBlock::createAnonymousColumnsWithParent(const LayoutObject* parent)
 {
     RefPtr<ComputedStyle> newStyle = ComputedStyle::createAnonymousStyleWithDisplay(parent->styleRef(), BLOCK);
     newStyle->inheritColumnPropertiesFrom(parent->styleRef());
 
     LayoutBlockFlow* newBox = LayoutBlockFlow::createAnonymous(&parent->document());
     parent->updateAnonymousChildStyle(*newBox, *newStyle);
     newBox->setStyle(newStyle.release());
     return newBox;
 }
 
-LayoutBlockFlow* LayoutBlock::createAnonymousColumnSpanWithParentRenderer(const LayoutObject* parent)
+LayoutBlockFlow* LayoutBlock::createAnonymousColumnSpanWithParent(const LayoutObject* parent)
 {
     RefPtr<ComputedStyle> newStyle = ComputedStyle::createAnonymousStyleWithDisplay(parent->styleRef(), BLOCK);
     newStyle->setColumnSpan(ColumnSpanAll);
 
     LayoutBlockFlow* newBox = LayoutBlockFlow::createAnonymous(&parent->document());
     parent->updateAnonymousChildStyle(*newBox, *newStyle);
     newBox->setStyle(newStyle.release());
     return newBox;
 }
 
-static bool recalcNormalFlowChildOverflowIfNeeded(LayoutObject* renderer)
+static bool recalcNormalFlowChildOverflowIfNeeded(LayoutObject* layoutObject)
 {
-    if (renderer->isOutOfFlowPositioned() || !renderer->needsOverflowRecalcAfterStyleChange())
+    if (layoutObject->isOutOfFlowPositioned() || !layoutObject->needsOverflowRecalcAfterStyleChange())
         return false;
 
-    ASSERT(renderer->isLayoutBlock());
-    return toLayoutBlock(renderer)->recalcOverflowAfterStyleChange();
+    ASSERT(layoutObject->isLayoutBlock());
+    return toLayoutBlock(layoutObject)->recalcOverflowAfterStyleChange();
 }
 
 bool LayoutBlock::recalcChildOverflowAfterStyleChange()
 {
     ASSERT(childNeedsOverflowRecalcAfterStyleChange());
     setChildNeedsOverflowRecalcAfterStyleChange(false);
 
     bool childrenOverflowChanged = false;
 
     if (childrenInline()) {
         ListHashSet<RootInlineBox*> lineBoxes;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
-            LayoutObject* renderer = walker.current();
-            if (recalcNormalFlowChildOverflowIfNeeded(renderer)) {
+            LayoutObject* layoutObject = walker.current();
+            if (recalcNormalFlowChildOverflowIfNeeded(layoutObject)) {
                 childrenOverflowChanged = true;
-                if (InlineBox* inlineBoxWrapper = toLayoutBlock(renderer)->inlineBoxWrapper())
+                if (InlineBox* inlineBoxWrapper = toLayoutBlock(layoutObject)->inlineBoxWrapper())
                     lineBoxes.add(&inlineBoxWrapper->root());
             }
         }
 
         // FIXME: Glyph overflow will get lost in this case, but not really a big deal.
         GlyphOverflowAndFallbackFontsMap textBoxDataMap;
         for (ListHashSet<RootInlineBox*>::const_iterator it = lineBoxes.begin(); it != lineBoxes.end(); ++it) {
             RootInlineBox* box = *it;
             box->computeOverflow(box->lineTop(), box->lineBottom(), textBoxDataMap);
         }
@@ skipping 115 matching lines @@
 void LayoutBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
     showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink