Rename RenderText to LayoutText

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 51 matching lines @@
 
     if (obj->isBox())
         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);
+    LayoutText* text = toLayoutText(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(LayoutObject* o, bool fullLayout)
 {
     if (o->isText()) {
-        RenderText* renderText = toRenderText(o);
+        LayoutText* renderText = toLayoutText(o);
         renderText->dirtyOrDeleteLineBoxesIfNeeded(fullLayout);
     } else
         toRenderInline(o)->dirtyLineBoxes(fullLayout);
 }
 
 static bool parentIsConstructedOrHaveNext(InlineFlowBox* parentBox)
 {
     do {
         if (parentBox->isConstructed() || parentBox->nextOnLine())
             return true;
@@ skipping 77 matching lines @@
 
 static bool reachedEndOfTextRenderer(const BidiRunList<BidiRun>& bidiRuns)
 {
     BidiRun* run = bidiRuns.logicallyLastRun();
     if (!run)
         return true;
     unsigned pos = run->stop();
     LayoutObject* r = run->m_object;
     if (!r->isText() || r->isBR())
         return false;
-    RenderText* renderText = toRenderText(r);
+    LayoutText* renderText = toLayoutText(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);
 }
 
 RootInlineBox* RenderBlockFlow::constructLine(BidiRunList<BidiRun>& bidiRuns, const LineInfo& lineInfo)
@@ skipping 162 matching lines @@
         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);
 }
 
-static inline void setLogicalWidthForTextRun(RootInlineBox* lineBox, BidiRun* run, RenderText* renderer, float xPos, const LineInfo& lineInfo,
+static inline void setLogicalWidthForTextRun(RootInlineBox* lineBox, BidiRun* run, LayoutText* renderer, float xPos, const LineInfo& lineInfo,
                                              GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache, WordMeasurements& wordMeasurements)
 {
     HashSet<const SimpleFontData*> fallbackFonts;
     GlyphOverflow glyphOverflow;
 
     const Font& font = renderer->style(lineInfo.isFirstLine())->font();
     // Always compute glyph overflow if the block's line-box-contain value is "glyphs".
     if (lineBox->fitsToGlyphs()) {
         // If we don't stick out of the root line's font box, then don't bother computing our glyph overflow. This optimization
         // will keep us from computing glyph bounds in nearly all cases.
@@ skipping 207 matching lines @@
     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);
+            LayoutText* rt = toLayoutText(r->m_object);
             if (textAlign == JUSTIFY && r != trailingSpaceRun && textJustify != TextJustifyNone) {
                 if (!isAfterExpansion)
                     toInlineTextBox(r->m_box)->setCanHaveLeadingExpansion(true);
                 unsigned opportunitiesInRun;
                 if (rt->is8Bit())
                     opportunitiesInRun = Character::expansionOpportunityCount(rt->characters8() + r->m_start, r->m_stop - r->m_start, r->m_box->direction(), isAfterExpansion, textJustify);
                 else
                     opportunitiesInRun = Character::expansionOpportunityCount(rt->characters16() + r->m_start, r->m_stop - r->m_start, r->m_box->direction(), isAfterExpansion, textJustify);
                 expansionOpportunities.append(opportunitiesInRun);
                 expansionOpportunityCount += opportunitiesInRun;
@@ skipping 46 matching lines @@
             continue; // Skip runs with no line boxes.
 
         // 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);
+            toLayoutText(r->m_object)->positionLineBox(r->m_box);
         else if (r->m_object->isBox())
             toLayoutBox(r->m_object)->positionLineBox(r->m_box);
     }
 }
 
 void RenderBlockFlow::appendFloatingObjectToLastLine(FloatingObject* floatingObject)
 {
     ASSERT(!floatingObject->originatingLine());
     floatingObject->setOriginatingLine(lastRootBox());
     lastRootBox()->appendFloat(floatingObject->renderer());
@@ skipping 491 matching lines @@
 }
 
 static inline void stripTrailingSpace(FloatWillBeLayoutUnit& inlineMax, FloatWillBeLayoutUnit& inlineMin,
     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);
+        LayoutText* text = toLayoutText(trailingSpaceChild);
         UChar trailingWhitespaceChar = ' ';
         for (unsigned i = text->textLength(); i > 0; i--) {
             UChar c = text->characterAt(i - 1);
             if (!Character::treatAsSpace(c))
                 break;
             trailingWhitespaceChar = c;
         }
 
         // FIXME: This ignores first-line.
         const Font& font = text->style()->font();
@@ skipping 196 matching lines @@
                 }
 
                 // We are no longer stripping whitespace at the start of
                 // a line.
                 if (!child->isFloating()) {
                     stripFrontSpaces = false;
                     trailingSpaceChild = 0;
                 }
             } else if (child->isText()) {
                 // Case (3). Text.
-                RenderText* t = toRenderText(child);
+                LayoutText* t = toLayoutText(child);
 
                 if (t->isWordBreak()) {
                     minLogicalWidth = std::max(minLogicalWidth, inlineMin.toLayoutUnit());
                     inlineMin = FloatWillBeLayoutUnit();
                     continue;
                 }
 
                 // Determine if we have a breakable character. Pass in
                 // whether or not we should ignore any spaces at the front
                 // of the string. If those are going to be stripped out,
@@ skipping 301 matching lines @@
             RootInlineBox* next = curr->nextRootBox();
             curr->deleteLine();
             curr = next;
         }
         ASSERT(!firstLineBox() && !lastLineBox());
     } else {
         if (curr) {
             // We have a dirty line.
             if (RootInlineBox* prevRootBox = curr->prevRootBox()) {
                 // We have a previous line.
-                if (!dirtiedByFloat && (!prevRootBox->endsWithBreak() || !prevRootBox->lineBreakObj() || (prevRootBox->lineBreakObj()->isText() && prevRootBox->lineBreakPos() >= toRenderText(prevRootBox->lineBreakObj())->textLength())))
+                if (!dirtiedByFloat && (!prevRootBox->endsWithBreak() || !prevRootBox->lineBreakObj() || (prevRootBox->lineBreakObj()->isText() && prevRootBox->lineBreakPos() >= toLayoutText(prevRootBox->lineBreakObj())->textLength())))
                     // The previous line didn't break cleanly or broke at a newline
                     // that has been deleted, so treat it as dirty too.
                     curr = prevRootBox;
             }
         } else {
             // No dirty lines were found.
             // If the last line didn't break cleanly, treat it as dirty.
             if (lastRootBox() && !lastRootBox()->endsWithBreak())
                 curr = lastRootBox();
         }
@@ skipping 323 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;
 }
 
 }