Move rendering/RenderObject to layout/LayoutObject.

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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 
 #include "core/dom/AXObjectCache.h"
 #include "core/layout/BidiRunForLine.h"
 #include "core/layout/Layer.h"
 #include "core/layout/LayoutCounter.h"
+#include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutRubyRun.h"
 #include "core/layout/line/BreakingContextInlineHeaders.h"
 #include "core/layout/line/LayoutTextInfo.h"
 #include "core/layout/line/LineLayoutState.h"
 #include "core/layout/line/LineWidth.h"
 #include "core/layout/line/TrailingFloatsRootInlineBox.h"
 #include "core/layout/line/WordMeasurement.h"
 #include "core/layout/svg/line/SVGRootInlineBox.h"
 #include "core/rendering/RenderFlowThread.h"
 #include "core/rendering/RenderListMarker.h"
-#include "core/rendering/RenderObjectInlines.h"
 #include "core/rendering/RenderRegion.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/TextRunConstructor.h"
 #include "core/rendering/VerticalPositionCache.h"
 #include "platform/fonts/Character.h"
 #include "platform/text/BidiResolver.h"
 #include "wtf/RefCountedLeakCounter.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/unicode/CharacterNames.h"
 
 namespace blink {
 
 using namespace WTF::Unicode;
 
-static inline InlineBox* createInlineBoxForRenderer(RenderObject* obj, bool isRootLineBox, bool isOnlyRun = false)
+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 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
     // (Note the use of strict mode.  In "almost strict" mode, we don't treat the box for <br> as text.)
     if (text->isBR())
         textBox->setIsText(isOnlyRun || text->document().inNoQuirksMode());
     textBox->setDirOverride(run.dirOverride(text->style()->rtlOrdering() == VisualOrder));
     if (run.m_hasHyphen)
         textBox->setHasHyphen(true);
     return textBox;
 }
 
-static inline void dirtyLineBoxesForRenderer(RenderObject* o, bool fullLayout)
+static inline void dirtyLineBoxesForRenderer(LayoutObject* o, bool fullLayout)
 {
     if (o->isText()) {
         RenderText* renderText = toRenderText(o);
         renderText->dirtyOrDeleteLineBoxesIfNeeded(fullLayout);
     } else
         toRenderInline(o)->dirtyLineBoxes(fullLayout);
 }
 
 static bool parentIsConstructedOrHaveNext(InlineFlowBox* parentBox)
 {
     do {
         if (parentBox->isConstructed() || parentBox->nextOnLine())
             return true;
         parentBox = parentBox->parent();
     } while (parentBox);
     return false;
 }
 
