Rename renderer() to layoutObject().

Source/core/layout/LayoutBlockFlowLine.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 202 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() != LayoutObject::SelectionNone)
+        if (!rootHasSelectedChildren && box->layoutObject().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()) {
+        if (!parentBox || parentBox->layoutObject() != 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 {
             // Append the inline box to this line.
             parentBox->addToLine(box);
         }
 
         box->setBidiLevel(r->level());
 
         if (box->isInlineTextBox()) {
@@ skipping 242 matching lines @@
             expansionOpportunityCount -= opportunitiesInRun;
             if (!expansionOpportunityCount)
                 break;
         }
     }
 }
 
 void LayoutBlockFlow::updateLogicalWidthForAlignment(const ETextAlign& textAlign, const RootInlineBox* rootInlineBox, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float& availableLogicalWidth, unsigned expansionOpportunityCount)
 {
     TextDirection direction;
-    if (rootInlineBox && rootInlineBox->renderer().style()->unicodeBidi() == Plaintext)
+    if (rootInlineBox && rootInlineBox->layoutObject().style()->unicodeBidi() == Plaintext)
         direction = rootInlineBox->direction();
     else
         direction = style()->direction();
 
     // Armed with the total width of the line (without justification),
     // we now examine our text-align property in order to determine where to position the
     // objects horizontally. The total width of the line can be increased if we end up
     // justifying text.
     switch (textAlign) {
     case LEFT:
@@ skipping 163 matching lines @@
             toLayoutText(r->m_object)->positionLineBox(r->m_box);
         else if (r->m_object->isBox())
             toLayoutBox(r->m_object)->positionLineBox(r->m_box);
     }
 }
 
 void LayoutBlockFlow::appendFloatingObjectToLastLine(FloatingObject* floatingObject)
 {
     ASSERT(!floatingObject->originatingLine());
     floatingObject->setOriginatingLine(lastRootBox());
-    lastRootBox()->appendFloat(floatingObject->renderer());
+    lastRootBox()->appendFloat(floatingObject->layoutObject());
 }
 
 // This function constructs line boxes for all of the text runs in the resolver and computes their position.
 RootInlineBox* LayoutBlockFlow::createLineBoxesFromBidiRuns(unsigned bidiLevel, BidiRunList<BidiRun>& bidiRuns, const InlineIterator& end, LineInfo& lineInfo, VerticalPositionCache& verticalPositionCache, BidiRun* trailingSpaceRun, WordMeasurements& wordMeasurements)
 {
     if (!bidiRuns.runCount())
         return 0;
 
     // FIXME: Why is this only done when we had runs?
     lineInfo.setLastLine(!end.object());
@@ skipping 65 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()) {
-            LayoutObject* lastObject = &lastLeafChild->renderer();
+            LayoutObject* lastObject = &lastLeafChild->layoutObject();
             if (!lastObject->isBR())
-                lastObject = &lastRootBox()->firstLeafChild()->renderer();
+                lastObject = &lastRootBox()->firstLeafChild()->layoutObject();
             if (lastObject->isBR()) {
                 EClear clear = lastObject->style()->clear();
                 if (clear != CNONE)
                     clearFloats(clear);
             }
         }
     }
 
     layoutRunsAndFloatsInRange(layoutState, resolver, cleanLineStart, cleanLineBidiStatus);
     linkToEndLineIfNeeded(layoutState);
@@ skipping 132 matching lines @@
                 FloatingObjectSetIterator end = floatingObjectSet.end();
                 if (layoutState.lastFloat()) {
                     FloatingObjectSetIterator lastFloatIterator = floatingObjectSet.find(layoutState.lastFloat());
                     ASSERT(lastFloatIterator != end);
                     ++lastFloatIterator;
                     it = lastFloatIterator;
                 }
                 for (; it != end; ++it) {
                     FloatingObject* f = it->get();
                     appendFloatingObjectToLastLine(f);
-                    ASSERT(f->renderer() == layoutState.floats()[layoutState.floatIndex()].object);
+                    ASSERT(f->layoutObject() == layoutState.floats()[layoutState.floatIndex()].object);
                     // If a float's geometry has changed, give up on syncing with clean lines.
                     if (layoutState.floats()[layoutState.floatIndex()].rect != f->frameRect())
                         checkForEndLineMatch = false;
                     layoutState.setFloatIndex(layoutState.floatIndex() + 1);
                 }
                 layoutState.setLastFloat(!floatingObjectSet.isEmpty() ? floatingObjectSet.last().get() : 0);
             }
         }
 
         lineMidpointState.reset();
@@ skipping 1084 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());
-            LayoutBox* floatBox = floatingObject->renderer();
+            LayoutBox* floatBox = floatingObject->layoutObject();
             setLogicalTopForChild(*floatBox, logicalTopForChild(*floatBox) + marginBeforeForChild(*floatBox) + paginationStrut);
             if (floatBox->isLayoutBlock())
                 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;
 }
 
 }