Rename RenderText to LayoutText

Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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/rendering/RenderText.h"
+#include "core/layout/LayoutText.h"
 
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/Text.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/layout/Layer.h"
 #include "core/layout/LayoutBlock.h"
+#include "core/layout/LayoutTextCombine.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/TextRunConstructor.h"
 #include "core/layout/line/AbstractInlineTextBox.h"
 #include "core/layout/line/EllipsisBox.h"
 #include "core/layout/line/InlineTextBox.h"
-#include "core/rendering/RenderCombineText.h"
 #include "platform/fonts/Character.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextBreakIterator.h"
 #include "platform/text/TextRunIterator.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/unicode/CharacterNames.h"
 
 using namespace WTF;
 using namespace Unicode;
 
 namespace blink {
 
 struct SameSizeAsRenderText : public LayoutObject {
     uint32_t bitfields : 16;
     float widths[4];
     String text;
     void* pointers[2];
 };
 
-static_assert(sizeof(RenderText) == sizeof(SameSizeAsRenderText), "RenderText should stay small");
+static_assert(sizeof(LayoutText) == sizeof(SameSizeAsRenderText), "LayoutText should stay small");
 
 class SecureTextTimer;
-typedef HashMap<RenderText*, SecureTextTimer*> SecureTextTimerMap;
+typedef HashMap<LayoutText*, SecureTextTimer*> SecureTextTimerMap;
 static SecureTextTimerMap* gSecureTextTimers = 0;
 
 class SecureTextTimer final : public TimerBase {
 public:
-    SecureTextTimer(RenderText* renderText)
+    SecureTextTimer(LayoutText* renderText)
         : m_renderText(renderText)
         , m_lastTypedCharacterOffset(-1)
     {
     }
 
     void restartWithNewText(unsigned lastTypedCharacterOffset)
     {
         m_lastTypedCharacterOffset = lastTypedCharacterOffset;
         if (Settings* settings = m_renderText->document().settings())
             startOneShot(settings->passwordEchoDurationInSeconds(), FROM_HERE);
     }
     void invalidate() { m_lastTypedCharacterOffset = -1; }
     unsigned lastTypedCharacterOffset() { return m_lastTypedCharacterOffset; }
 
 private:
     virtual void fired() override
     {
         ASSERT(gSecureTextTimers->contains(m_renderText));
         m_renderText->setText(m_renderText->text().impl(), true /* forcing setting text as it may be masked later */);
     }
 
-    RenderText* m_renderText;
+    LayoutText* m_renderText;
     int m_lastTypedCharacterOffset;
 };
 
 static void makeCapitalized(String* string, UChar previous)
 {
     if (string->isNull())
         return;
 
     unsigned length = string->length();
     const StringImpl& input = *string->impl();
@@ skipping 23 matching lines @@
     for (endOfWord = boundary->next(); endOfWord != TextBreakDone; startOfWord = endOfWord, endOfWord = boundary->next()) {
         if (startOfWord) // Ignore first char of previous string
             result.append(input[startOfWord - 1] == noBreakSpace ? noBreakSpace : toTitleCase(stringWithPrevious[startOfWord]));
         for (int i = startOfWord + 1; i < endOfWord; i++)
             result.append(input[i - 1]);
     }
 
     *string = result.toString();
 }
 
-RenderText::RenderText(Node* node, PassRefPtr<StringImpl> str)
+LayoutText::LayoutText(Node* node, PassRefPtr<StringImpl> str)
     : LayoutObject(!node || node->isDocumentNode() ? 0 : node)
     , m_hasTab(false)
     , m_linesDirty(false)
     , m_containsReversedText(false)
     , m_knownToHaveNoOverflowAndNoFallbackFonts(false)
     , m_minWidth(-1)
     , m_maxWidth(-1)
     , m_firstLineMinWidth(0)
     , m_lastLineLineMinWidth(0)
     , m_text(str)
     , m_firstTextBox(0)
     , m_lastTextBox(0)
 {
     ASSERT(m_text);
-    // FIXME: Some clients of RenderText (and subclasses) pass Document as node to create anonymous renderer.
+    // FIXME: Some clients of LayoutText (and subclasses) pass Document as node to create anonymous renderer.
     // They should be switched to passing null and using setDocumentForAnonymous.
     if (node && node->isDocumentNode())
         setDocumentForAnonymous(toDocument(node));
 
     m_isAllASCII = m_text.containsOnlyASCII();
     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
     setIsText();
 
     view()->frameView()->incrementVisuallyNonEmptyCharacterCount(m_text.length());
 }
 
 #if ENABLE(ASSERT)
 
-RenderText::~RenderText()
+LayoutText::~LayoutText()
 {
     ASSERT(!m_firstTextBox);
     ASSERT(!m_lastTextBox);
 }
 
 #endif
 
-const char* RenderText::renderName() const
+const char* LayoutText::renderName() const
 {
+    // FIXME: Rename to LayoutText
     return "RenderText";
 }
 
-bool RenderText::isTextFragment() const
+bool LayoutText::isTextFragment() const
 {
     return false;
 }
 
-bool RenderText::isWordBreak() const
+bool LayoutText::isWordBreak() const
 {
     return false;
 }
 
-void RenderText::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
+void LayoutText::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
 {
     // There is no need to ever schedule paint invalidations from a style change of a text run, since
     // we already did this for the parent of the text run.
     // We do have to schedule layouts, though, since a style change can force us to
     // need to relayout.
     if (diff.needsFullLayout()) {
         setNeedsLayoutAndPrefWidthsRecalc();
         m_knownToHaveNoOverflowAndNoFallbackFonts = false;
     }
 
     const LayoutStyle& newStyle = styleRef();
     ETextTransform oldTransform = oldStyle ? oldStyle->textTransform() : TTNONE;
     ETextSecurity oldSecurity = oldStyle ? oldStyle->textSecurity() : TSNONE;
     if (oldTransform != newStyle.textTransform() || oldSecurity != newStyle.textSecurity())
         transformText();
 
     // This is an optimization that kicks off font load before layout.
     // In order to make it fast, we only check if the first character of the
     // text is included in the unicode ranges of the fonts.
     if (!text().containsOnlyWhitespace())
         newStyle.font().willUseFontData(text().characterStartingAt(0));
 }
 
-void RenderText::removeAndDestroyTextBoxes()
+void LayoutText::removeAndDestroyTextBoxes()
 {
     if (!documentBeingDestroyed()) {
         if (firstTextBox()) {
             if (isBR()) {
                 RootInlineBox* next = firstTextBox()->root().nextRootBox();
                 if (next)
                     next->markDirty();
             }
             for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
                 box->remove();
-        } else if (parent())
+        } else if (parent()) {
             parent()->dirtyLinesFromChangedChild(this);
+        }
     }
     deleteTextBoxes();
 }
 
