rendering/RenderBoxModelObject -> layout/LayoutBoxModelObject

Source/core/rendering/RenderInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 28 matching lines @@
 #include "core/paint/ObjectPainter.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderFullScreen.h"
 #include "core/rendering/RenderView.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 
 namespace blink {
 
-struct SameSizeAsRenderInline : public RenderBoxModelObject {
+struct SameSizeAsRenderInline : public LayoutBoxModelObject {
     virtual ~SameSizeAsRenderInline() { }
     LayoutObjectChildList m_children;
     RenderLineBoxList m_lineBoxes;
 };
 
 static_assert(sizeof(RenderInline) == sizeof(SameSizeAsRenderInline), "RenderInline should stay small");
 
 RenderInline::RenderInline(Element* element)
-    : RenderBoxModelObject(element)
+    : LayoutBoxModelObject(element)
 {
     setChildrenInline(true);
 }
 
 RenderInline* RenderInline::createAnonymous(Document* document)
 {
     RenderInline* renderer = new RenderInline(0);
     renderer->setDocumentForAnonymous(document);
     return renderer;
 }
@@ skipping 13 matching lines @@
     }
 #endif
 
     // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
     // properly dirty line boxes that they are removed from.  Effects that do :before/:after only on hover could crash otherwise.
     children()->destroyLeftoverChildren();
 
     // Destroy our continuation before anything other than anonymous children.
     // The reason we don't destroy it before anonymous children is that they may
     // have continuations of their own that are anonymous children of our continuation.
-    RenderBoxModelObject* continuation = this->continuation();
+    LayoutBoxModelObject* continuation = this->continuation();
     if (continuation) {
         continuation->destroy();
         setContinuation(0);
     }
 
     if (!documentBeingDestroyed()) {
         if (firstLineBox()) {
-            // We can't wait for RenderBoxModelObject::destroy to clear the selection,
+            // We can't wait for LayoutBoxModelObject::destroy to clear the selection,
             // because by then we will have nuked the line boxes.
             // FIXME: The FrameSelection should be responsible for this when it
             // is notified of DOM mutations.
             if (isSelectionBorder())
                 view()->clearSelection();
 
             // If line boxes are contained inside a root, that means we're an inline.
             // In that case, we need to remove all the line boxes so that the parent
             // lines aren't pointing to deleted children. If the first line box does
             // not have a parent that means they are either already disconnected or
             // root lines that can just be destroyed without disconnecting.
             if (firstLineBox()->parent()) {
                 for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
                     box->remove();
             }
         } else if (parent())
             parent()->dirtyLinesFromChangedChild(this);
     }
 
     m_lineBoxes.deleteLineBoxes();
 
-    RenderBoxModelObject::willBeDestroyed();
+    LayoutBoxModelObject::willBeDestroyed();
 }
 
 RenderInline* RenderInline::inlineElementContinuation() const
 {
-    RenderBoxModelObject* continuation = this->continuation();
+    LayoutBoxModelObject* continuation = this->continuation();
     if (!continuation || continuation->isInline())
         return toRenderInline(continuation);
     return toRenderBlock(continuation)->inlineElementContinuation();
 }
 
 void RenderInline::updateFromStyle()
 {
-    RenderBoxModelObject::updateFromStyle();
+    LayoutBoxModelObject::updateFromStyle();
 
     // FIXME: Is this still needed. Was needed for run-ins, since run-in is considered a block display type.
     setInline(true);
 
     // FIXME: Support transforms and reflections on inline flows someday.
     setHasTransformRelatedProperty(false);
     setHasReflection(false);
 }
 
 static LayoutObject* inFlowPositionedInlineAncestor(LayoutObject* p)
