Move rendering/RenderBox to layout/LayoutBox.

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 567 matching lines @@
 
     bool isHorizontal = style()->isHorizontalWritingMode();
 
     for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox()) {
-            RenderBox* currBox = toRenderBox(curr);
+            LayoutBox* currBox = toLayoutBox(curr);
             if (currBox->inlineBoxWrapper()) {
                 RootInlineBox& rootBox = currBox->inlineBoxWrapper()->root();
                 int logicalTop = rootBox.logicalTop() + (rootBox.renderer().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
                 int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
                 if (isHorizontal)
                     yield(FloatRect(currBox->inlineBoxWrapper()->x() - currBox->marginLeft(), logicalTop, (currBox->size().width() + currBox->marginWidth()).toFloat(), logicalHeight));
                 else
                     yield(FloatRect(logicalTop, currBox->inlineBoxWrapper()->y() - currBox->marginTop(), logicalHeight, (currBox->size().height() + currBox->marginHeight()).toFloat()));
             }
         } else if (curr->isRenderInline()) {
@@ skipping 54 matching lines @@
 
 } // unnamed namespace
 
 void RenderInline::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     AbsoluteRectsGeneratorContext context(rects, accumulatedOffset);
     generateLineBoxRects(context);
 
     if (continuation()) {
         if (continuation()->isBox()) {
-            RenderBox* box = toRenderBox(continuation());
+            LayoutBox* box = toLayoutBox(continuation());
             continuation()->absoluteRects(rects, toLayoutPoint(accumulatedOffset - containingBlock()->location() + box->locationOffset()));
         } else
             continuation()->absoluteRects(rects, toLayoutPoint(accumulatedOffset - containingBlock()->location()));
     }
 }
 
 
 namespace {
 
 class AbsoluteQuadsGeneratorContext {
@@ skipping 164 matching lines @@
     if (firstLineBoxIncludingCulling()) {
         // 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;
     LayoutBoxModelObject* c = continuation();
     while (c) {
-        RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
+        LayoutBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
         if (c->isInline() || c->slowFirstChild())
             return c->positionForPoint(parentBlockPoint - contBlock->locationOffset());
         c = toRenderBlock(c)->inlineElementContinuation();
     }
 
     return LayoutBoxModelObject::positionForPoint(point);
 }
 
 namespace {
 
@@ skipping 51 matching lines @@
 
 InlineBox* RenderInline::culledInlineFirstLineBox() const
 {
     for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox())
-            return toRenderBox(curr)->inlineBoxWrapper();
+            return toLayoutBox(curr)->inlineBoxWrapper();
         if (curr->isRenderInline()) {
             RenderInline* currInline = toRenderInline(curr);
             InlineBox* result = currInline->firstLineBoxIncludingCulling();
             if (result)
                 return result;
         } else if (curr->isText()) {
             RenderText* currText = toRenderText(curr);
             if (currText->firstTextBox())
                 return currText->firstTextBox();
         }
     }
     return 0;
 }
 
 InlineBox* RenderInline::culledInlineLastLineBox() const
 {
     for (LayoutObject* curr = lastChild(); curr; curr = curr->previousSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox())
-            return toRenderBox(curr)->inlineBoxWrapper();
+            return toLayoutBox(curr)->inlineBoxWrapper();
         if (curr->isRenderInline()) {
             RenderInline* currInline = toRenderInline(curr);
             InlineBox* result = currInline->lastLineBoxIncludingCulling();
             if (result)
                 return result;
         } else if (curr->isText()) {
             RenderText* currText = toRenderText(curr);
             if (currText->lastTextBox())
                 return currText->lastTextBox();
         }
     }
     return 0;
 }
 
 LayoutRect RenderInline::culledInlineVisualOverflowBoundingBox() const
 {
     FloatRect floatResult;
     LinesBoundingBoxGeneratorContext context(floatResult);
     generateCulledLineBoxRects(context, this);
     LayoutRect result(enclosingLayoutRect(floatResult));
     bool isHorizontal = style()->isHorizontalWritingMode();
     for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // For overflow we just have to propagate by hand and recompute it all.
         if (curr->isBox()) {
-            RenderBox* currBox = toRenderBox(curr);
+            LayoutBox* currBox = toLayoutBox(curr);
             if (!currBox->hasSelfPaintingLayer() && currBox->inlineBoxWrapper()) {
                 LayoutRect logicalRect = currBox->logicalVisualOverflowRectForPropagation(styleRef());
                 if (isHorizontal) {
                     logicalRect.moveBy(currBox->location());
                     result.uniteIfNonZero(logicalRect);
                 } else {
                     logicalRect.moveBy(currBox->location());
                     result.uniteIfNonZero(logicalRect.transposedRect());
                 }
             }
@@ skipping 145 matching lines @@
         // is translated, but the render box isn't, so we need to do this to get the
         // right dirty rect. Since this is called from LayoutObject::setStyle, the relative position
         // flag on the LayoutObject has been cleared, so use the one on the style().
         topLeft += layer()->offsetForInFlowPosition();
     }
 
     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
     rect.setLocation(topLeft);
     if (o->hasOverflowClip()) {
-        RenderBox* containerBox = toRenderBox(o);
+        LayoutBox* containerBox = toLayoutBox(o);
         containerBox->applyCachedClipAndScrollOffsetForPaintInvalidation(rect);
         if (rect.isEmpty())
             return;
     }
 
     if (containerSkipped) {
         // If the paintInvalidationContainer is below o, then we need to map the rect into paintInvalidationContainer's coordinates.
         LayoutSize containerOffset = paintInvalidationContainer->offsetFromAncestorContainer(o);
         rect.move(-containerOffset);
         return;
     }
 
     o->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
 }
 
 LayoutSize RenderInline::offsetFromContainer(const LayoutObject* container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
     ASSERT(container == this->container());
 
     LayoutSize offset;
     if (isRelPositioned())
         offset += offsetForInFlowPosition();
 
     offset += container->columnOffset(point);
 
     if (container->hasOverflowClip())
-        offset -= toRenderBox(container)->scrolledContentOffset();
+        offset -= toLayoutBox(container)->scrolledContentOffset();
 
     if (offsetDependsOnPoint) {
         *offsetDependsOnPoint = container->hasColumns()
             || (container->isBox() && container->style()->isFlippedBlocksWritingMode())
             || container->isLayoutFlowThread();
     }
 
     return offset;
 }
 