-void RenderText::willBeDestroyed()
+void LayoutText::willBeDestroyed()
 {
     if (SecureTextTimer* secureTextTimer = gSecureTextTimers ? gSecureTextTimers->take(this) : 0)
         delete secureTextTimer;
 
     removeAndDestroyTextBoxes();
     LayoutObject::willBeDestroyed();
 }
 
-void RenderText::extractTextBox(InlineTextBox* box)
+void LayoutText::extractTextBox(InlineTextBox* box)
 {
     checkConsistency();
 
     m_lastTextBox = box->prevTextBox();
     if (box == m_firstTextBox)
         m_firstTextBox = 0;
     if (box->prevTextBox())
         box->prevTextBox()->setNextTextBox(0);
     box->setPreviousTextBox(0);
     for (InlineTextBox* curr = box; curr; curr = curr->nextTextBox())
         curr->setExtracted();
 
     checkConsistency();
 }
 
-void RenderText::attachTextBox(InlineTextBox* box)
+void LayoutText::attachTextBox(InlineTextBox* box)
 {
     checkConsistency();
 
     if (m_lastTextBox) {
         m_lastTextBox->setNextTextBox(box);
         box->setPreviousTextBox(m_lastTextBox);
-    } else
+    } else {
         m_firstTextBox = box;
+    }
     InlineTextBox* last = box;
     for (InlineTextBox* curr = box; curr; curr = curr->nextTextBox()) {
         curr->setExtracted(false);
         last = curr;
     }
     m_lastTextBox = last;
 
     checkConsistency();
 }
 
-void RenderText::removeTextBox(InlineTextBox* box)
+void LayoutText::removeTextBox(InlineTextBox* box)
 {
     checkConsistency();
 
     if (box == m_firstTextBox)
         m_firstTextBox = box->nextTextBox();
     if (box == m_lastTextBox)
         m_lastTextBox = box->prevTextBox();
     if (box->nextTextBox())
         box->nextTextBox()->setPreviousTextBox(box->prevTextBox());
     if (box->prevTextBox())
         box->prevTextBox()->setNextTextBox(box->nextTextBox());
 
     checkConsistency();
 }
 
-void RenderText::deleteTextBoxes()
+void LayoutText::deleteTextBoxes()
 {
     if (firstTextBox()) {
         InlineTextBox* next;
         for (InlineTextBox* curr = firstTextBox(); curr; curr = next) {
             next = curr->nextTextBox();
             curr->destroy();
         }
         m_firstTextBox = m_lastTextBox = 0;
     }
 }
 
-PassRefPtr<StringImpl> RenderText::originalText() const
+PassRefPtr<StringImpl> LayoutText::originalText() const
 {
     Node* e = node();
     return (e && e->isTextNode()) ? toText(e)->dataImpl() : 0;
 }
 
-String RenderText::plainText() const
+String LayoutText::plainText() const
 {
     if (node())
         return blink::plainText(rangeOfContents(node()).get());
 
     // FIXME: this is just a stopgap until TextIterator is adapted to support generated text.
     StringBuilder plainTextBuilder;
     for (InlineTextBox* textBox = firstTextBox(); textBox; textBox = textBox->nextTextBox()) {
         String text = m_text.substring(textBox->start(), textBox->len()).simplifyWhiteSpace(WTF::DoNotStripWhiteSpace);
         plainTextBuilder.append(text);
         if (textBox->nextTextBox() && textBox->nextTextBox()->start() > textBox->end() && text.length() && !text.right(1).containsOnlyWhitespace())
             plainTextBuilder.append(space);
     }
     return plainTextBuilder.toString();
 }
 
-void RenderText::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
+void LayoutText::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         rects.append(enclosingIntRect(FloatRect(FloatPoint(accumulatedOffset) + box->topLeft().toFloatPoint(), box->size().toFloatSize())));
 }
 
 static FloatRect localQuadForTextBox(InlineTextBox* box, unsigned start, unsigned end, bool useSelectionHeight)
 {
     unsigned realEnd = std::min(box->end() + 1, end);
     LayoutRect r = box->localSelectionRect(start, realEnd);
     if (r.height()) {
         if (!useSelectionHeight) {
             // Change the height and y position (or width and x for vertical text)
             // because selectionRect uses selection-specific values.
             if (box->isHorizontal()) {
                 r.setHeight(box->height());
                 r.setY(box->y());
             } else {
                 r.setWidth(box->width());
                 r.setX(box->x());
             }
         }
         return FloatRect(r);
     }
     return FloatRect();
 }
 
-void RenderText::absoluteRectsForRange(Vector<IntRect>& rects, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed)
+void LayoutText::absoluteRectsForRange(Vector<IntRect>& rects, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed)
 {
     // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
     // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this
     // function to take ints causes various internal mismatches. But selectionRect takes ints, and
     // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but
     // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
     ASSERT(end == UINT_MAX || end <= INT_MAX);
     ASSERT(start <= INT_MAX);
     start = std::min(start, static_cast<unsigned>(INT_MAX));
     end = std::min(end, static_cast<unsigned>(INT_MAX));
@@ skipping 39 matching lines @@
         // The ellipsis should be considered to be selected if the end of
         // the selection is past the beginning of the truncation and the
         // beginning of the selection is before or at the beginning of the truncation.
         if (ellipsisEndPosition >= truncation && ellipsisStartPosition <= truncation)
             return ellipsis->selectionRect();
     }
 
     return IntRect();
 }
 