@@ skipping 30 matching lines @@
             newBlockStyle->setPosition(newStyle.position());
         }
 
         if (newBlockStyle)
             block->setStyle(newBlockStyle);
     }
 }
 
 void RenderInline::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
 {
-    RenderBoxModelObject::styleDidChange(diff, oldStyle);
+    LayoutBoxModelObject::styleDidChange(diff, oldStyle);
 
     // Ensure that all of the split inlines pick up the new style. We
     // only do this if we're an inline, since we don't want to propagate
     // a block's style to the other inlines.
     // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
     // and after the block share the same style, but the block doesn't
     // need to pass its style on to anyone else.
     const LayoutStyle& newStyle = styleRef();
     RenderInline* continuation = inlineElementContinuation();
     for (RenderInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation()) {
-        RenderBoxModelObject* nextCont = currCont->continuation();
+        LayoutBoxModelObject* nextCont = currCont->continuation();
         currCont->setContinuation(0);
         currCont->setStyle(style());
         currCont->setContinuation(nextCont);
     }
 
     // If an inline's outline or in-flow positioning has changed then any descendant blocks will need to change their styles accordingly.
     // Do this by updating the styles of the descendant blocks' containing anonymous blocks - there may be more than one.
     if (continuation && oldStyle
         && (!newStyle.isOutlineEquivalent(oldStyle)
             || (newStyle.position() != oldStyle->position() && (newStyle.hasInFlowPosition() || oldStyle->hasInFlowPosition())))) {
@@ skipping 73 matching lines @@
     return caretRect;
 }
 
 void RenderInline::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     if (continuation())
         return addChildToContinuation(newChild, beforeChild);
     return addChildIgnoringContinuation(newChild, beforeChild);
 }
 
-static RenderBoxModelObject* nextContinuation(LayoutObject* renderer)
+static LayoutBoxModelObject* nextContinuation(LayoutObject* renderer)
 {
     if (renderer->isInline() && !renderer->isReplaced())
         return toRenderInline(renderer)->continuation();
     return toRenderBlock(renderer)->inlineElementContinuation();
 }
 
-RenderBoxModelObject* RenderInline::continuationBefore(LayoutObject* beforeChild)
+LayoutBoxModelObject* RenderInline::continuationBefore(LayoutObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() == this)
         return this;
 
-    RenderBoxModelObject* curr = nextContinuation(this);
-    RenderBoxModelObject* nextToLast = this;
-    RenderBoxModelObject* last = this;
+    LayoutBoxModelObject* curr = nextContinuation(this);
+    LayoutBoxModelObject* nextToLast = this;
+    LayoutBoxModelObject* last = this;
     while (curr) {
         if (beforeChild && beforeChild->parent() == curr) {
             if (curr->slowFirstChild() == beforeChild)
                 return last;
             return curr;
         }
 
         nextToLast = last;
         last = curr;
         curr = nextContinuation(curr);
@@ skipping 21 matching lines @@
         // Giving the block a layer like this allows it to collect the x/y offsets from inline parents later.
         if (LayoutObject* positionedAncestor = inFlowPositionedInlineAncestor(this))
             newStyle->setPosition(positionedAncestor->style()->position());
 
         // Push outline style to the block continuation.
         if (!newStyle->isOutlineEquivalent(style()))
             newStyle->setOutlineFromStyle(*style());
 
         RenderBlockFlow* newBox = RenderBlockFlow::createAnonymous(&document());
         newBox->setStyle(newStyle.release());
-        RenderBoxModelObject* oldContinuation = continuation();
+        LayoutBoxModelObject* oldContinuation = continuation();
         setContinuation(newBox);
 
         splitFlow(beforeChild, newBox, newChild, oldContinuation);
         return;
     }
 
-    RenderBoxModelObject::addChild(newChild, beforeChild);
+    LayoutBoxModelObject::addChild(newChild, beforeChild);
 
     newChild->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 }
 
 RenderInline* RenderInline::clone() const
 {
     RenderInline* cloneInline = new RenderInline(node());
     cloneInline->setStyle(style());
     cloneInline->setFlowThreadState(flowThreadState());
     return cloneInline;
 }
 
 void RenderInline::moveChildrenToIgnoringContinuation(RenderInline* to, LayoutObject* startChild)
 {
     LayoutObject* child = startChild;
     while (child) {
         LayoutObject* currentChild = child;
         child = currentChild->nextSibling();
         to->addChildIgnoringContinuation(children()->removeChildNode(this, currentChild), nullptr);
     }
 }
 
 void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
                                 RenderBlock* middleBlock,