@@ skipping 11 matching lines @@
     }
 
     bool containerSkipped;
     LayoutObject* o = container(paintInvalidationContainer, &containerSkipped);
     if (!o)
         return;
 
     if (mode & ApplyContainerFlip && o->isBox()) {
         if (o->style()->isFlippedBlocksWritingMode()) {
             IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
-            transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);
+            transformState.move(toLayoutBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);
         }
         mode &= ~ApplyContainerFlip;
     }
 
     LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
 
     bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() || style()->preserves3D());
     if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
         TransformationMatrix t;
         getTransformFromContainer(o, containerOffset, t);
@@ skipping 37 matching lines @@
 
     Node* n = node();
     LayoutPoint localPoint(point);
     if (n) {
         if (isInlineElementContinuation()) {
             // We're in the continuation of a split inline.  Adjust our local point to be in the coordinate space
             // of the principal renderer's containing block.  This will end up being the innerNonSharedNode.
             RenderBlock* firstBlock = n->renderer()->containingBlock();
 
             // Get our containing block.
-            RenderBox* block = containingBlock();
+            LayoutBox* block = containingBlock();
             localPoint.moveBy(block->location() - firstBlock->locationOffset());
         }
 
         result.setInnerNode(n);
         if (!result.innerNonSharedNode())
             result.setInnerNonSharedNode(n);
         result.setLocalPoint(localPoint);
     }
 }
 
 void RenderInline::dirtyLineBoxes(bool fullLayout)
 {
     if (fullLayout) {
         m_lineBoxes.deleteLineBoxes();
         return;
     }
 
     if (!alwaysCreateLineBoxes()) {
         // We have to grovel into our children in order to dirty the appropriate lines.
         for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
             if (curr->isFloatingOrOutOfFlowPositioned())
                 continue;
             if (curr->isBox() && !curr->needsLayout()) {
-                RenderBox* currBox = toRenderBox(curr);
+                LayoutBox* currBox = toLayoutBox(curr);
                 if (currBox->inlineBoxWrapper())
                     currBox->inlineBoxWrapper()->root().markDirty();
             } else if (!curr->selfNeedsLayout()) {
                 if (curr->isRenderInline()) {
                     RenderInline* currInline = toRenderInline(curr);
                     for (InlineFlowBox* childLine = currInline->firstLineBox(); childLine; childLine = childLine->nextLineBox())
                         childLine->root().markDirty();
                 } else if (curr->isText()) {
                     RenderText* currText = toRenderText(curr);
                     for (InlineTextBox* childText = currText->firstTextBox(); childText; childText = childText->nextTextBox())
@@ skipping 29 matching lines @@
     return style()->computedLineHeight();
 }
 
 int RenderInline::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
 {
     ASSERT(linePositionMode == PositionOnContainingLine);
     const FontMetrics& fontMetrics = style(firstLine)->fontMetrics();
     return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
 }
 
-LayoutSize RenderInline::offsetForInFlowPositionedInline(const RenderBox& child) const
+LayoutSize RenderInline::offsetForInFlowPositionedInline(const LayoutBox& child) const
 {
     // FIXME: This function isn't right with mixed writing modes.
 
     ASSERT(isRelPositioned());
     if (!isRelPositioned())
         return LayoutSize();
 
     // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
     // box from the rest of the content, but only in the cases where we know we're positioned
     // relative to the inline itself.
@@ skipping 70 matching lines @@
 {
     AbsoluteLayoutRectsIgnoringEmptyRectsGeneratorContext context(rects, additionalOffset);
     generateLineBoxRects(context);
 
     addChildFocusRingRects(rects, additionalOffset);
 
     if (continuation()) {
         if (continuation()->isInline())
             continuation()->addFocusRingRects(rects, additionalOffset + (continuation()->containingBlock()->location() - containingBlock()->location()));
         else
-            continuation()->addFocusRingRects(rects, additionalOffset + (toRenderBox(continuation())->location() - containingBlock()->location()));
+            continuation()->addFocusRingRects(rects, additionalOffset + (toLayoutBox(continuation())->location() - containingBlock()->location()));
     }
 }
 
 void RenderInline::computeSelfHitTestRects(Vector<LayoutRect>& rects, const LayoutPoint& layerOffset) const
 {
     AbsoluteLayoutRectsGeneratorContext context(rects, layerOffset);
     generateLineBoxRects(context);
 }
 
 void RenderInline::addAnnotatedRegions(Vector<AnnotatedRegionValue>& regions)
@@ skipping 21 matching lines @@
 }
 
 void RenderInline::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(displayItemList);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         displayItemList->invalidate(box->displayItemClient());
 }
 
 } // namespace blink