-void RenderText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed, ClippingOption option) const
+void LayoutText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed, ClippingOption option) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         FloatRect boundaries = box->calculateBoundaries().toFloatRect();
 
         // Shorten the width of this text box if it ends in an ellipsis.
         // FIXME: ellipsisRectForBox should switch to return FloatRect soon with the subpixellayout branch.
         IntRect ellipsisRect = (option == ClipToEllipsis) ? ellipsisRectForBox(box, 0, textLength()) : IntRect();
         if (!ellipsisRect.isEmpty()) {
             if (style()->isHorizontalWritingMode())
                 boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
             else
                 boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
         }
         quads.append(localToAbsoluteQuad(boundaries, 0, wasFixed));
     }
 }
 
-void RenderText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
+void LayoutText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
 {
     absoluteQuads(quads, wasFixed, NoClipping);
 }
 
-void RenderText::absoluteQuadsForRange(Vector<FloatQuad>& quads, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed)
+void LayoutText::absoluteQuadsForRange(Vector<FloatQuad>& quads, unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed)
 {
     // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
     // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this
     // function to take ints causes various internal mismatches. But selectionRect takes ints, and
     // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but
     // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
     ASSERT(end == UINT_MAX || end <= INT_MAX);
     ASSERT(start <= INT_MAX);
     start = std::min(start, static_cast<unsigned>(INT_MAX));
     end = std::min(end, static_cast<unsigned>(INT_MAX));
@@ skipping 65 matching lines @@
     case AlwaysDownstream:
         affinity = DOWNSTREAM;
         break;
     case AlwaysUpstream:
         affinity = VP_UPSTREAM_IF_POSSIBLE;
         break;
     case UpstreamIfPositionIsNotAtStart:
         affinity = offset > box->caretMinOffset() ? VP_UPSTREAM_IF_POSSIBLE : DOWNSTREAM;
         break;
     }
-    int textStartOffset = box->renderer().isText() ? toRenderText(box->renderer()).textStartOffset() : 0;
+    int textStartOffset = box->renderer().isText() ? toLayoutText(box->renderer()).textStartOffset() : 0;
     return box->renderer().createPositionWithAffinity(offset + textStartOffset, affinity);
 }
 
 static PositionWithAffinity createPositionWithAffinityForBoxAfterAdjustingOffsetForBiDi(const InlineTextBox* box, int offset, ShouldAffinityBeDownstream shouldAffinityBeDownstream)
 {
     ASSERT(box);
     ASSERT(offset >= 0);
 
     if (offset && static_cast<unsigned>(offset) < box->len())
         return createPositionWithAffinityForBox(box, box->start() + offset, shouldAffinityBeDownstream);
@@ skipping 56 matching lines @@
             leftmostBox = prevBox;
             prevBox = leftmostBox->prevLeafChildIgnoringLineBreak();
         } while (prevBox && prevBox->bidiLevel() >= box->bidiLevel());
         return createPositionWithAffinityForBox(leftmostBox,
             box->isLeftToRightDirection() ? leftmostBox->caretMinOffset() : leftmostBox->caretMaxOffset(), shouldAffinityBeDownstream);
     }
 
     return createPositionWithAffinityForBox(box, box->caretLeftmostOffset(), shouldAffinityBeDownstream);
 }
 
-PositionWithAffinity RenderText::positionForPoint(const LayoutPoint& point)
+PositionWithAffinity LayoutText::positionForPoint(const LayoutPoint& point)
 {
     if (!firstTextBox() || textLength() == 0)
         return createPositionWithAffinity(0, DOWNSTREAM);
 
     LayoutUnit pointLineDirection = firstTextBox()->isHorizontal() ? point.x() : point.y();
     LayoutUnit pointBlockDirection = firstTextBox()->isHorizontal() ? point.y() : point.x();
     bool blocksAreFlipped = style()->isFlippedBlocksWritingMode();
 
     InlineTextBox* lastBox = 0;
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
@@ skipping 17 matching lines @@
     }
 
     if (lastBox) {
         ShouldAffinityBeDownstream shouldAffinityBeDownstream;
         lineDirectionPointFitsInBox(pointLineDirection, lastBox, shouldAffinityBeDownstream);
         return createPositionWithAffinityForBoxAfterAdjustingOffsetForBiDi(lastBox, lastBox->offsetForPosition(pointLineDirection.toFloat()) + lastBox->start(), shouldAffinityBeDownstream);
     }
     return createPositionWithAffinity(0, DOWNSTREAM);
 }
 
-LayoutRect RenderText::localCaretRect(InlineBox* inlineBox, int caretOffset, LayoutUnit* extraWidthToEndOfLine)
+LayoutRect LayoutText::localCaretRect(InlineBox* inlineBox, int caretOffset, LayoutUnit* extraWidthToEndOfLine)
 {
     if (!inlineBox)
         return LayoutRect();
 
     ASSERT(inlineBox->isInlineTextBox());
     if (!inlineBox->isInlineTextBox())
         return LayoutRect();
 
     InlineTextBox* box = toInlineTextBox(inlineBox);
 
@@ skipping 56 matching lines @@
         left = std::max(left, leftEdge);
         left = std::min(left, rootRight - caretWidth);
     } else {
         left = std::min(left, rightEdge - caretWidthRightOfOffset);
         left = std::max(left, rootLeft);
     }
 
     return LayoutRect(style()->isHorizontalWritingMode() ? IntRect(left, top, caretWidth, height) : IntRect(top, left, height, caretWidth));
 }
 
