Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/line/InlineFlowBox.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple 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.
  */
 
 #include "config.h"
 #include "core/layout/line/InlineFlowBox.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/dom/Document.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/Layer.h"
+#include "core/layout/LayoutObjectInlines.h"
 #include "core/layout/LayoutRubyBase.h"
 #include "core/layout/LayoutRubyRun.h"
 #include "core/layout/LayoutRubyText.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/layout/line/RootInlineBox.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/InlineFlowBoxPainter.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderInline.h"
 #include "core/rendering/RenderListMarker.h"
-#include "core/rendering/RenderObjectInlines.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/style/ShadowList.h"
 #include "platform/fonts/Font.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 
 #include <math.h>
 
 namespace blink {
 
 struct SameSizeAsInlineFlowBox : public InlineBox {
@@ skipping 165 matching lines @@
         child->setParent(0);
 #endif
         child->deleteLine();
         child = next;
     }
 #if ENABLE(ASSERT)
     m_firstChild = 0;
     m_lastChild = 0;
 #endif
 
-    removeLineBoxFromRenderObject();
+    removeLineBoxFromLayoutObject();
     destroy();
 }
 
-void InlineFlowBox::removeLineBoxFromRenderObject()
+void InlineFlowBox::removeLineBoxFromLayoutObject()
 {
     rendererLineBoxes()->removeLineBox(this);
 }
 
 void InlineFlowBox::extractLine()
 {
     if (!extracted())
-        extractLineBoxFromRenderObject();
+        extractLineBoxFromLayoutObject();
     for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
         child->extractLine();
 }
 
-void InlineFlowBox::extractLineBoxFromRenderObject()
+void InlineFlowBox::extractLineBoxFromLayoutObject()
 {
     rendererLineBoxes()->extractLineBox(this);
 }
 
 void InlineFlowBox::attachLine()
 {
     if (extracted())
-        attachLineBoxToRenderObject();
+        attachLineBoxToLayoutObject();
     for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
         child->attachLine();
 }
 
-void InlineFlowBox::attachLineBoxToRenderObject()
+void InlineFlowBox::attachLineBoxToLayoutObject()
 {
     rendererLineBoxes()->attachLineBox(this);
 }
 
 void InlineFlowBox::adjustPosition(FloatWillBeLayoutUnit dx, FloatWillBeLayoutUnit dy)
 {
     InlineBox::adjustPosition(dx, dy);
     for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
         child->adjustPosition(dx, dy);
     if (m_overflow)
         m_overflow->move(dx, dy); // FIXME: Rounding error here since overflow was pixel snapped, but nobody other than list markers passes non-integral values here.
 }
 
 RenderLineBoxList* InlineFlowBox::rendererLineBoxes() const
 {
     return toRenderInline(renderer()).lineBoxes();
 }
 
-static inline bool isLastChildForRenderer(RenderObject* ancestor, RenderObject* child)
+static inline bool isLastChildForRenderer(LayoutObject* ancestor, LayoutObject* child)
 {
     if (!child)
         return false;
 
     if (child == ancestor)
         return true;
 
-    RenderObject* curr = child;
-    RenderObject* parent = curr->parent();
+    LayoutObject* curr = child;
+    LayoutObject* parent = curr->parent();
     while (parent && (!parent->isRenderBlock() || parent->isInline())) {
         if (parent->slowLastChild() != curr)
             return false;
         if (parent == ancestor)
             return true;
 
         curr = parent;
         parent = curr->parent();
     }
 
     return true;
 }
 
-static bool isAnsectorAndWithinBlock(RenderObject* ancestor, RenderObject* child)
+static bool isAnsectorAndWithinBlock(LayoutObject* ancestor, LayoutObject* child)
 {
-    RenderObject* object = child;
+    LayoutObject* object = child;
     while (object && (!object->isRenderBlock() || object->isInline())) {
         if (object == ancestor)
             return true;
         object = object->parent();
     }
     return false;
 }
 
