Move rendering/RenderBox to layout/LayoutBox.

Source/core/rendering/RenderBlockLineLayout.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google 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 43 matching lines @@
 
 static inline InlineBox* createInlineBoxForRenderer(LayoutObject* obj, bool isRootLineBox, bool isOnlyRun = false)
 {
     // Callers should handle text themselves.
     ASSERT(!obj->isText());
 
     if (isRootLineBox)
         return toRenderBlockFlow(obj)->createAndAppendRootInlineBox();
 
     if (obj->isBox())
-        return toRenderBox(obj)->createInlineBox();
+        return toLayoutBox(obj)->createInlineBox();
 
     return toRenderInline(obj)->createAndAppendInlineFlowBox();
 }
 
 static inline InlineTextBox* createInlineBoxForText(BidiRun& run, bool isOnlyRun)
 {
     ASSERT(run.m_object->isText());
     RenderText* text = toRenderText(run.m_object);
     InlineTextBox* textBox = text->createInlineTextBox(run.m_start, run.m_stop - run.m_start);
     // We only treat a box as text for a <br> if we are on a line by ourself or in strict mode
@@ skipping 481 matching lines @@
     bool isFirstLine = lineInfo.isFirstLine() && !(isAnonymousBlock() && parent()->slowFirstChild() != this);
     bool isAfterHardLineBreak = lineBox->prevRootBox() && lineBox->prevRootBox()->endsWithBreak();
     IndentTextOrNot shouldIndentText = requiresIndent(isFirstLine, isAfterHardLineBreak, styleRef());
     float lineLogicalLeft;
     float lineLogicalRight;
     float availableLogicalWidth;
     updateLogicalInlinePositions(this, lineLogicalLeft, lineLogicalRight, availableLogicalWidth, isFirstLine, shouldIndentText, 0);
     bool needsWordSpacing;
 
     if (firstRun && firstRun->m_object->isReplaced()) {
-        RenderBox* renderBox = toRenderBox(firstRun->m_object);
-        updateLogicalInlinePositions(this, lineLogicalLeft, lineLogicalRight, availableLogicalWidth, isFirstLine, shouldIndentText, renderBox->logicalHeight());
+        LayoutBox* layoutBox = toLayoutBox(firstRun->m_object);
+        updateLogicalInlinePositions(this, lineLogicalLeft, lineLogicalRight, availableLogicalWidth, isFirstLine, shouldIndentText, layoutBox->logicalHeight());
     }
 
     computeInlineDirectionPositionsForSegment(lineBox, lineInfo, textAlign, lineLogicalLeft, availableLogicalWidth, firstRun, trailingSpaceRun, textBoxDataMap, verticalPositionCache, wordMeasurements);
     // The widths of all runs are now known. We can now place every inline box (and
     // compute accurate widths for the inline flow boxes).
     needsWordSpacing = lineBox->isLeftToRightDirection() ? false: true;
     lineBox->placeBoxesInInlineDirection(lineLogicalLeft, needsWordSpacing);
 }
 
 BidiRun* RenderBlockFlow::computeInlineDirectionPositionsForSegment(RootInlineBox* lineBox, const LineInfo& lineInfo, ETextAlign textAlign, float& logicalLeft,
@@ skipping 31 matching lines @@
             if (rt->textLength()) {
                 if (!r->m_start && needsWordSpacing && isSpaceOrNewline(rt->characterAt(r->m_start)))
                     totalLogicalWidth += rt->style(lineInfo.isFirstLine())->font().fontDescription().wordSpacing();
                 needsWordSpacing = !isSpaceOrNewline(rt->characterAt(r->m_stop - 1));
             }
 
             setLogicalWidthForTextRun(lineBox, r, rt, totalLogicalWidth, lineInfo, textBoxDataMap, verticalPositionCache, wordMeasurements);
         } else {
             isAfterExpansion = false;
             if (!r->m_object->isRenderInline()) {
-                RenderBox* renderBox = toRenderBox(r->m_object);
-                if (renderBox->isRubyRun())
-                    setMarginsForRubyRun(r, toLayoutRubyRun(renderBox), previousObject, lineInfo);
-                r->m_box->setLogicalWidth(logicalWidthForChild(*renderBox).toFloat());
-                totalLogicalWidth += marginStartForChild(*renderBox) + marginEndForChild(*renderBox);
+                LayoutBox* layoutBox = toLayoutBox(r->m_object);
+                if (layoutBox->isRubyRun())
+                    setMarginsForRubyRun(r, toLayoutRubyRun(layoutBox), previousObject, lineInfo);
+                r->m_box->setLogicalWidth(logicalWidthForChild(*layoutBox).toFloat());
+                totalLogicalWidth += marginStartForChild(*layoutBox) + marginEndForChild(*layoutBox);
                 needsWordSpacing = true;
             }
         }
 
         totalLogicalWidth += r->m_box->logicalWidth();
         previousObject = r->m_object;
     }
 
     if (isAfterExpansion && !expansionOpportunities.isEmpty()) {
         expansionOpportunities.last()--;
@@ skipping 21 matching lines @@
         // Align positioned boxes with the top of the line box.  This is
         // a reasonable approximation of an appropriate y position.
         if (r->m_object->isOutOfFlowPositioned())
             r->m_box->setLogicalTop(logicalHeight().toFloat());
 
         // Position is used to properly position both replaced elements and
         // to update the static normal flow x/y of positioned elements.
         if (r->m_object->isText())
             toRenderText(r->m_object)->positionLineBox(r->m_box);
         else if (r->m_object->isBox())
-            toRenderBox(r->m_object)->positionLineBox(r->m_box);
+            toLayoutBox(r->m_object)->positionLineBox(r->m_box);
     }
 }
 
 void RenderBlockFlow::appendFloatingObjectToLastLine(FloatingObject* floatingObject)
 {
     ASSERT(!floatingObject->originatingLine());
     floatingObject->setOriginatingLine(lastRootBox());
     lastRootBox()->appendFloat(floatingObject->renderer());
 }
 