-ALWAYS_INLINE float RenderText::widthFromCache(const Font& f, int start, int len, float xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+ALWAYS_INLINE float LayoutText::widthFromCache(const Font& f, int start, int len, float xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
     if (style()->hasTextCombine() && isCombineText()) {
-        const RenderCombineText* combineText = toRenderCombineText(this);
+        const LayoutTextCombine* combineText = toLayoutTextCombine(this);
         if (combineText->isCombined())
             return combineText->combinedTextWidth(f);
     }
 
     if (f.isFixedPitch() && f.fontDescription().variant() == FontVariantNormal && m_isAllASCII && (!glyphOverflow || !glyphOverflow->computeBounds)) {
         bool missingGlyph = false;
         float monospaceCharacterWidth = f.spaceWidth();
         float w = 0;
         bool isSpace;
         ASSERT(m_text);
@@ skipping 12 matching lines @@
                     w += monospaceCharacterWidth;
                     isSpace = true;
                 } else if (c == characterTabulation) {
                     if (layoutStyle.collapseWhiteSpace()) {
                         w += monospaceCharacterWidth;
                         isSpace = true;
                     } else {
                         w += f.tabWidth(layoutStyle.tabSize(), xPos + w);
                         isSpace = false;
                     }
-                } else
+                } else {
                     isSpace = false;
+                }
             } else {
                 w += monospaceCharacterWidth;
                 isSpace = false;
             }
             if (isSpace && i > start)
                 w += f.fontDescription().wordSpacing();
         }
         if (!missingGlyph)
             return w;
     }
 
-    TextRun run = constructTextRun(const_cast<RenderText*>(this), f, this, start, len, styleRef(), textDirection);
+    TextRun run = constructTextRun(const_cast<LayoutText*>(this), f, this, start, len, styleRef(), textDirection);
     run.setCharactersLength(textLength() - start);
     ASSERT(run.charactersLength() >= run.length());
     run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
     run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
     run.setXPos(xPos);
     return f.width(run, fallbackFonts, glyphOverflow);
 }
 
-void RenderText::trimmedPrefWidths(FloatWillBeLayoutUnit leadWidth,
+void LayoutText::trimmedPrefWidths(FloatWillBeLayoutUnit leadWidth,
     FloatWillBeLayoutUnit& firstLineMinWidth, bool& hasBreakableStart,
     FloatWillBeLayoutUnit& lastLineMinWidth, bool& hasBreakableEnd,
     bool& hasBreakableChar, bool& hasBreak,
     FloatWillBeLayoutUnit& firstLineMaxWidth, FloatWillBeLayoutUnit& lastLineMaxWidth,
     FloatWillBeLayoutUnit& minWidth, FloatWillBeLayoutUnit& maxWidth, bool& stripFrontSpaces,
     TextDirection direction)
 {
     bool collapseWhiteSpace = style()->collapseWhiteSpace();
     if (!collapseWhiteSpace)
         stripFrontSpaces = false;
@@ skipping 73 matching lines @@
 
             if (i == len - 1) {
                 // A <pre> run that ends with a newline, as in, e.g.,
                 // <pre>Some text\n\n<span>More text</pre>
                 lastLineMaxWidth = FloatWillBeLayoutUnit();
             }
         }
     }
 }
 
-float RenderText::minLogicalWidth() const
+float LayoutText::minLogicalWidth() const
 {
     if (preferredLogicalWidthsDirty())
-        const_cast<RenderText*>(this)->computePreferredLogicalWidths(0);
+        const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0);
 
     return m_minWidth;
 }
 
-float RenderText::maxLogicalWidth() const
+float LayoutText::maxLogicalWidth() const
 {
     if (preferredLogicalWidthsDirty())
-        const_cast<RenderText*>(this)->computePreferredLogicalWidths(0);
+        const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0);
 
     return m_maxWidth;
 }
 
-void RenderText::computePreferredLogicalWidths(float leadWidth)
+void LayoutText::computePreferredLogicalWidths(float leadWidth)
 {
     HashSet<const SimpleFontData*> fallbackFonts;
     GlyphOverflow glyphOverflow;
     computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphOverflow);
 
     // We shouldn't change our mind once we "know".
     ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts || (fallbackFonts.isEmpty() && glyphOverflow.isZero()));
     m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts.isEmpty() && glyphOverflow.isZero();
 }
 
-static inline float hyphenWidth(RenderText* renderer, const Font& font, TextDirection direction)
+static inline float hyphenWidth(LayoutText* renderer, const Font& font, TextDirection direction)
 {
     const LayoutStyle& style = renderer->styleRef();
     return font.width(constructTextRun(renderer, font, style.hyphenString().string(), style, direction));
 }
 
-void RenderText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
+void LayoutText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
 {
     ASSERT(m_hasTab || preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts);
 
     m_minWidth = 0;
     m_maxWidth = 0;
     m_firstLineMinWidth = 0;
     m_lastLineLineMinWidth = 0;
 
     if (isBR())
         return;
@@ skipping 57 matching lines @@
             textDirection = run->direction();
         }
 
         bool previousCharacterIsSpace = isSpace;
         bool isNewline = false;
         if (c == newlineCharacter) {
             if (styleToUse.preserveNewline()) {
                 m_hasBreak = true;
                 isNewline = true;
                 isSpace = false;
-            } else
+            } else {
                 isSpace = true;
+            }
         } else if (c == characterTabulation) {
             if (!styleToUse.collapseWhiteSpace()) {
                 m_hasTab = true;
                 isSpace = false;
-            } else
+            } else {
                 isSpace = true;
+            }
         } else {
             isSpace = c == space;
         }
 
         bool isBreakableLocation = isNewline || (isSpace && styleToUse.autoWrap());
         if (!i)
             m_hasBreakableStart = isBreakableLocation;
         if (i == len - 1) {
             m_hasBreakableEnd = isBreakableLocation;
             m_hasEndWhiteSpace = isNewline || isSpace;
         }
 
         if (!ignoringSpaces && styleToUse.collapseWhiteSpace() && previousCharacterIsSpace && isSpace)
             ignoringSpaces = true;
 
         if (ignoringSpaces && !isSpace)
             ignoringSpaces = false;
 
         // Ignore spaces and soft hyphens
         if (ignoringSpaces) {
             ASSERT(lastWordBoundary == i);
             lastWordBoundary++;
             continue;
-        } else if (c == softHyphen) {
+        }
+        if (c == softHyphen) {
             currMaxWidth += widthFromCache(f, lastWordBoundary, i - lastWordBoundary, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
             if (firstGlyphLeftOverflow < 0)
                 firstGlyphLeftOverflow = glyphOverflow.left;
             lastWordBoundary = i + 1;
             continue;
         }
 
         bool hasBreak = breakIterator.isBreakable(i, nextBreakable, breakAll ? LineBreakType::BreakAll : LineBreakType::Normal);
         bool betweenWords = true;
         int j = i;
@@ skipping 21 matching lines @@
             // space, then subtract its width.
             float wordTrailingSpaceWidth = 0;
             if (isSpace && (f.fontDescription().typesettingFeatures() & Kerning)) {
                 ASSERT(textDirection >=0 && textDirection <= 1);
                 if (!cachedWordTrailingSpaceWidth[textDirection])
                     cachedWordTrailingSpaceWidth[textDirection] = f.width(constructTextRun(this, f, &space, 1, styleToUse, textDirection)) + wordSpacing;
                 wordTrailingSpaceWidth = cachedWordTrailingSpaceWidth[textDirection];
             }
 
             float w;
-            if (wordTrailingSpaceWidth && isSpace)
+            if (wordTrailingSpaceWidth && isSpace) {
                 w = widthFromCache(f, i, wordLen + 1, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow) - wordTrailingSpaceWidth;
-            else {
+            } else {
                 w = widthFromCache(f, i, wordLen, leadWidth + currMaxWidth, textDirection, &fallbackFonts, &glyphOverflow);
                 if (c == softHyphen)
                     currMinWidth += hyphenWidth(this, f, textDirection);
             }
 
             if (firstGlyphLeftOverflow < 0)
                 firstGlyphLeftOverflow = glyphOverflow.left;
             currMinWidth += w;
             if (betweenWords) {
                 if (lastWordBoundary == i)
@@ skipping 82 matching lines @@
 
     if (styleToUse.whiteSpace() == PRE) {
         if (firstLine)
             m_firstLineMinWidth = m_maxWidth;
         m_lastLineLineMinWidth = currMaxWidth;
     }
 
     clearPreferredLogicalWidthsDirty();
 }
 
-bool RenderText::isAllCollapsibleWhitespace() const
+bool LayoutText::isAllCollapsibleWhitespace() const
 {
     unsigned length = textLength();
     if (is8Bit()) {
         for (unsigned i = 0; i < length; ++i) {
             if (!style()->isCollapsibleWhiteSpace(characters8()[i]))
                 return false;
         }
         return true;
     }
     for (unsigned i = 0; i < length; ++i) {
         if (!style()->isCollapsibleWhiteSpace(characters16()[i]))
             return false;
     }
     return true;
 }
 
-bool RenderText::containsOnlyWhitespace(unsigned from, unsigned len) const
+bool LayoutText::containsOnlyWhitespace(unsigned from, unsigned len) const
 {
     ASSERT(m_text);
     StringImpl& text = *m_text.impl();
     unsigned currPos;
     for (currPos = from;
     currPos < from + len && (text[currPos] == newlineCharacter || text[currPos] == space || text[currPos] == characterTabulation);
     currPos++) { }
     return currPos >= (from + len);
 }
 
-FloatPoint RenderText::firstRunOrigin() const
+FloatPoint LayoutText::firstRunOrigin() const
 {
     return IntPoint(firstRunX(), firstRunY());
 }
 
-float RenderText::firstRunX() const
+float LayoutText::firstRunX() const
 {
     return m_firstTextBox ? m_firstTextBox->x().toFloat() : 0;
 }
 
-float RenderText::firstRunY() const
+float LayoutText::firstRunY() const
 {
     return m_firstTextBox ? m_firstTextBox->y().toFloat() : 0;
 }
 
-void RenderText::setSelectionState(SelectionState state)
+void LayoutText::setSelectionState(SelectionState state)
 {
     LayoutObject::setSelectionState(state);
 
     if (canUpdateSelectionOnRootLineBoxes()) {
         if (state == SelectionStart || state == SelectionEnd || state == SelectionBoth) {
             int startPos, endPos;
             selectionStartEnd(startPos, endPos);
             if (selectionState() == SelectionStart) {
                 endPos = textLength();
 
                 // to handle selection from end of text to end of line
                 if (startPos && startPos == endPos)
                     startPos = endPos - 1;
-            } else if (selectionState() == SelectionEnd)
+            } else if (selectionState() == SelectionEnd) {
                 startPos = 0;
+            }
 
             for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
                 if (box->isSelected(startPos, endPos)) {
                     box->root().setHasSelectedChildren(true);
                 }
             }
         } else {
             for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
                 box->root().setHasSelectedChildren(state == SelectionInside);
             }
         }
     }
 
     // The containing block can be null in case of an orphaned tree.
     LayoutBlock* containingBlock = this->containingBlock();
     if (containingBlock && !containingBlock->isLayoutView())
         containingBlock->setSelectionState(state);
 }
 
-void RenderText::setTextWithOffset(PassRefPtr<StringImpl> text, unsigned offset, unsigned len, bool force)
+void LayoutText::setTextWithOffset(PassRefPtr<StringImpl> text, unsigned offset, unsigned len, bool force)
 {
     if (!force && equal(m_text.impl(), text.get()))
         return;
 
     unsigned oldLen = textLength();
     unsigned newLen = text->length();
     int delta = newLen - oldLen;
     unsigned end = len ? offset + len - 1 : offset;
 
     RootInlineBox* firstRootBox = 0;
@@ skipping 57 matching lines @@
     // If the text node is empty, dirty the line where new text will be inserted.
     if (!firstTextBox() && parent()) {
         parent()->dirtyLinesFromChangedChild(this);
         dirtiedLines = true;
     }
 
     m_linesDirty = dirtiedLines;
     setText(text, force || dirtiedLines);
 }
 