-void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, bool isLogicallyLastRunWrapped, RenderObject* logicallyLastRunRenderer)
+void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, bool isLogicallyLastRunWrapped, LayoutObject* logicallyLastRunRenderer)
 {
     // All boxes start off open.  They will not apply any margins/border/padding on
     // any side.
     bool includeLeftEdge = false;
     bool includeRightEdge = false;
 
     // The root inline box never has borders/margins/padding.
     if (parent()) {
         bool ltr = renderer().style()->isLeftToRightDirection();
 
@@ skipping 686 matching lines @@
 
 bool InlineFlowBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
 {
     LayoutRect overflowRect(visualOverflowRect(lineTop, lineBottom));
     flipForWritingMode(overflowRect);
     overflowRect.moveBy(accumulatedOffset);
     if (!locationInContainer.intersects(overflowRect))
         return false;
 
     // We need to hit test both our inline children (InlineBoxes) and culled inlines
-    // (RenderObjects). We check our inlines in the same order as line layout but
+    // (LayoutObjects). We check our inlines in the same order as line layout but
     // for each inline we additionally need to hit test its culled inline parents.
     // While hit testing culled inline parents, we can stop once we reach
     // a non-inline parent or a culled inline associated with a different inline box.
     InlineBox* prev;
     for (InlineBox* curr = lastChild(); curr; curr = prev) {
         prev = curr->prevOnLine();
 
         // Layers will handle hit testing themselves.
         if (curr->boxModelObject() && curr->boxModelObject()->hasSelfPaintingLayer())
             continue;
 
         if (curr->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom)) {
             renderer().updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
             return true;
         }
 
         // If the current inlinebox's renderer and the previous inlinebox's renderer are same,
         // we should yield the hit-test to the previous inlinebox.
         if (prev && curr->renderer() == prev->renderer())
             continue;
 
-        RenderObject* culledParent = &curr->renderer();
+        LayoutObject* culledParent = &curr->renderer();
         while (true) {
-            RenderObject* sibling = culledParent->style()->isLeftToRightDirection() ? culledParent->previousSibling() : culledParent->nextSibling();
+            LayoutObject* sibling = culledParent->style()->isLeftToRightDirection() ? culledParent->previousSibling() : culledParent->nextSibling();
             culledParent = culledParent->parent();
             ASSERT(culledParent);
 
             if (culledParent == renderer() || (sibling && prev && prev->renderer().isDescendantOf(culledParent)))
                 break;
 
             if (culledParent->isRenderInline() && toRenderInline(culledParent)->hitTestCulledInline(request, result, locationInContainer, accumulatedOffset))
                 return true;
         }
     }
@@ skipping 53 matching lines @@
 }
 
 InlineBox* InlineFlowBox::lastLeafChild() const
 {
     InlineBox* leaf = 0;
     for (InlineBox* child = lastChild(); child && !leaf; child = child->prevOnLine())
         leaf = child->isLeaf() ? child : toInlineFlowBox(child)->lastLeafChild();
     return leaf;
 }
 
-RenderObject::SelectionState InlineFlowBox::selectionState() const
+LayoutObject::SelectionState InlineFlowBox::selectionState() const
 {
-    return RenderObject::SelectionNone;
+    return LayoutObject::SelectionNone;
 }
 
 bool InlineFlowBox::canAccommodateEllipsis(bool ltr, int blockEdge, int ellipsisWidth) const
 {
     for (InlineBox *box = firstChild(); box; box = box->nextOnLine()) {
         if (!box->canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth))
             return false;
     }
     return true;
 }
@@ skipping 182 matching lines @@
     }
 }
 
 #ifndef NDEBUG
 
 const char* InlineFlowBox::boxName() const
 {
     return "InlineFlowBox";
 }
 
-void InlineFlowBox::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj, int depth) const
+void InlineFlowBox::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj, int depth) const
 {
     InlineBox::showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, depth);
     for (const InlineBox* box = firstChild(); box; box = box->nextOnLine())
         box->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, depth + 1);
 }
 
 #endif
 
 #if ENABLE(ASSERT)
 void InlineFlowBox::checkConsistency() const
 {
 #ifdef CHECK_CONSISTENCY
     ASSERT(!m_hasBadChildList);
     const InlineBox* prev = 0;
     for (const InlineBox* child = m_firstChild; child; child = child->nextOnLine()) {
         ASSERT(child->parent() == this);
         ASSERT(child->prevOnLine() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastChild);
 #endif
 }
 
 #endif
 
 } // namespace blink