@@ skipping 322 matching lines @@
             for (RootInlineBox* line = layoutState.endLine(); line; line = line->nextRootBox()) {
                 line->attachLine();
                 if (paginated) {
                     delta -= line->paginationStrut();
                     adjustLinePositionForPagination(*line, delta, layoutState.flowThread());
                 }
                 if (delta) {
                     layoutState.updatePaintInvalidationRangeFromBox(line, delta);
                     line->adjustBlockDirectionPosition(delta.toFloat());
                 }
-                if (Vector<RenderBox*>* cleanLineFloats = line->floatsPtr()) {
-                    Vector<RenderBox*>::iterator end = cleanLineFloats->end();
-                    for (Vector<RenderBox*>::iterator f = cleanLineFloats->begin(); f != end; ++f) {
+                if (Vector<LayoutBox*>* cleanLineFloats = line->floatsPtr()) {
+                    Vector<LayoutBox*>::iterator end = cleanLineFloats->end();
+                    for (Vector<LayoutBox*>::iterator f = cleanLineFloats->begin(); f != end; ++f) {
                         FloatingObject* floatingObject = insertFloatingObject(**f);
                         ASSERT(!floatingObject->originatingLine());
                         floatingObject->setOriginatingLine(line);
                         setLogicalHeight(logicalTopForChild(**f) - marginBeforeForChild(**f) + delta);
                         positionNewFloats();
                     }
                 }
             }
             setLogicalHeight(lastRootBox()->lineBottomWithLeading());
         } else {
@@ skipping 42 matching lines @@
 }
 
 void RenderBlockFlow::markDirtyFloatsForPaintInvalidation(Vector<FloatWithRect>& floats)
 {
     size_t floatCount = floats.size();
     // Floats that did not have layout did not paint invalidations when we laid them out. They would have
     // painted by now if they had moved, but if they stayed at (0, 0), they still need to be
     // painted.
     for (size_t i = 0; i < floatCount; ++i) {
         if (!floats[i].everHadLayout) {
-            RenderBox* f = floats[i].object;
+            LayoutBox* f = floats[i].object;
             if (!f->location().x() && !f->location().y())
                 f->setShouldDoFullPaintInvalidation();
         }
     }
 }
 
 struct InlineMinMaxIterator {
 /* InlineMinMaxIterator is a class that will iterate over all render objects that contribute to
    inline min/max width calculations.  Note the following about the way it walks:
    (1) Positioned content is skipped (since it does not contribute to min/max width of a block)
@@ skipping 225 matching lines @@
                     childMax += margins;
                 }
             }
 
             if (!child->isRenderInline() && !child->isText()) {
                 // Case (2). Inline replaced elements and floats.
                 // Go ahead and terminate the current line as far as
                 // minwidth is concerned.
                 LayoutUnit childMinPreferredLogicalWidth, childMaxPreferredLogicalWidth;
                 if (child->isBox() && child->isHorizontalWritingMode() != isHorizontalWritingMode()) {
-                    RenderBox* childBox = toRenderBox(child);
+                    LayoutBox* childBox = toLayoutBox(child);
                     LogicalExtentComputedValues computedValues;
                     childBox->computeLogicalHeight(childBox->borderAndPaddingLogicalHeight(), 0, computedValues);
                     childMinPreferredLogicalWidth = childMaxPreferredLogicalWidth = computedValues.m_extent;
                 } else {
                     childMinPreferredLogicalWidth = child->minPreferredLogicalWidth();
                     childMaxPreferredLogicalWidth = child->maxPreferredLogicalWidth();
                 }
                 childMin += childMinPreferredLogicalWidth;
                 childMax += childMaxPreferredLogicalWidth;
 
@@ skipping 214 matching lines @@
     // Walk all the lines and delete our ellipsis line boxes if they exist.
     if (hasTextOverflow)
          deleteEllipsisLineBoxes();
 
     if (firstChild()) {
         // In full layout mode, clear the line boxes of children upfront. Otherwise,
         // siblings can run into stale root lineboxes during layout. Then layout
         // the replaced elements later. In partial layout mode, line boxes are not
         // deleted and only dirtied. In that case, we can layout the replaced
         // elements at the same time.
-        Vector<RenderBox*> replacedChildren;
+        Vector<LayoutBox*> replacedChildren;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
             LayoutObject* o = walker.current();
 
             if (!layoutState.hasInlineChild() && o->isInline())
                 layoutState.setHasInlineChild(true);
 
             if (o->isReplaced() || o->isFloating() || o->isOutOfFlowPositioned()) {
-                RenderBox* box = toRenderBox(o);
+                LayoutBox* box = toLayoutBox(o);
 
                 updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, *box);
 
                 if (o->isOutOfFlowPositioned())
                     o->containingBlock()->insertPositionedObject(box);
                 else if (o->isFloating())
                     layoutState.floats().append(FloatWithRect(box));
                 else if (isFullLayout || o->needsLayout()) {
                     // Replaced element.
                     box->dirtyLineBoxes(isFullLayout);
@@ skipping 38 matching lines @@
     if (hasTextOverflow)
         checkLinesForTextOverflow();
 
     // Ensure the new line boxes will be painted.
     if (isFullLayout && firstLineBox())
         setShouldDoFullPaintInvalidation();
 }
 
 void RenderBlockFlow::checkFloatsInCleanLine(RootInlineBox* line, Vector<FloatWithRect>& floats, size_t& floatIndex, bool& encounteredNewFloat, bool& dirtiedByFloat)
 {
-    Vector<RenderBox*>* cleanLineFloats = line->floatsPtr();
+    Vector<LayoutBox*>* cleanLineFloats = line->floatsPtr();
     if (!cleanLineFloats)
         return;
 
-    Vector<RenderBox*>::iterator end = cleanLineFloats->end();
-    for (Vector<RenderBox*>::iterator it = cleanLineFloats->begin(); it != end; ++it) {
-        RenderBox* floatingBox = *it;
+    Vector<LayoutBox*>::iterator end = cleanLineFloats->end();
+    for (Vector<LayoutBox*>::iterator it = cleanLineFloats->begin(); it != end; ++it) {
+        LayoutBox* floatingBox = *it;
         floatingBox->layoutIfNeeded();
         LayoutSize newSize = floatingBox->size() +
             LayoutSize(floatingBox->marginWidth(), floatingBox->marginHeight());
         if (floats[floatIndex].object != floatingBox) {
             encounteredNewFloat = true;
             return;
         }
 
         if (floats[floatIndex].rect.size() != newSize) {
             LayoutUnit floatTop = isHorizontalWritingMode() ? floats[floatIndex].rect.y() : floats[floatIndex].rect.x();
@@ skipping 88 matching lines @@
         // If we have no dirty lines, then last is just the last root box.
         last = curr ? curr->prevRootBox() : lastRootBox();
     }
 
     unsigned numCleanFloats = 0;
     if (!layoutState.floats().isEmpty()) {
         LayoutUnit savedLogicalHeight = logicalHeight();
         // Restore floats from clean lines.
         RootInlineBox* line = firstRootBox();
         while (line != curr) {
-            if (Vector<RenderBox*>* cleanLineFloats = line->floatsPtr()) {
-                Vector<RenderBox*>::iterator end = cleanLineFloats->end();
-                for (Vector<RenderBox*>::iterator f = cleanLineFloats->begin(); f != end; ++f) {
+            if (Vector<LayoutBox*>* cleanLineFloats = line->floatsPtr()) {
+                Vector<LayoutBox*>::iterator end = cleanLineFloats->end();
+                for (Vector<LayoutBox*>::iterator f = cleanLineFloats->begin(); f != end; ++f) {
                     FloatingObject* floatingObject = insertFloatingObject(**f);
                     ASSERT(!floatingObject->originatingLine());
                     floatingObject->setOriginatingLine(line);
                     setLogicalHeight(logicalTopForChild(**f) - marginBeforeForChild(**f));
                     positionNewFloats();
                     ASSERT(layoutState.floats()[numCleanFloats].object == *f);
                     numCleanFloats++;
                 }
             }
             line = line->nextRootBox();
@@ skipping 259 matching lines @@
     FloatingObjectSetIterator it = floatingObjectSet.end();
     --it; // Last float is newFloat, skip that one.
     FloatingObjectSetIterator begin = floatingObjectSet.begin();
     while (it != begin) {
         --it;
         FloatingObject* floatingObject = it->get();
         if (floatingObject == lastFloatFromPreviousLine)
             break;
         if (logicalTopForFloat(floatingObject) == logicalHeight() + lineInfo.floatPaginationStrut()) {
             floatingObject->setPaginationStrut(paginationStrut + floatingObject->paginationStrut());
-            RenderBox* floatBox = floatingObject->renderer();
+            LayoutBox* floatBox = floatingObject->renderer();
             setLogicalTopForChild(*floatBox, logicalTopForChild(*floatBox) + marginBeforeForChild(*floatBox) + paginationStrut);
             if (floatBox->isRenderBlock())
                 floatBox->forceChildLayout();
             else
                 floatBox->layoutIfNeeded();
             // Save the old logical top before calling removePlacedObject which will set
             // isPlaced to false. Otherwise it will trigger an assert in logicalTopForFloat.
             LayoutUnit oldLogicalTop = logicalTopForFloat(floatingObject);
             m_floatingObjects->removePlacedObject(floatingObject);
             setLogicalTopForFloat(floatingObject, oldLogicalTop + paginationStrut);
@@ skipping 19 matching lines @@
     float logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false).toFloat();
     float availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }