Rename RenderText to LayoutText

Source/core/dom/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 21 matching lines @@
 #include "core/dom/Text.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLTableElement.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
+#include "core/layout/LayoutText.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/line/InlineTextBox.h"
-#include "core/rendering/RenderText.h"
 #include "platform/Logging.h"
 #include "wtf/text/CString.h"
 #include "wtf/unicode/CharacterNames.h"
 #include <stdio.h>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static Node* nextRenderedEditable(Node* node)
 {
     for (node = node->nextLeafNode(); node; node = node->nextLeafNode()) {
         LayoutObject* renderer = node->renderer();
         if (!renderer)
             continue;
         if (!node->hasEditableStyle())
             continue;
-        if ((renderer->isBox() && toLayoutBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toRenderText(renderer)->firstTextBox()))
+        if ((renderer->isBox() && toLayoutBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toLayoutText(renderer)->firstTextBox()))
             return node;
     }
     return 0;
 }
 
 static Node* previousRenderedEditable(Node* node)
 {
     for (node = node->previousLeafNode(); node; node = node->previousLeafNode()) {
         LayoutObject* renderer = node->renderer();
         if (!renderer)
             continue;
         if (!node->hasEditableStyle())
             continue;
-        if ((renderer->isBox() && toLayoutBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toRenderText(renderer)->firstTextBox()))
+        if ((renderer->isBox() && toLayoutBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toLayoutText(renderer)->firstTextBox()))
             return node;
     }
     return 0;
 }
 
 const TreeScope* Position::commonAncestorTreeScope(const Position& a, const Position& b)
 {
     if (!a.containerNode() || !b.containerNode())
         return nullptr;
     return a.containerNode()->treeScope().commonAncestorTreeScope(b.containerNode()->treeScope());
@@ skipping 373 matching lines @@
 
 int Position::renderedOffset() const
 {
     if (!deprecatedNode()->isTextNode())
         return m_offset;
 
     if (!deprecatedNode()->renderer())
         return m_offset;
 
     int result = 0;
-    RenderText* textRenderer = toRenderText(deprecatedNode()->renderer());
+    LayoutText* textRenderer = toLayoutText(deprecatedNode()->renderer());
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         int start = box->start();
         int end = box->start() + box->len();
         if (m_offset < start)
             return result;
         if (m_offset <= end) {
             result += m_offset - start;
             return result;
         }
         result += box->len();
@@ skipping 108 matching lines @@
             return lastVisible;
 
         // Return position after tables and nodes which have content that can be ignored.
         if (editingIgnoresContent(currentNode) || isRenderedHTMLTableElement(currentNode)) {
             if (currentPos.atEndOfNode())
                 return positionAfterNode(currentNode);
             continue;
         }
 
         // return current position if it is in rendered text
-        if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
+        if (renderer->isText() && toLayoutText(renderer)->firstTextBox()) {
             if (currentNode != startNode) {
                 // This assertion fires in layout tests in the case-transform.html test because
                 // of a mix-up between offsets in the text in the DOM tree with text in the
                 // render tree which can have a different length due to case transformation.
                 // Until we resolve that, disable this so we can run the layout tests!
                 //ASSERT(currentOffset >= renderer->caretMaxOffset());
                 return createLegacyEditingPosition(currentNode, renderer->caretMaxOffset());
             }
 
             unsigned textOffset = currentPos.offsetInLeafNode();
-            RenderText* textRenderer = toRenderText(renderer);
+            LayoutText* textRenderer = toLayoutText(renderer);
             InlineTextBox* lastTextBox = textRenderer->lastTextBox();
             for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
                 if (textOffset <= box->start() + box->len()) {
                     if (textOffset > box->start())
                         return currentPos;
                     continue;
                 }
 
                 if (box == lastTextBox || textOffset != box->start() + box->len() + 1)
                     continue;
@@ skipping 96 matching lines @@
             lastVisible = currentPos;
 
         // Return position before tables and nodes which have content that can be ignored.
         if (editingIgnoresContent(currentNode) || isRenderedHTMLTableElement(currentNode)) {
             if (currentPos.offsetInLeafNode() <= renderer->caretMinOffset())
                 return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
             continue;
         }
 
         // return current position if it is in rendered text
-        if (renderer->isText() && toRenderText(renderer)->firstTextBox()) {
+        if (renderer->isText() && toLayoutText(renderer)->firstTextBox()) {
             if (currentNode != startNode) {
                 ASSERT(currentPos.atStartOfNode());
                 return createLegacyEditingPosition(currentNode, renderer->caretMinOffset());
             }
 
             unsigned textOffset = currentPos.offsetInLeafNode();
-            RenderText* textRenderer = toRenderText(renderer);
+            LayoutText* textRenderer = toLayoutText(renderer);
             InlineTextBox* lastTextBox = textRenderer->lastTextBox();
             for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
                 if (textOffset <= box->end()) {
                     if (textOffset >= box->start())
                         return currentPos;
                     continue;
                 }
 
                 if (box == lastTextBox || textOffset != box->start() + box->len())
                     continue;
@@ skipping 32 matching lines @@
 static int boundingBoxLogicalHeight(LayoutObject *o, const IntRect &rect)
 {
     return o->style()->isHorizontalWritingMode() ? rect.height() : rect.width();
 }
 
 bool Position::hasRenderedNonAnonymousDescendantsWithHeight(LayoutObject* renderer)
 {
     LayoutObject* stop = renderer->nextInPreOrderAfterChildren();
     for (LayoutObject *o = renderer->slowFirstChild(); o && o != stop; o = o->nextInPreOrder())
         if (o->nonPseudoNode()) {
-            if ((o->isText() && boundingBoxLogicalHeight(o, toRenderText(o)->linesBoundingBox()))
+            if ((o->isText() && boundingBoxLogicalHeight(o, toLayoutText(o)->linesBoundingBox()))
                 || (o->isBox() && toLayoutBox(o)->pixelSnappedLogicalHeight())
                 || (o->isLayoutInline() && isEmptyInline(o) && boundingBoxLogicalHeight(o, toLayoutInline(o)->linesBoundingBox())))
                 return true;
         }
     return false;
 }
 
 bool Position::nodeIsUserSelectNone(Node* node)
 {
     return node && node->renderer() && !node->renderer()->isSelectable();
@@ skipping 74 matching lines @@
 
 bool Position::inRenderedText() const
 {
     if (isNull() || !deprecatedNode()->isTextNode())
         return false;
 
     LayoutObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
 
-    RenderText *textRenderer = toRenderText(renderer);
+    LayoutText* textRenderer = toLayoutText(renderer);
     for (InlineTextBox *box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
         if (box->containsCaretOffset(m_offset))
             // Return false for offsets inside composed characters.
             return m_offset == 0 || m_offset == textRenderer->nextOffset(textRenderer->previousOffset(m_offset));
     }
 
     return false;
 }
 
 bool Position::isRenderedCharacter() const
 {
     if (isNull() || !deprecatedNode()->isTextNode())
         return false;
 
     LayoutObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
 
-    RenderText* textRenderer = toRenderText(renderer);
+    LayoutText* textRenderer = toLayoutText(renderer);
     for (InlineTextBox* box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
         if (m_offset < static_cast<int>(box->start()) && !textRenderer->containsReversedText()) {
             // The offset we're looking for is before this node
             // this means the offset must be in content that is
             // not rendered. Return false.
             return false;
         }
         if (m_offset >= static_cast<int>(box->start()) && m_offset < static_cast<int>(box->start() + box->len()))
             return true;
     }
@@ skipping 107 matching lines @@
     for (LayoutObject* next = renderer->nextInPreOrder(container); next; next = next->nextInPreOrder(container)) {
         if (next->isLayoutBlock())
             return 0;
         if (next->isBR())
             return 0;
         if (isNonTextLeafChild(next))
             return 0;
         if (next->isText()) {
             InlineTextBox* match = 0;
             int minOffset = INT_MAX;
-            for (InlineTextBox* box = toRenderText(next)->firstTextBox(); box; box = box->nextTextBox()) {
+            for (InlineTextBox* box = toLayoutText(next)->firstTextBox(); box; box = box->nextTextBox()) {
                 int caretMinOffset = box->caretMinOffset();
                 if (caretMinOffset < minOffset) {
                     match = box;
                     minOffset = caretMinOffset;
                 }
             }
             if (match)
                 return match;
         }
     }
@@ skipping 40 matching lines @@
 
             equivalent.getInlineBoxAndOffset(UPSTREAM, primaryDirection, inlineBox, caretOffset);
             return;
         }
         if (renderer->isBox()) {
             inlineBox = toLayoutBox(renderer)->inlineBoxWrapper();
             if (!inlineBox || (caretOffset > inlineBox->caretMinOffset() && caretOffset < inlineBox->caretMaxOffset()))
                 return;
         }
     } else {
-        RenderText* textRenderer = toRenderText(renderer);
+        LayoutText* textRenderer = toLayoutText(renderer);
 
         InlineTextBox* box;
         InlineTextBox* candidate = 0;
 
         for (box = textRenderer->firstTextBox(); box; box = box->nextTextBox()) {
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (caretOffset < caretMinOffset || caretOffset > caretMaxOffset || (caretOffset == caretMaxOffset && box->isLineBreak()))
                 continue;
@@ skipping 206 matching lines @@
     pos.showTreeForThis();
 }
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
 }
 
 #endif