Move rendering/RenderObject to layout/LayoutObject.

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 36 matching lines @@
 #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()) {
-        RenderObject* renderer = node->renderer();
+        LayoutObject* renderer = node->renderer();
         if (!renderer)
             continue;
         if (!node->hasEditableStyle())
             continue;
         if ((renderer->isBox() && toRenderBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toRenderText(renderer)->firstTextBox()))
             return node;
     }
     return 0;
 }
 
 static Node* previousRenderedEditable(Node* node)
 {
     for (node = node->previousLeafNode(); node; node = node->previousLeafNode()) {
-        RenderObject* renderer = node->renderer();
+        LayoutObject* renderer = node->renderer();
         if (!renderer)
             continue;
         if (!node->hasEditableStyle())
             continue;
         if ((renderer->isBox() && toRenderBox(renderer)->inlineBoxWrapper()) || (renderer->isText() && toRenderText(renderer)->firstTextBox()))
             return node;
     }
     return 0;
 }
 
@@ skipping 481 matching lines @@
             }
             lastNode = currentNode;
         }
 
         // If we've moved to a position that is visually distinct, return the last saved position. There
         // is code below that terminates early if we're *about* to move to a visually distinct position.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
             return lastVisible;
 
         // skip position in unrendered or invisible node
-        RenderObject* renderer = currentNode->renderer();
+        LayoutObject* renderer = currentNode->renderer();
         if (!renderer || renderer->style()->visibility() != VISIBLE)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer(currentPos))
@@ skipping 112 matching lines @@
         // Do not move to a visually distinct position.
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
             return lastVisible;
         // Do not move past a visually disinct position.
         // Note: The first position after the last in a node whose ends are visually distinct
         // positions will be [boundary->parentNode(), originalBlock->nodeIndex() + 1].
         if (boundary && boundary->parentNode() == currentNode)
             return lastVisible;
 
         // skip position in unrendered or invisible node
-        RenderObject* renderer = currentNode->renderer();
+        LayoutObject* renderer = currentNode->renderer();
         if (!renderer || renderer->style()->visibility() != VISIBLE)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer(currentPos))
@@ skipping 50 matching lines @@
 
                 if (continuesOnNextLine)
                     return currentPos;
             }
         }
     }
 
     return lastVisible;
 }
 
-static int boundingBoxLogicalHeight(RenderObject *o, const IntRect &rect)
+static int boundingBoxLogicalHeight(LayoutObject *o, const IntRect &rect)
 {
     return o->style()->isHorizontalWritingMode() ? rect.height() : rect.width();
 }
 
-bool Position::hasRenderedNonAnonymousDescendantsWithHeight(RenderObject* renderer)
+bool Position::hasRenderedNonAnonymousDescendantsWithHeight(LayoutObject* renderer)
 {
-    RenderObject* stop = renderer->nextInPreOrderAfterChildren();
-    for (RenderObject *o = renderer->slowFirstChild(); o && o != stop; o = o->nextInPreOrder())
+    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()))
                 || (o->isBox() && toRenderBox(o)->pixelSnappedLogicalHeight())
                 || (o->isRenderInline() && isEmptyInline(o) && boundingBoxLogicalHeight(o, toRenderInline(o)->linesBoundingBox())))
                 return true;
         }
     return false;
 }
 
 bool Position::nodeIsUserSelectNone(Node* node)
