Rename RenderText to LayoutText

Source/core/layout/line/InlineIterator.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 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.
  *
  */
 
 #ifndef InlineIterator_h
 #define InlineIterator_h
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutInline.h"
-#include "core/rendering/RenderText.h"
+#include "core/layout/LayoutText.h"
+
 #include "wtf/StdLibExtras.h"
 
 namespace blink {
 
 // This class is used to LayoutInline subtrees, stepping by character within the
-// text children. InlineIterator will use bidiNext to find the next RenderText
+// text children. InlineIterator will use bidiNext to find the next LayoutText
 // optionally notifying a BidiResolver every time it steps into/out of a LayoutInline.
 class InlineIterator {
 public:
     enum IncrementRule {
         FastIncrementInIsolatedRenderer,
         FastIncrementInTextNode
     };
 
     InlineIterator()
         : m_root(0)
@@ skipping 34 matching lines @@
     unsigned offset() const { return m_pos; }
     void setOffset(unsigned position) { m_pos = position; }
     LayoutObject* root() const { return m_root; }
 
     void fastIncrementInTextNode();
     void increment(InlineBidiResolver* = 0, IncrementRule = FastIncrementInTextNode);
     bool atEnd() const;
 
     inline bool atTextParagraphSeparator() const
     {
-        return m_obj && m_obj->preservesNewline() && m_obj->isText() && toRenderText(m_obj)->textLength()
-            && !toRenderText(m_obj)->isWordBreak() && toRenderText(m_obj)->characterAt(m_pos) == '\n';
+        return m_obj && m_obj->preservesNewline() && m_obj->isText() && toLayoutText(m_obj)->textLength()
+            && !toLayoutText(m_obj)->isWordBreak() && toLayoutText(m_obj)->characterAt(m_pos) == '\n';
     }
 
     inline bool atParagraphSeparator() const
     {
         return (m_obj && m_obj->isBR()) || atTextParagraphSeparator();
     }
 
     UChar characterAt(unsigned) const;
     UChar current() const;
     UChar previousInSameNode() const;
@@ skipping 84 matching lines @@
 };
 
 static bool isEmptyInline(LayoutObject* object)
 {
     if (!object->isLayoutInline())
         return false;
 
     for (LayoutObject* curr = toLayoutInline(object)->firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
-        if (curr->isText() && toRenderText(curr)->isAllCollapsibleWhitespace())
+        if (curr->isText() && toLayoutText(curr)->isAllCollapsibleWhitespace())
             continue;
 
         if (!isEmptyInline(curr))
             return false;
     }
     return true;
 }
 
 // FIXME: This function is misleadingly named. It has little to do with bidi.
 // This function will iterate over inlines within a block, optionally notifying
@@ skipping 112 matching lines @@
     if (!o || o->isLayoutInline() || isIteratorTarget(o))
         return o;
 
     return bidiNextIncludingEmptyInlines(root, o);
 }
 
 inline void InlineIterator::fastIncrementInTextNode()
 {
     ASSERT(m_obj);
     ASSERT(m_obj->isText());
-    ASSERT(m_pos <= toRenderText(m_obj)->textLength());
+    ASSERT(m_pos <= toLayoutText(m_obj)->textLength());
     if (m_pos < INT_MAX)
         m_pos++;
 }
 
 // FIXME: This is used by LayoutBlockFlow for simplified layout, and has nothing to do with bidi
 // it shouldn't use functions called bidiFirst and bidiNext.
 class InlineWalker {
 public:
     InlineWalker(LayoutBlock* root)
         : m_root(root)
@@ skipping 43 matching lines @@
 
     if (rule == FastIncrementInIsolatedRenderer
         && resolver && resolver->inIsolate()
         && !endOfLineHasIsolatedObjectAncestor(resolver->endOfLine(), resolver->position())) {
         moveTo(bidiNextSkippingEmptyInlines(m_root, m_obj, resolver), 0);
         return;
     }
 
     if (m_obj->isText()) {
         fastIncrementInTextNode();
-        if (m_pos < toRenderText(m_obj)->textLength())
+        if (m_pos < toLayoutText(m_obj)->textLength())
             return;
     }
     // bidiNext can return 0, so use moveTo instead of moveToStartOf
     moveTo(bidiNextSkippingEmptyInlines(m_root, m_obj, resolver), 0);
 }
 
 inline bool InlineIterator::atEnd() const
 {
     return !m_obj;
 }
 
 inline UChar InlineIterator::characterAt(unsigned index) const
 {
     if (!m_obj || !m_obj->isText())
         return 0;
 
-    return toRenderText(m_obj)->characterAt(index);
+    return toLayoutText(m_obj)->characterAt(index);
 }
 
 inline UChar InlineIterator::current() const
 {
     return characterAt(m_pos);
 }
 
 inline UChar InlineIterator::previousInSameNode() const
 {
     if (!m_pos)
@@ skipping 24 matching lines @@
 {
     bool inEndOfLine = m_current == end || m_current.atEnd() || (inIsolate() && m_current.object() == end.object());
     if (inIsolate() && inEndOfLine) {
         m_current.moveTo(m_current.object(), end.offset(), m_current.nextBreakablePosition());
         m_last = m_current;
         updateStatusLastFromCurrentDirection(WTF::Unicode::OtherNeutral);
     }
     return inEndOfLine;
 }
 
-static inline bool isCollapsibleSpace(UChar character, RenderText* renderer)
+static inline bool isCollapsibleSpace(UChar character, LayoutText* renderer)
 {
     if (character == ' ' || character == '\t' || character == softHyphen)
         return true;
     if (character == '\n')
         return !renderer->style()->preserveNewline();
     return false;
 }
 
 template <typename CharacterType>
-static inline int findFirstTrailingSpace(RenderText* lastText, const CharacterType* characters, int start, int stop)
+static inline int findFirstTrailingSpace(LayoutText* lastText, const CharacterType* characters, int start, int stop)
 {
     int firstSpace = stop;
     while (firstSpace > start) {
         UChar current = characters[firstSpace - 1];
         if (!isCollapsibleSpace(current, lastText))
             break;
         firstSpace--;
     }
 
     return firstSpace;
 }
 
 template <>
 inline int InlineBidiResolver::findFirstTrailingSpaceAtRun(BidiRun* run)
 {
     ASSERT(run);
     LayoutObject* lastObject = run->m_object;
     if (!lastObject->isText())
         return run->m_stop;
 
-    RenderText* lastText = toRenderText(lastObject);
+    LayoutText* lastText = toLayoutText(lastObject);
     int firstSpace;
     if (lastText->is8Bit())
         firstSpace = findFirstTrailingSpace(lastText, lastText->characters8(), run->start(), run->stop());
     else
         firstSpace = findFirstTrailingSpace(lastText, lastText->characters16(), run->start(), run->stop());
     return firstSpace;
 }
 
 template <>
 inline BidiRun* InlineBidiResolver::addTrailingRun(BidiRunList<BidiRun>& runs, int start, int stop, BidiRun* run, BidiContext* context, TextDirection direction) const
@@ skipping 239 matching lines @@
         m_sor = m_eor;
     }
 
     m_direction = WTF::Unicode::OtherNeutral;
     m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
 }
 
 #endif // InlineIterator_h