-void RenderText::transformText()
+void LayoutText::transformText()
 {
     if (RefPtr<StringImpl> textToTransform = originalText())
         setText(textToTransform.release(), true);
 }
 
 static inline bool isInlineFlowOrEmptyText(const LayoutObject* o)
 {
     if (o->isLayoutInline())
         return true;
     if (!o->isText())
         return false;
-    return toRenderText(o)->text().isEmpty();
+    return toLayoutText(o)->text().isEmpty();
 }
 
-UChar RenderText::previousCharacter() const
+UChar LayoutText::previousCharacter() const
 {
     // find previous text renderer if one exists
     const LayoutObject* previousText = previousInPreOrder();
-    for (; previousText; previousText = previousText->previousInPreOrder())
+    for (; previousText; previousText = previousText->previousInPreOrder()) {
         if (!isInlineFlowOrEmptyText(previousText))
             break;
+    }
     UChar prev = space;
-    if (previousText && previousText->isText())
-        if (StringImpl* previousString = toRenderText(previousText)->text().impl())
+    if (previousText && previousText->isText()) {
+        if (StringImpl* previousString = toLayoutText(previousText)->text().impl())
             prev = (*previousString)[previousString->length() - 1];
+    }
     return prev;
 }
 
-void RenderText::addLayerHitTestRects(LayerHitTestRects&, const Layer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
+void LayoutText::addLayerHitTestRects(LayerHitTestRects&, const Layer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
 {
     // Text nodes aren't event targets, so don't descend any further.
 }
 
 void applyTextTransform(const LayoutStyle* style, String& text, UChar previousCharacter)
 {
     if (!style)
         return;
 
     switch (style->textTransform()) {
     case TTNONE:
         break;
     case CAPITALIZE:
         makeCapitalized(&text, previousCharacter);
         break;
     case UPPERCASE:
         text = text.upper(style->locale());
         break;
     case LOWERCASE:
         text = text.lower(style->locale());
         break;
     }
 }
 
-void RenderText::setTextInternal(PassRefPtr<StringImpl> text)
+void LayoutText::setTextInternal(PassRefPtr<StringImpl> text)
 {
     ASSERT(text);
     m_text = text;
 
     if (style()) {
         applyTextTransform(style(), m_text, previousCharacter());
 
         // We use the same characters here as for list markers.
         // See the listMarkerText function in LayoutListMarker.cpp.
         switch (style()->textSecurity()) {
@@ skipping 10 matching lines @@
         }
     }
 
     ASSERT(m_text);
     ASSERT(!isBR() || (textLength() == 1 && m_text[0] == newlineCharacter));
 
     m_isAllASCII = m_text.containsOnlyASCII();
     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
 }
 
-void RenderText::secureText(UChar mask)
+void LayoutText::secureText(UChar mask)
 {
     if (!m_text.length())
         return;
 
     int lastTypedCharacterOffsetToReveal = -1;
     UChar revealedText;
     SecureTextTimer* secureTextTimer = gSecureTextTimers ? gSecureTextTimers->get(this) : 0;
     if (secureTextTimer && secureTextTimer->isActive()) {
         lastTypedCharacterOffsetToReveal = secureTextTimer->lastTypedCharacterOffset();
         if (lastTypedCharacterOffsetToReveal >= 0)
             revealedText = m_text[lastTypedCharacterOffsetToReveal];
     }
 
     m_text.fill(mask);
     if (lastTypedCharacterOffsetToReveal >= 0) {
         m_text.replace(lastTypedCharacterOffsetToReveal, 1, String(&revealedText, 1));
         // m_text may be updated later before timer fires. We invalidate the lastTypedCharacterOffset to avoid inconsistency.
         secureTextTimer->invalidate();
     }
 }
 
-void RenderText::setText(PassRefPtr<StringImpl> text, bool force)
+void LayoutText::setText(PassRefPtr<StringImpl> text, bool force)
 {
     ASSERT(text);
 
     if (!force && equal(m_text.impl(), text.get()))
         return;
 
     setTextInternal(text);
     // If preferredLogicalWidthsDirty() of an orphan child is true, LayoutObjectChildList::
     // insertChildNode() fails to set true to owner. To avoid that, we call
-    // setNeedsLayoutAndPrefWidthsRecalc() only if this RenderText has parent.
+    // setNeedsLayoutAndPrefWidthsRecalc() only if this LayoutText has parent.
     if (parent())
         setNeedsLayoutAndPrefWidthsRecalc();
     m_knownToHaveNoOverflowAndNoFallbackFonts = false;
 
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->textChanged(this);
 }
 
-void RenderText::dirtyOrDeleteLineBoxesIfNeeded(bool fullLayout)
+void LayoutText::dirtyOrDeleteLineBoxesIfNeeded(bool fullLayout)
 {
     if (fullLayout)
         deleteTextBoxes();
     else if (!m_linesDirty)
         dirtyLineBoxes();
     m_linesDirty = false;
 }
 
-void RenderText::dirtyLineBoxes()
+void LayoutText::dirtyLineBoxes()
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         box->dirtyLineBoxes();
     m_linesDirty = false;
 }
 
-InlineTextBox* RenderText::createTextBox(int start, unsigned short length)
+InlineTextBox* LayoutText::createTextBox(int start, unsigned short length)
 {
     return new InlineTextBox(*this, start, length);
 }
 
-InlineTextBox* RenderText::createInlineTextBox(int start, unsigned short length)
+InlineTextBox* LayoutText::createInlineTextBox(int start, unsigned short length)
 {
     InlineTextBox* textBox = createTextBox(start, length);
-    if (!m_firstTextBox)
+    if (!m_firstTextBox) {
         m_firstTextBox = m_lastTextBox = textBox;
-    else {
+    } else {
         m_lastTextBox->setNextTextBox(textBox);
         textBox->setPreviousTextBox(m_lastTextBox);
         m_lastTextBox = textBox;
     }
     return textBox;
 }
 
-void RenderText::positionLineBox(InlineBox* box)
+void LayoutText::positionLineBox(InlineBox* box)
 {
     InlineTextBox* s = toInlineTextBox(box);
 
     // FIXME: should not be needed!!!
     if (!s->len()) {
         // We want the box to be destroyed.
         s->remove(DontMarkLineBoxes);
         if (m_firstTextBox == s)
             m_firstTextBox = s->nextTextBox();
         else
             s->prevTextBox()->setNextTextBox(s->nextTextBox());
         if (m_lastTextBox == s)
             m_lastTextBox = s->prevTextBox();
         else
             s->nextTextBox()->setPreviousTextBox(s->prevTextBox());
         s->destroy();
         return;
     }
 
     m_containsReversedText |= !s->isLeftToRightDirection();
 }
 
-float RenderText::width(unsigned from, unsigned len, float xPos, TextDirection textDirection, bool firstLine, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float LayoutText::width(unsigned from, unsigned len, float xPos, TextDirection textDirection, bool firstLine, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
     if (from >= textLength())
         return 0;
 
     if (from + len > textLength())
         len = textLength() - from;
 
     return width(from, len, style(firstLine)->font(), xPos, textDirection, fallbackFonts, glyphOverflow);
 }
 
-float RenderText::width(unsigned from, unsigned len, const Font& f, float xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float LayoutText::width(unsigned from, unsigned len, const Font& f, float xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
     ASSERT(from + len <= textLength());
     if (!textLength())
         return 0;
 
     float w;
     if (&f == &style()->font()) {
         if (!style()->preserveNewline() && !from && len == textLength() && (!glyphOverflow || !glyphOverflow->computeBounds)) {
             if (fallbackFonts) {
                 ASSERT(glyphOverflow);
                 if (preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts) {
-                    const_cast<RenderText*>(this)->computePreferredLogicalWidths(0, *fallbackFonts, *glyphOverflow);
+                    const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0, *fallbackFonts, *glyphOverflow);
                     // We shouldn't change our mind once we "know".
                     ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts
                         || (fallbackFonts->isEmpty() && glyphOverflow->isZero()));
                     m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts->isEmpty() && glyphOverflow->isZero();
                 }
                 w = m_maxWidth;
             } else {
                 w = maxLogicalWidth();
             }
         } else {
             w = widthFromCache(f, from, len, xPos, textDirection, fallbackFonts, glyphOverflow);
         }
     } else {
-        TextRun run = constructTextRun(const_cast<RenderText*>(this), f, this, from, len, styleRef(), textDirection);
+        TextRun run = constructTextRun(const_cast<LayoutText*>(this), f, this, from, len, styleRef(), textDirection);
         run.setCharactersLength(textLength() - from);
         ASSERT(run.charactersLength() >= run.length());
 
         run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
         run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
         run.setXPos(xPos);
         w = f.width(run, fallbackFonts, glyphOverflow);
     }
 
     return w;
 }
 
-IntRect RenderText::linesBoundingBox() const
+IntRect LayoutText::linesBoundingBox() const
 {
     IntRect result;
 
-    ASSERT(!firstTextBox() == !lastTextBox());  // Either both are null or both exist.
+    ASSERT(!firstTextBox() == !lastTextBox()); // Either both are null or both exist.
     if (firstTextBox() && lastTextBox()) {
         // Return the width of the minimal left side and the maximal right side.
         float logicalLeftSide = 0;
         float logicalRightSide = 0;
         for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
             if (curr == firstTextBox() || curr->logicalLeft() < logicalLeftSide)
                 logicalLeftSide = curr->logicalLeft();
             if (curr == firstTextBox() || curr->logicalRight() > logicalRightSide)
                 logicalRightSide = curr->logicalRight();
         }
 
         bool isHorizontal = style()->isHorizontalWritingMode();
 
         float x = isHorizontal ? logicalLeftSide : firstTextBox()->x().toFloat();
         float y = isHorizontal ? firstTextBox()->y().toFloat() : logicalLeftSide;
         float width = isHorizontal ? logicalRightSide - logicalLeftSide : lastTextBox()->logicalBottom() - x;
         float height = isHorizontal ? lastTextBox()->logicalBottom() - y : logicalRightSide - logicalLeftSide;
         result = enclosingIntRect(FloatRect(x, y, width, height));
     }
 
     return result;
 }
 
-LayoutRect RenderText::linesVisualOverflowBoundingBox() const
+LayoutRect LayoutText::linesVisualOverflowBoundingBox() const
 {
     if (!firstTextBox())
         return LayoutRect();
 
     // Return the width of the minimal left side and the maximal right side.
     LayoutUnit logicalLeftSide = LayoutUnit::max();
     LayoutUnit logicalRightSide = LayoutUnit::min();
     for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
         LayoutRect logicalVisualOverflow = curr->logicalOverflowRect();
         logicalLeftSide = std::min(logicalLeftSide, logicalVisualOverflow.x());
         logicalRightSide = std::max(logicalRightSide, logicalVisualOverflow.maxX());
     }
 
     LayoutUnit logicalTop = firstTextBox()->logicalTopVisualOverflow();
     LayoutUnit logicalWidth = logicalRightSide - logicalLeftSide;
     LayoutUnit logicalHeight = lastTextBox()->logicalBottomVisualOverflow() - logicalTop;
 
     LayoutRect rect(logicalLeftSide, logicalTop, logicalWidth, logicalHeight);
     if (!style()->isHorizontalWritingMode())
         rect = rect.transposedRect();
     return rect;
 }
 