-InlineFlowBox* RenderBlockFlow::createLineBoxes(RenderObject* obj, const LineInfo& lineInfo, InlineBox* childBox)
+InlineFlowBox* RenderBlockFlow::createLineBoxes(LayoutObject* obj, const LineInfo& lineInfo, InlineBox* childBox)
 {
     // See if we have an unconstructed line box for this object that is also
     // the last item on the line.
     unsigned lineDepth = 1;
     InlineFlowBox* parentBox = 0;
     InlineFlowBox* result = 0;
     bool hasDefaultLineBoxContain = style()->lineBoxContain() == RenderStyle::initialLineBoxContain();
     do {
         ASSERT_WITH_SECURITY_IMPLICATION(obj->isRenderInline() || obj == this);
 
@@ skipping 58 matching lines @@
     }
     return false;
 }
 
 static bool reachedEndOfTextRenderer(const BidiRunList<BidiRun>& bidiRuns)
 {
     BidiRun* run = bidiRuns.logicallyLastRun();
     if (!run)
         return true;
     unsigned pos = run->stop();
-    RenderObject* r = run->m_object;
+    LayoutObject* r = run->m_object;
     if (!r->isText() || r->isBR())
         return false;
     RenderText* renderText = toRenderText(r);
     unsigned length = renderText->textLength();
     if (pos >= length)
         return true;
 
     if (renderText->is8Bit())
         return endsWithASCIISpaces(renderText->characters8(), pos, length);
     return endsWithASCIISpaces(renderText->characters16(), pos, length);
@@ skipping 19 matching lines @@
         if (r->m_object->isText())
             box = createInlineBoxForText(*r, isOnlyRun);
         else
             box = createInlineBoxForRenderer(r->m_object, false, isOnlyRun);
         r->m_box = box;
 
         ASSERT(box);
         if (!box)
             continue;
 
-        if (!rootHasSelectedChildren && box->renderer().selectionState() != RenderObject::SelectionNone)
+        if (!rootHasSelectedChildren && box->renderer().selectionState() != LayoutObject::SelectionNone)
             rootHasSelectedChildren = true;
 
         // If we have no parent box yet, or if the run is not simply a sibling,
         // then we need to construct inline boxes as necessary to properly enclose the
         // run's inline box. Segments can only be siblings at the root level, as
         // they are positioned separately.
         if (!parentBox || parentBox->renderer() != r->m_object->parent()) {
             // Create new inline boxes all the way back to the appropriate insertion point.
             parentBox = createLineBoxes(r->m_object->parent(), lineInfo, box);
         } else {
@@ skipping 109 matching lines @@
         totalLogicalWidth -= trailingSpaceRun->m_box->logicalWidth();
         trailingSpaceWidth = std::min(trailingSpaceRun->m_box->logicalWidth().toFloat(), (availableLogicalWidth - totalLogicalWidth + 1) / 2);
         trailingSpaceRun->m_box->setLogicalWidth(std::max<float>(0, trailingSpaceWidth));
     }
     if (isLeftToRightDirection)
         logicalLeft += std::max<float>((availableLogicalWidth - totalLogicalWidth) / 2, 0);
     else
         logicalLeft += totalLogicalWidth > availableLogicalWidth ? (availableLogicalWidth - totalLogicalWidth) : (availableLogicalWidth - totalLogicalWidth) / 2 - trailingSpaceWidth;
 }
 
-void RenderBlockFlow::setMarginsForRubyRun(BidiRun* run, LayoutRubyRun* renderer, RenderObject* previousObject, const LineInfo& lineInfo)
+void RenderBlockFlow::setMarginsForRubyRun(BidiRun* run, LayoutRubyRun* renderer, LayoutObject* previousObject, const LineInfo& lineInfo)
 {
     int startOverhang;
     int endOverhang;
-    RenderObject* nextObject = 0;
+    LayoutObject* nextObject = 0;
     for (BidiRun* runWithNextObject = run->next(); runWithNextObject; runWithNextObject = runWithNextObject->next()) {
         if (!runWithNextObject->m_object->isOutOfFlowPositioned() && !runWithNextObject->m_box->isLineBreak()) {
             nextObject = runWithNextObject->m_object;
             break;
         }
     }
     renderer->getOverhang(lineInfo.isFirstLine(), renderer->style()->isLeftToRightDirection() ? previousObject : nextObject, renderer->style()->isLeftToRightDirection() ? nextObject : previousObject, startOverhang, endOverhang);
     setMarginStartForChild(*renderer, -startOverhang);
     setMarginEndForChild(*renderer, -endOverhang);
 }