-                                LayoutObject* beforeChild, RenderBoxModelObject* oldCont)
+                                LayoutObject* beforeChild, LayoutBoxModelObject* oldCont)
 {
     ASSERT(isDescendantOf(fromBlock));
 
     // If we're splitting the inline containing the fullscreened element,
     // |beforeChild| may be the renderer for the fullscreened element. However,
     // that renderer is wrapped in a RenderFullScreen, so |this| is not its
     // parent. Since the splitting logic expects |this| to be the parent, set
     // |beforeChild| to be the RenderFullScreen.
     if (Fullscreen* fullscreen = Fullscreen::fromIfExists(document())) {
         const Element* fullScreenElement = fullscreen->webkitCurrentFullScreenElement();
@@ skipping 28 matching lines @@
     fromBlock->moveChildrenTo(toBlock, topMostInline->nextSibling(), nullptr, true);
 
     RenderInline* currentParent = topMostInlineToClone;
     RenderInline* cloneInlineParent = cloneInline;
 
     // Clone the inlines from top to down to ensure any new object will be added into a rooted tree.
     // Note that we have already cloned the top-most one, so the loop begins from size - 2 (except if
     // we have reached |cMaxDepth| in which case we sacrifice correct rendering for performance).
     for (int i = static_cast<int>(inlinesToClone.size()) - 2; i >= 0; --i) {
         // Hook the clone up as a continuation of |currentInline|.
-        RenderBoxModelObject* oldCont = currentParent->continuation();
+        LayoutBoxModelObject* oldCont = currentParent->continuation();
         currentParent->setContinuation(cloneInline);
         cloneInline->setContinuation(oldCont);
 
         // Create a new clone.
         RenderInline* current = inlinesToClone[i];
         cloneInline = current->clone();
 
         // Insert our |cloneInline| as the first child of |cloneInlineParent|.
         cloneInlineParent->addChildIgnoringContinuation(cloneInline, nullptr);
 
@@ skipping 11 matching lines @@
     // Hook |cloneInline| up as the continuation of the middle block.
     cloneInline->setContinuation(oldCont);
     middleBlock->setContinuation(cloneInline);
 
     // Now take all of the children from |beforeChild| to the end and remove
     // them from |this| and place them in the clone.
     moveChildrenToIgnoringContinuation(cloneInline, beforeChild);
 }
 
 void RenderInline::splitFlow(LayoutObject* beforeChild, RenderBlock* newBlockBox,
-    LayoutObject* newChild, RenderBoxModelObject* oldCont)
+    LayoutObject* newChild, LayoutBoxModelObject* oldCont)
 {
     RenderBlock* pre = 0;
     RenderBlock* block = containingBlock();
 
     // Delete our line boxes before we do the inline split into continuations.
     block->deleteLineBoxTree();
 
     bool madeNewBeforeBlock = false;
     if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {
         // We can reuse this block and make it the preBlock of the next continuation.
@@ skipping 38 matching lines @@
     // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
     // get deleted properly.  Because objects moves from the pre block into the post block, we want to
     // make new line boxes instead of leaving the old line boxes around.
     pre->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
     block->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
     post->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 }
 
 void RenderInline::addChildToContinuation(LayoutObject* newChild, LayoutObject* beforeChild)
 {
-    RenderBoxModelObject* flow = continuationBefore(beforeChild);
+    LayoutBoxModelObject* flow = continuationBefore(beforeChild);
     ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());
-    RenderBoxModelObject* beforeChildParent = 0;
+    LayoutBoxModelObject* beforeChildParent = 0;
     if (beforeChild)
-        beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
+        beforeChildParent = toLayoutBoxModelObject(beforeChild->parent());
     else {
-        RenderBoxModelObject* cont = nextContinuation(flow);
+        LayoutBoxModelObject* cont = nextContinuation(flow);
         if (cont)
             beforeChildParent = cont;
         else
             beforeChildParent = flow;
     }
 
     if (newChild->isFloatingOrOutOfFlowPositioned())
         return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
 
     // A continuation always consists of two potential candidates: an inline or an anonymous
@@ skipping 300 matching lines @@
     // FIXME: Does not deal with relative positioned inlines (should it?)
     RenderBlock* cb = containingBlock();
     if (firstLineBox()) {
         // This inline actually has a line box.  We must have clicked in the border/padding of one of these boxes.  We
         // should try to find a result by asking our containing block.
         return cb->positionForPoint(point);
     }
 
     // Translate the coords from the pre-anonymous block to the post-anonymous block.
     LayoutPoint parentBlockPoint = cb->location() + point;
-    RenderBoxModelObject* c = continuation();
+    LayoutBoxModelObject* c = continuation();
     while (c) {
         RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
         if (c->isInline() || c->slowFirstChild())
             return c->positionForPoint(parentBlockPoint - contBlock->locationOffset());
         c = toRenderBlock(c)->inlineElementContinuation();
     }
 
-    return RenderBoxModelObject::positionForPoint(point);
+    return LayoutBoxModelObject::positionForPoint(point);
 }
 
 namespace {
 
 class LinesBoundingBoxGeneratorContext {
 public:
     LinesBoundingBoxGeneratorContext(FloatRect& rect) : m_rect(rect) { }
     void operator()(const FloatRect& rect)
     {
         m_rect.uniteIfNonZero(rect);
@@ skipping 212 matching lines @@
 
         if (continuation() && !continuation()->isInline() && continuation()->parent())
             overflowRect.unite(continuation()->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineSize));
     }
 
     return overflowRect;
 }
 
 LayoutRect RenderInline::rectWithOutlineForPaintInvalidation(const LayoutLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth, const PaintInvalidationState* paintInvalidationState) const
 {
-    LayoutRect r(RenderBoxModelObject::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
+    LayoutRect r(LayoutBoxModelObject::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
     for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isText())
             r.unite(curr->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
     }
     return r;
 }
 
 void RenderInline::mapRectToPaintInvalidationBacking(const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
 {
     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
@@ skipping 117 matching lines @@
         LayoutSize containerOffset = paintInvalidationContainer->offsetFromAncestorContainer(o);
         transformState.move(-containerOffset.width(), -containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
         return;
     }
 
     o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
 }
 
 void RenderInline::updateDragState(bool dragOn)
 {
-    RenderBoxModelObject::updateDragState(dragOn);
+    LayoutBoxModelObject::updateDragState(dragOn);
     if (continuation())
         continuation()->updateDragState(dragOn);
 }
 
 void RenderInline::childBecameNonInline(LayoutObject* child)
 {
     // We have to split the parent flow.
     RenderBlock* newBox = containingBlock()->createAnonymousBlock();
-    RenderBoxModelObject* oldContinuation = continuation();
+    LayoutBoxModelObject* oldContinuation = continuation();
     setContinuation(newBox);
     LayoutObject* beforeChild = child->nextSibling();
     children()->removeChildNode(this, child);
     splitFlow(beforeChild, newBox, child, oldContinuation);
 }
 
 void RenderInline::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 {
     if (result.innerNode())
         return;
@@ skipping 201 matching lines @@
 
     FloatPoint absPos = container->localToAbsolute();
     region.bounds.setX(absPos.x() + region.bounds.x());
     region.bounds.setY(absPos.y() + region.bounds.y());
 
     regions.append(region);
 }
 
 void RenderInline::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
 {
-    RenderBoxModelObject::invalidateDisplayItemClients(displayItemList);
+    LayoutBoxModelObject::invalidateDisplayItemClients(displayItemList);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         displayItemList->invalidate(box->displayItemClient());
 }
 
 } // namespace blink