-LayoutRect RenderText::clippedOverflowRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
+LayoutRect LayoutText::clippedOverflowRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     if (style()->visibility() != VISIBLE)
         return LayoutRect();
 
     LayoutRect paintInvalidationRect(linesVisualOverflowBoundingBox());
     mapRectToPaintInvalidationBacking(paintInvalidationContainer, paintInvalidationRect, paintInvalidationState);
     return paintInvalidationRect;
 }
 
-LayoutRect RenderText::selectionRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer) const
+LayoutRect LayoutText::selectionRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer) const
 {
     ASSERT(!needsLayout());
 
     if (selectionState() == SelectionNone)
         return LayoutRect();
     LayoutBlock* cb = containingBlock();
     if (!cb)
         return LayoutRect();
 
     // Now calculate startPos and endPos for painting selection.
@@ skipping 21 matching lines @@
         rect.unite(LayoutRect(ellipsisRectForBox(box, startPos, endPos)));
     }
 
     mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, 0);
     // FIXME: groupedMapping() leaks the squashing abstraction.
     if (paintInvalidationContainer->layer()->groupedMapping())
         Layer::mapRectToPaintBackingCoordinates(paintInvalidationContainer, rect);
     return rect;
 }
 
-int RenderText::caretMinOffset() const
+int LayoutText::caretMinOffset() const
 {
     InlineTextBox* box = firstTextBox();
     if (!box)
         return 0;
     int minOffset = box->start();
     for (box = box->nextTextBox(); box; box = box->nextTextBox())
         minOffset = std::min<int>(minOffset, box->start());
     return minOffset;
 }
 