@@ skipping 209 matching lines @@
 
 BidiRun* RenderBlockFlow::computeInlineDirectionPositionsForSegment(RootInlineBox* lineBox, const LineInfo& lineInfo, ETextAlign textAlign, float& logicalLeft,
     float& availableLogicalWidth, BidiRun* firstRun, BidiRun* trailingSpaceRun, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache,
     WordMeasurements& wordMeasurements)
 {
     bool needsWordSpacing = true;
     float totalLogicalWidth = lineBox->getFlowSpacingLogicalWidth().toFloat();
     unsigned expansionOpportunityCount = 0;
     bool isAfterExpansion = true;
     Vector<unsigned, 16> expansionOpportunities;
-    RenderObject* previousObject = 0;
+    LayoutObject* previousObject = 0;
     TextJustify textJustify = style()->textJustify();
 
     BidiRun* r = firstRun;
     for (; r; r = r->next()) {
         if (!r->m_box || r->m_object->isOutOfFlowPositioned() || r->m_box->isLineBreak())
             continue; // Positioned objects are only participating to figure out their
                       // correct static x position.  They have no effect on the width.
                       // Similarly, line break boxes have no effect on the width.
         if (r->m_object->isText()) {
             RenderText* rt = toRenderText(r->m_object);
@@ skipping 152 matching lines @@
         if (!layoutState.usesPaintInvalidationBounds())
             layoutState.setPaintInvalidationRange(logicalHeight());
         deleteLineRange(layoutState, startLine);
     }
 
     if (!layoutState.isFullLayout() && lastRootBox() && lastRootBox()->endsWithBreak()) {
         // If the last line before the start line ends with a line break that clear floats,
         // adjust the height accordingly.
         // A line break can be either the first or the last object on a line, depending on its direction.
         if (InlineBox* lastLeafChild = lastRootBox()->lastLeafChild()) {
-            RenderObject* lastObject = &lastLeafChild->renderer();
+            LayoutObject* lastObject = &lastLeafChild->renderer();
             if (!lastObject->isBR())
                 lastObject = &lastRootBox()->firstLeafChild()->renderer();
             if (lastObject->isBR()) {
                 EClear clear = lastObject->style()->clear();
                 if (clear != CNONE)
                     clearFloats(clear);
             }
         }
     }
 
@@ skipping 311 matching lines @@
 
 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)
    (2) We do not drill into the children of floats or replaced elements, since you can't break
        in the middle of such an element.
    (3) Inline flows (e.g., <a>, <span>, <i>) are walked twice, since each side can have
        distinct borders/margin/padding that contribute to the min/max width.
 */
-    RenderObject* parent;
-    RenderObject* current;
+    LayoutObject* parent;
+    LayoutObject* current;
     bool endOfInline;
 
-    InlineMinMaxIterator(RenderObject* p, bool end = false)
+    InlineMinMaxIterator(LayoutObject* p, bool end = false)
         : parent(p), current(p), endOfInline(end)
     {
 
     }
 
-    RenderObject* next();
+    LayoutObject* next();
 };
 
