Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/InlineBox.h

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 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.
  *
  */
 
 #ifndef InlineBox_h
 #define InlineBox_h
 
+#include "core/layout/LayoutObject.h"
 #include "core/rendering/FloatToLayoutUnit.h"
 #include "core/rendering/RenderBoxModelObject.h"
-#include "core/rendering/RenderObjectInlines.h"
 #include "platform/graphics/paint/DisplayItemClient.h"
 #include "platform/text/TextDirection.h"
 
 namespace blink {
 
 class HitTestRequest;
 class HitTestResult;
 class RootInlineBox;
 
 enum MarkLineBoxes { MarkLineBoxesDirty, DontMarkLineBoxes };
 
 // InlineBox represents a rectangle that occurs on a line.  It corresponds to
-// some RenderObject (i.e., it represents a portion of that RenderObject).
+// some LayoutObject (i.e., it represents a portion of that LayoutObject).
 class InlineBox {
     WTF_MAKE_NONCOPYABLE(InlineBox);
 public:
-    InlineBox(RenderObject& obj)
+    InlineBox(LayoutObject& obj)
         : m_next(0)
         , m_prev(0)
         , m_parent(0)
         , m_renderer(obj)
         , m_logicalWidth()
 #if ENABLE(ASSERT)
         , m_hasBadParent(false)
 #endif
     {
     }
 
-    InlineBox(RenderObject& obj, FloatPointWillBeLayoutPoint topLeft, FloatWillBeLayoutUnit logicalWidth, bool firstLine, bool constructed,
+    InlineBox(LayoutObject& obj, FloatPointWillBeLayoutPoint topLeft, FloatWillBeLayoutUnit logicalWidth, bool firstLine, bool constructed,
               bool dirty, bool extracted, bool isHorizontal, InlineBox* next, InlineBox* prev, InlineFlowBox* parent)
         : m_next(next)
         , m_prev(prev)
         , m_parent(parent)
         , m_renderer(obj)
         , m_topLeft(topLeft)
         , m_logicalWidth(logicalWidth)
         , m_bitfields(firstLine, constructed, dirty, extracted, isHorizontal)
 #if ENABLE(ASSERT)
         , m_hasBadParent(false)
@@ skipping 39 matching lines @@
 
     // InlineBoxes are allocated out of the rendering partition.
     void* operator new(size_t);
     void operator delete(void*);
 
 #ifndef NDEBUG
     void showTreeForThis() const;
     void showLineTreeForThis() const;
 
     virtual void showBox(int = 0) const;
-    virtual void showLineTreeAndMark(const InlineBox* = 0, const char* = 0, const InlineBox* = 0, const char* = 0, const RenderObject* = 0, int = 0) const;
+    virtual void showLineTreeAndMark(const InlineBox* = 0, const char* = 0, const InlineBox* = 0, const char* = 0, const LayoutObject* = 0, int = 0) const;
     virtual const char* boxName() const;
 #endif
 
     bool isText() const { return m_bitfields.isText(); }
     void setIsText(bool isText) { m_bitfields.setIsText(isText); }
 
     virtual bool isInlineFlowBox() const { return false; }
     virtual bool isInlineTextBox() const { return false; }
     virtual bool isRootInlineBox() const { return false; }
 
@@ skipping 46 matching lines @@
 
     InlineBox* nextLeafChild() const;
     InlineBox* prevLeafChild() const;
 
     // Helper functions for editing and hit-testing code.
     // FIXME: These two functions should be moved to RenderedPosition once the code to convert between
     // Position and inline box, offset pair is moved to RenderedPosition.
     InlineBox* nextLeafChildIgnoringLineBreak() const;
     InlineBox* prevLeafChildIgnoringLineBreak() const;
 
-    RenderObject& renderer() const { return m_renderer; }
+    LayoutObject& renderer() const { return m_renderer; }
 
     InlineFlowBox* parent() const
     {
         ASSERT(!m_hasBadParent);
         return m_parent;
     }
     void setParent(InlineFlowBox* par) { m_parent = par; }
 
     const RootInlineBox& root() const;
     RootInlineBox& root();
@@ skipping 64 matching lines @@
     int caretLeftmostOffset() const { return isLeftToRightDirection() ? caretMinOffset() : caretMaxOffset(); }
     int caretRightmostOffset() const { return isLeftToRightDirection() ? caretMaxOffset() : caretMinOffset(); }
 
     virtual void clearTruncation() { }
 
     bool isDirty() const { return m_bitfields.dirty(); }
     virtual void markDirty() { m_bitfields.setDirty(true); }
 
     virtual void dirtyLineBoxes();
 
-    virtual RenderObject::SelectionState selectionState() const;
+    virtual LayoutObject::SelectionState selectionState() const;
 
     virtual bool canAccommodateEllipsis(bool ltr, int blockEdge, int ellipsisWidth) const;
     // visibleLeftEdge, visibleRightEdge are in the parent's coordinate system.
     virtual FloatWillBeLayoutUnit placeEllipsisBox(bool ltr, FloatWillBeLayoutUnit visibleLeftEdge, FloatWillBeLayoutUnit visibleRightEdge, FloatWillBeLayoutUnit ellipsisWidth, FloatWillBeLayoutUnit &truncatedWidth, bool&);
 
 #if ENABLE(ASSERT)
     void setHasBadParent();
 #endif
 
     int expansion() const { return m_bitfields.expansion(); }
@@ skipping 100 matching lines @@
         signed expansion() const { return m_expansion; }
         void setExpansion(signed expansion) { m_expansion = expansion; }
     };
 #undef ADD_BOOLEAN_BITFIELD
 
 private:
     InlineBox* m_next; // The next element on the same line as us.
     InlineBox* m_prev; // The previous element on the same line as us.
 
     InlineFlowBox* m_parent; // The box that contains us.
-    RenderObject& m_renderer;
+    LayoutObject& m_renderer;
 
 protected:
     // For RootInlineBox
     bool endsWithBreak() const { return m_bitfields.endsWithBreak(); }
     void setEndsWithBreak(bool endsWithBreak) { m_bitfields.setEndsWithBreak(endsWithBreak); }
     bool hasEllipsisBox() const { return m_bitfields.hasEllipsisBoxOrHyphen(); }
     bool hasSelectedChildren() const { return m_bitfields.hasSelectedChildrenOrCanHaveLeadingExpansion(); }
     void setHasSelectedChildren(bool hasSelectedChildren) { m_bitfields.setHasSelectedChildrenOrCanHaveLeadingExpansion(hasSelectedChildren); }
     void setHasEllipsisBox(bool hasEllipsisBox) { m_bitfields.setHasEllipsisBoxOrHyphen(hasEllipsisBox); }
 
@@ skipping 40 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const blink::InlineBox*);
 void showLineTree(const blink::InlineBox*);
 #endif
 
 #endif // InlineBox_h