-int RenderText::caretMaxOffset() const
+int LayoutText::caretMaxOffset() const
 {
     InlineTextBox* box = lastTextBox();
     if (!lastTextBox())
         return textLength();
 
     int maxOffset = box->start() + box->len();
     for (box = box->prevTextBox(); box; box = box->prevTextBox())
         maxOffset = std::max<int>(maxOffset, box->start() + box->len());
     return maxOffset;
 }
 
-unsigned RenderText::renderedTextLength() const
+unsigned LayoutText::renderedTextLength() const
 {
-    int l = 0;
+    int len = 0;
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
-        l += box->len();
-    return l;
+        len += box->len();
+    return len;
 }
 
-int RenderText::previousOffset(int current) const
+int LayoutText::previousOffset(int current) const
 {
     if (isAllASCII() || m_text.is8Bit())
         return current - 1;
 
     StringImpl* textImpl = m_text.impl();
     TextBreakIterator* iterator = cursorMovementIterator(textImpl->characters16(), textImpl->length());
     if (!iterator)
         return current - 1;
 
     long result = iterator->preceding(current);
@@ skipping 37 matching lines @@
 }
 
 inline bool isRegionalIndicator(UChar32 c)
 {
     // National flag emoji each consists of a pair of regional indicator symbols.
     return 0x1F1E6 <= c && c <= 0x1F1FF;
 }
 
 #endif
 
-int RenderText::previousOffsetForBackwardDeletion(int current) const
+int LayoutText::previousOffsetForBackwardDeletion(int current) const
 {
 #if OS(POSIX)
     ASSERT(m_text);
     StringImpl& text = *m_text.impl();
     UChar32 character;
     bool sawRegionalIndicator = false;
     while (current > 0) {
         if (U16_IS_TRAIL(text[--current]))
             --current;
         if (current < 0)
@@ skipping 74 matching lines @@
 #else
     // Platforms other than Unix-like delete by one code point.
     if (U16_IS_TRAIL(m_text[--current]))
         --current;
     if (current < 0)
         current = 0;
     return current;
 #endif
 }
 
-int RenderText::nextOffset(int current) const
+int LayoutText::nextOffset(int current) const
 {
     if (isAllASCII() || m_text.is8Bit())
         return current + 1;
 
     StringImpl* textImpl = m_text.impl();
     TextBreakIterator* iterator = cursorMovementIterator(textImpl->characters16(), textImpl->length());
     if (!iterator)
         return current + 1;
 
     long result = iterator->following(current);
     if (result == TextBreakDone)
         result = current + 1;
 
     return result;
 }
 
-bool RenderText::computeCanUseSimpleFontCodePath() const
+bool LayoutText::computeCanUseSimpleFontCodePath() const
 {
     if (isAllASCII() || m_text.is8Bit())
         return true;
     return Character::characterRangeCodePath(characters16(), length()) == SimplePath;
 }
 
 #if ENABLE(ASSERT)
 
-void RenderText::checkConsistency() const
+void LayoutText::checkConsistency() const
 {
 #ifdef CHECK_CONSISTENCY
     const InlineTextBox* prev = 0;
     for (const InlineTextBox* child = m_firstTextBox; child != 0; child = child->nextTextBox()) {
         ASSERT(child->renderer() == this);
         ASSERT(child->prevTextBox() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastTextBox);
 #endif
 }
 
 #endif
 
-void RenderText::momentarilyRevealLastTypedCharacter(unsigned lastTypedCharacterOffset)
+void LayoutText::momentarilyRevealLastTypedCharacter(unsigned lastTypedCharacterOffset)
 {
     if (!gSecureTextTimers)
         gSecureTextTimers = new SecureTextTimerMap;
 
     SecureTextTimer* secureTextTimer = gSecureTextTimers->get(this);
     if (!secureTextTimer) {
         secureTextTimer = new SecureTextTimer(this);
         gSecureTextTimers->add(this, secureTextTimer);
     }
     secureTextTimer->restartWithNewText(lastTypedCharacterOffset);
 }
 
-PassRefPtr<AbstractInlineTextBox> RenderText::firstAbstractInlineTextBox()
+PassRefPtr<AbstractInlineTextBox> LayoutText::firstAbstractInlineTextBox()
 {
     return AbstractInlineTextBox::getOrCreate(this, m_firstTextBox);
 }
 
-void RenderText::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
+void LayoutText::invalidateDisplayItemClients(DisplayItemList* displayItemList) const
 {
     LayoutObject::invalidateDisplayItemClients(displayItemList);
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         displayItemList->invalidate(box->displayItemClient());
 }
 
 } // namespace blink