-RenderObject* InlineMinMaxIterator::next()
+LayoutObject* InlineMinMaxIterator::next()
 {
-    RenderObject* result = 0;
+    LayoutObject* result = 0;
     bool oldEndOfInline = endOfInline;
     endOfInline = false;
     while (current || current == parent) {
         if (!oldEndOfInline && (current == parent || (!current->isFloating() && !current->isReplaced() && !current->isOutOfFlowPositioned())))
             result = current->slowFirstChild();
 
         if (!result) {
             // We hit the end of our inline. (It was empty, e.g., <span></span>.)
             if (!oldEndOfInline && current->isRenderInline()) {
                 result = current;
@@ skipping 43 matching lines @@
         return getBPMWidth(child->marginEnd(), childStyle->marginEnd()) +
             getBPMWidth(child->paddingEnd(), childStyle->paddingEnd()) +
             child->borderEnd();
     }
     return getBPMWidth(child->marginStart(), childStyle->marginStart()) +
         getBPMWidth(child->paddingStart(), childStyle->paddingStart()) +
         child->borderStart();
 }
 
 static inline void stripTrailingSpace(FloatWillBeLayoutUnit& inlineMax, FloatWillBeLayoutUnit& inlineMin,
-    RenderObject* trailingSpaceChild)
+    LayoutObject* trailingSpaceChild)
 {
     if (trailingSpaceChild && trailingSpaceChild->isText()) {
         // Collapse away the trailing space at the end of a block by finding
         // the first white-space character and subtracting its width. Subsequent
         // white-space characters have been collapsed into the first one (which
         // can be either a space or a tab character).
         RenderText* text = toRenderText(trailingSpaceChild);
         UChar trailingWhitespaceChar = ' ';
         for (unsigned i = text->textLength(); i > 0; i--) {
             UChar c = text->characterAt(i - 1);
@@ skipping 32 matching lines @@
     FloatWillBeLayoutUnit inlineMax;
     FloatWillBeLayoutUnit inlineMin;
 
     RenderStyle* styleToUse = style();
     RenderBlock* containingBlock = this->containingBlock();
     LayoutUnit cw = containingBlock ? containingBlock->contentLogicalWidth() : LayoutUnit();
 
     // If we are at the start of a line, we want to ignore all white-space.
     // Also strip spaces if we previously had text that ended in a trailing space.
     bool stripFrontSpaces = true;
-    RenderObject* trailingSpaceChild = 0;
+    LayoutObject* trailingSpaceChild = 0;
 
     // Firefox and Opera will allow a table cell to grow to fit an image inside it under
     // very specific cirucumstances (in order to match common WinIE renderings).
     // Not supporting the quirk has caused us to mis-render some real sites. (See Bugzilla 10517.)
     bool allowImagesToBreak = !document().inQuirksMode() || !isTableCell() || !styleToUse->logicalWidth().isIntrinsicOrAuto();
 
     bool autoWrap, oldAutoWrap;
     autoWrap = oldAutoWrap = styleToUse->autoWrap();
 
     InlineMinMaxIterator childIterator(this);
 
     // Only gets added to the max preffered width once.
     bool addedTextIndent = false;
     // Signals the text indent was more negative than the min preferred width
     bool hasRemainingNegativeTextIndent = false;
 
     LayoutUnit textIndent = minimumValueForLength(styleToUse->textIndent(), cw);
-    RenderObject* prevFloat = 0;
+    LayoutObject* prevFloat = 0;
     bool isPrevChildInlineFlow = false;
     bool shouldBreakLineAfterText = false;
-    while (RenderObject* child = childIterator.next()) {
+    while (LayoutObject* child = childIterator.next()) {
         autoWrap = child->isReplaced() ? child->parent()->style()->autoWrap() :
             child->style()->autoWrap();
 
         if (!child->isBR()) {
             // Step One: determine whether or not we need to go ahead and
             // terminate our current line. Each discrete chunk can become
             // the new min-width, if it is the widest chunk seen so far, and
             // it can also become the max-width.
 
             // Children fall into three categories:
@@ skipping 293 matching lines @@
          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;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
-            RenderObject* o = walker.current();
+            LayoutObject* o = walker.current();
 
             if (!layoutState.hasInlineChild() && o->isInline())
                 layoutState.setHasInlineChild(true);
 
             if (o->isReplaced() || o->isFloating() || o->isOutOfFlowPositioned()) {
                 RenderBox* box = toRenderBox(o);
 
                 updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, *box);
 
                 if (o->isOutOfFlowPositioned())
@@ skipping 312 matching lines @@
 
             // Now delete the lines that we failed to sync.
             deleteLineRange(layoutState, originalEndLine, result);
             return matched;
         }
     }
 
     return false;
 }
 
-bool RenderBlockFlow::generatesLineBoxesForInlineChild(RenderObject* inlineObj)
+bool RenderBlockFlow::generatesLineBoxesForInlineChild(LayoutObject* inlineObj)
 
 {
     ASSERT(inlineObj->parent() == this);
 
     InlineIterator it(this, inlineObj, 0);
     // FIXME: We should pass correct value for WhitespacePosition.
     while (!it.atEnd() && !requiresLineBox(it))
         it.increment();
 
     return !it.atEnd();
@@ skipping 148 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;
 }
 
 }