@@ skipping 26 matching lines @@
         parent = candidateRoot->parentNode();
     }
     return candidateRoot;
 }
 
 bool Position::isCandidate() const
 {
     if (isNull())
         return false;
 
-    RenderObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
 
     if (renderer->style()->visibility() != VISIBLE)
         return false;
 
     if (renderer->isBR())
         // FIXME: The condition should be m_anchorType == PositionIsBeforeAnchor, but for now we still need to support legacy positions.
         return !m_offset && m_anchorType != PositionIsAfterAnchor && !nodeIsUserSelectNone(deprecatedNode()->parentNode());
 
@@ skipping 25 matching lines @@
     }
 
     return false;
 }
 
 bool Position::inRenderedText() const
 {
     if (isNull() || !deprecatedNode()->isTextNode())
         return false;
 
-    RenderObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
 
     RenderText *textRenderer = toRenderText(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;
 
-    RenderObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
 
     RenderText* textRenderer = toRenderText(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;
     }
 
     return false;
 }
 
 bool Position::rendersInDifferentPosition(const Position &pos) const
 {
     if (isNull() || pos.isNull())
         return false;
 
-    RenderObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->renderer();
     if (!renderer)
         return false;
 
-    RenderObject* posRenderer = pos.deprecatedNode()->renderer();
+    LayoutObject* posRenderer = pos.deprecatedNode()->renderer();
     if (!posRenderer)
         return false;
 
     if (renderer->style()->visibility() != VISIBLE ||
         posRenderer->style()->visibility() != VISIBLE)
         return false;
 
     if (deprecatedNode() == pos.deprecatedNode()) {
         if (isHTMLBRElement(*deprecatedNode()))
             return false;
@@ skipping 61 matching lines @@
     }
 
     return true;
 }
 
 void Position::getInlineBoxAndOffset(EAffinity affinity, InlineBox*& inlineBox, int& caretOffset) const
 {
     getInlineBoxAndOffset(affinity, primaryDirection(), inlineBox, caretOffset);
 }
 
-static bool isNonTextLeafChild(RenderObject* object)
+static bool isNonTextLeafChild(LayoutObject* object)
 {
     if (object->slowFirstChild())
         return false;
     if (object->isText())
         return false;
     return true;
 }
 
-static InlineTextBox* searchAheadForBetterMatch(RenderObject* renderer)
+static InlineTextBox* searchAheadForBetterMatch(LayoutObject* renderer)
 {
     RenderBlock* container = renderer->containingBlock();
-    for (RenderObject* next = renderer->nextInPreOrder(container); next; next = next->nextInPreOrder(container)) {
+    for (LayoutObject* next = renderer->nextInPreOrder(container); next; next = next->nextInPreOrder(container)) {
         if (next->isRenderBlock())
             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()) {
@@ skipping 26 matching lines @@
     while (position != lastPosition) {
         lastPosition = position;
         position = position.upstream(CanCrossEditingBoundary);
     }
     return position;
 }
 
 void Position::getInlineBoxAndOffset(EAffinity affinity, TextDirection primaryDirection, InlineBox*& inlineBox, int& caretOffset) const
 {
     caretOffset = deprecatedEditingOffset();
-    RenderObject* renderer = deprecatedNode()->renderer();
+    LayoutObject* renderer = deprecatedNode()->renderer();
 
     if (!renderer->isText()) {
         inlineBox = 0;
         if (canHaveChildrenForEditing(deprecatedNode()) && renderer->isRenderBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(renderer)) {
             // Try a visually equivalent position with possibly opposite editability. This helps in case |this| is in
             // an editable block but surrounded by non-editable positions. It acts to negate the logic at the beginning
-            // of RenderObject::createVisiblePosition().
+            // of LayoutObject::createVisiblePosition().
             Position equivalent = downstreamIgnoringEditingBoundaries(*this);
             if (equivalent == *this) {
                 equivalent = upstreamIgnoringEditingBoundaries(*this);
                 if (equivalent == *this || downstreamIgnoringEditingBoundaries(equivalent) == *this)
                     return;
             }
 
             equivalent.getInlineBoxAndOffset(UPSTREAM, primaryDirection, inlineBox, caretOffset);
             return;
         }
@@ skipping 128 matching lines @@
                 inlineBox = tertiaryBox;
             }
             caretOffset = inlineBox->caretRightmostOffset();
         }
     }
 }
 
 TextDirection Position::primaryDirection() const
 {
     TextDirection primaryDirection = LTR;
-    for (const RenderObject* r = m_anchorNode->renderer(); r; r = r->parent()) {
+    for (const LayoutObject* r = m_anchorNode->renderer(); r; r = r->parent()) {
         if (r->isRenderBlockFlow()) {
             primaryDirection = r->style()->direction();
             break;
         }
     }
 
     return primaryDirection;
 }
 
 void Position::trace(Visitor* visitor)
@@ skipping 74 matching lines @@
     pos.showTreeForThis();
 }
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
 }
 
 #endif