Rename RenderText to LayoutText

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 241 matching lines @@
             dirtyLineBoxes(false);
         setAlwaysCreateLineBoxes();
     }
 }
 
 LayoutRect RenderInline::localCaretRect(InlineBox* inlineBox, int, LayoutUnit* extraWidthToEndOfLine)
 {
     if (firstChild()) {
         // This condition is possible if the RenderInline is at an editing boundary,
         // i.e. the VisiblePosition is:
-        //   <RenderInline editingBoundary=true>|<RenderText> </RenderText></RenderInline>
+        //   <RenderInline editingBoundary=true>|<LayoutText> </LayoutText></RenderInline>
         // FIXME: need to figure out how to make this return a valid rect, note that
         // there are no line boxes created in the above case.
         return LayoutRect();
     }
 
     ASSERT_UNUSED(inlineBox, !inlineBox);
 
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = 0;
 
@@ skipping 338 matching lines @@
                             childLine->logicalWidth() + childLine->marginLogicalLeft() + childLine->marginLogicalRight(),
                             logicalHeight));
                     else
                         yield(FloatRect(logicalTop,
                             childLine->y() - childLine->marginLogicalLeft(),
                             logicalHeight,
                             childLine->logicalWidth() + childLine->marginLogicalLeft() + childLine->marginLogicalRight()));
                 }
             }
         } else if (curr->isText()) {
-            RenderText* currText = toRenderText(curr);
+            LayoutText* currText = toLayoutText(curr);
             for (InlineTextBox* childText = currText->firstTextBox(); childText; childText = childText->nextTextBox()) {
                 RootInlineBox& rootBox = childText->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(childText->x(), logicalTop, childText->logicalWidth(), logicalHeight));
                 else
                     yield(FloatRect(logicalTop, childText->y(), logicalHeight, childText->logicalWidth()));
             }
         }
@@ skipping 285 matching lines @@
         // 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 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);
+            LayoutText* currText = toLayoutText(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 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);
+            LayoutText* currText = toLayoutText(curr);
             if (currText->lastTextBox())
                 return currText->lastTextBox();
         }
     }
     return 0;
 }
 
 LayoutRect RenderInline::culledInlineVisualOverflowBoundingBox() const
 {
     FloatRect floatResult;
@@ skipping 21 matching lines @@
         } else if (curr->isRenderInline()) {
             // If the child doesn't need line boxes either, then we can recur.
             RenderInline* currInline = toRenderInline(curr);
             if (!currInline->alwaysCreateLineBoxes())
                 result.uniteIfNonZero(currInline->culledInlineVisualOverflowBoundingBox());
             else if (!currInline->hasSelfPaintingLayer())
                 result.uniteIfNonZero(currInline->linesVisualOverflowBoundingBox());
         } else if (curr->isText()) {
             // FIXME; Overflow from text boxes is lost. We will need to cache this information in
             // InlineTextBoxes.
-            RenderText* currText = toRenderText(curr);
+            LayoutText* currText = toLayoutText(curr);
             result.uniteIfNonZero(currText->linesVisualOverflowBoundingBox());
         }
     }
     return result;
 }
 
 LayoutRect RenderInline::linesVisualOverflowBoundingBox() const
 {
     if (!alwaysCreateLineBoxes())
         return culledInlineVisualOverflowBoundingBox();
@@ skipping 274 matching lines @@
             if (curr->isBox() && !curr->needsLayout()) {
                 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);
+                    LayoutText* currText = toLayoutText(curr);
                     for (InlineTextBox* childText = currText->firstTextBox(); childText; childText = childText->nextTextBox())
                         childText->root().markDirty();
                 }
             }
         }
     } else
         m_lineBoxes.dirtyLineBoxes();
 }
 
 InlineFlowBox* RenderInline::createInlineFlowBox()
@@ skipping 153 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