Remove writing mode code from the linebox tree.

sky/engine/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
@@ skipping 33 matching lines @@
         , m_parent(0)
         , m_renderer(obj)
         , m_logicalWidth(0)
 #if ENABLE(ASSERT)
         , m_hasBadParent(false)
 #endif
     {
     }
 
     InlineBox(RenderObject& obj, FloatPoint topLeft, float logicalWidth, bool firstLine, bool constructed,
-              bool dirty, bool extracted, bool isHorizontal, InlineBox* next, InlineBox* prev, InlineFlowBox* parent)
+              bool dirty, bool extracted, 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)
+        , m_bitfields(firstLine, constructed, dirty, extracted)
 #if ENABLE(ASSERT)
         , m_hasBadParent(false)
 #endif
     {
     }
 
     virtual ~InlineBox();
 
     virtual void destroy() { delete this; }
 
     virtual void deleteLine();
     virtual void extractLine();
     virtual void attachLine();
 
     virtual bool isLineBreak() const { return false; }
 
     virtual void adjustPosition(float dx, float dy);
     void adjustLogicalPosition(float deltaLogicalLeft, float deltaLogicalTop)
     {
-        if (isHorizontal())
-            adjustPosition(deltaLogicalLeft, deltaLogicalTop);
-        else
-            adjustPosition(deltaLogicalTop, deltaLogicalLeft);
+        // FIXME(sky): Remove
+        adjustPosition(deltaLogicalLeft, deltaLogicalTop);
     }
     void adjustLineDirectionPosition(float delta)
     {
-        if (isHorizontal())
-            adjustPosition(delta, 0);
-        else
-            adjustPosition(0, delta);
+        adjustPosition(delta, 0);
     }
     void adjustBlockDirectionPosition(float delta)
     {
-        if (isHorizontal())
-            adjustPosition(0, delta);
-        else
-            adjustPosition(delta, 0);
+        adjustPosition(0, delta);
     }
 
     virtual void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom);
     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom);
 
     // InlineBoxes are allocated out of the rendering partition.
     void* operator new(size_t);
     void operator delete(void*);
 
 #ifndef NDEBUG
@@ skipping 17 matching lines @@
     virtual bool isSVGRootInlineBox() const { return false; }
 
     bool hasVirtualLogicalHeight() const { return m_bitfields.hasVirtualLogicalHeight(); }
     void setHasVirtualLogicalHeight() { m_bitfields.setHasVirtualLogicalHeight(true); }
     virtual float virtualLogicalHeight() const
     {
         ASSERT_NOT_REACHED();
         return 0;
     }
 
-    bool isHorizontal() const { return m_bitfields.isHorizontal(); }
-    void setIsHorizontal(bool isHorizontal) { m_bitfields.setIsHorizontal(isHorizontal); }
-
     virtual FloatRect calculateBoundaries() const
     {
         ASSERT_NOT_REACHED();
         return FloatRect();
     }
 
     bool isConstructed() { return m_bitfields.constructed(); }
     virtual void setConstructed() { m_bitfields.setConstructed(true); }
 
     void setExtracted(bool extracted = true) { m_bitfields.setExtracted(extracted); }
@@ skipping 45 matching lines @@
     float x() const { return m_topLeft.x(); }
     float left() const { return m_topLeft.x(); }
 
     // y() is the top side of the box in the containing block's coordinate system.
     void setY(float y) { m_topLeft.setY(y); }
     float y() const { return m_topLeft.y(); }
     float top() const { return m_topLeft.y(); }
 
     const FloatPoint& topLeft() const { return m_topLeft; }
 
-    float width() const { return isHorizontal() ? logicalWidth() : hasVirtualLogicalHeight() ? virtualLogicalHeight() : logicalHeight(); }
-    float height() const { return isHorizontal() ? hasVirtualLogicalHeight() ? virtualLogicalHeight() : logicalHeight() : logicalWidth(); }
+    float width() const { return logicalWidth(); }
+    float height() const { return hasVirtualLogicalHeight() ? virtualLogicalHeight() : logicalHeight(); }
     FloatSize size() const { return FloatSize(width(), height()); }
     float right() const { return left() + width(); }
     float bottom() const { return top() + height(); }
 
     // The logicalLeft position is the left edge of the line box in a horizontal line and the top edge in a vertical line.
-    float logicalLeft() const { return isHorizontal() ? m_topLeft.x() : m_topLeft.y(); }
+    float logicalLeft() const { return m_topLeft.x(); }
     float logicalRight() const { return logicalLeft() + logicalWidth(); }
     void setLogicalLeft(float left)
     {
-        if (isHorizontal())
-            setX(left);
-        else
-            setY(left);
+        // FIXME(sky): Remove
+        setX(left);
     }
     int pixelSnappedLogicalLeft() const { return logicalLeft(); }
     int pixelSnappedLogicalRight() const { return ceilf(logicalRight()); }
     int pixelSnappedLogicalTop() const { return logicalTop(); }
     int pixelSnappedLogicalBottom() const { return ceilf(logicalBottom()); }
 
     // The logicalTop[ position is the top edge of the line box in a horizontal line and the left edge in a vertical line.
-    float logicalTop() const { return isHorizontal() ? m_topLeft.y() : m_topLeft.x(); }
+    float logicalTop() const { return m_topLeft.y(); }
     float logicalBottom() const { return logicalTop() + logicalHeight(); }
     void setLogicalTop(float top)
     {
-        if (isHorizontal())
-            setY(top);
-        else
-            setX(top);
+        setY(top);
     }
 
     // The logical width is our extent in the line's overall inline direction, i.e., width for horizontal text and height for vertical text.
     void setLogicalWidth(float w) { m_logicalWidth = w; }
     float logicalWidth() const { return m_logicalWidth; }
 
     // The logical height is our extent in the block flow direction, i.e., height for horizontal text and width for vertical text.
     float logicalHeight() const;
 
-    FloatRect logicalFrameRect() const { return isHorizontal() ? FloatRect(m_topLeft.x(), m_topLeft.y(), m_logicalWidth, logicalHeight()) : FloatRect(m_topLeft.y(), m_topLeft.x(), m_logicalWidth, logicalHeight()); }
+    FloatRect logicalFrameRect() const { return FloatRect(m_topLeft.x(), m_topLeft.y(), m_logicalWidth, logicalHeight()); }
 
     virtual int baselinePosition(FontBaseline baselineType) const;
     virtual LayoutUnit lineHeight() const;
 
     virtual int caretMinOffset() const;
     virtual int caretMaxOffset() const;
 
     unsigned char bidiLevel() const { return m_bitfields.bidiEmbeddingLevel(); }
     void setBidiLevel(unsigned char level) { m_bitfields.setBidiEmbeddingLevel(level); }
     TextDirection direction() const { return bidiLevel() % 2 ? RTL : LTR; }
@@ skipping 42 matching lines @@
 
 #define ADD_BOOLEAN_BITFIELD(name, Name) \
     private:\
     unsigned m_##name : 1;\
     public:\
     bool name() const { return m_##name; }\
     void set##Name(bool name) { m_##name = name; }\
 
     class InlineBoxBitfields {
     public:
-        InlineBoxBitfields(bool firstLine = false, bool constructed = false, bool dirty = false, bool extracted = false, bool isHorizontal = true)
+        InlineBoxBitfields(bool firstLine = false, bool constructed = false, bool dirty = false, bool extracted = false)
             : m_firstLine(firstLine)
             , m_constructed(constructed)
             , m_bidiEmbeddingLevel(0)
             , m_dirty(dirty)
             , m_extracted(extracted)
             , m_hasVirtualLogicalHeight(false)
-            , m_isHorizontal(isHorizontal)
             , m_endsWithBreak(false)
             , m_hasSelectedChildrenOrCanHaveLeadingExpansion(false)
             , m_knownToHaveNoOverflow(true)
             , m_hasEllipsisBoxOrHyphen(false)
             , m_dirOverride(false)
             , m_isText(false)
             , m_determinedIfNextOnLineExists(false)
             , m_nextOnLineExists(false)
             , m_expansion(0)
         {
         }
 
         // Some of these bits are actually for subclasses and moved here to compact the structures.
         // for this class
         ADD_BOOLEAN_BITFIELD(firstLine, FirstLine);
         ADD_BOOLEAN_BITFIELD(constructed, Constructed);
 
     private:
         unsigned m_bidiEmbeddingLevel : 6; // The maximium bidi level is 62: http://unicode.org/reports/tr9/#Explicit_Levels_and_Directions
 
     public:
         unsigned char bidiEmbeddingLevel() const { return m_bidiEmbeddingLevel; }
         void setBidiEmbeddingLevel(unsigned char bidiEmbeddingLevel) { m_bidiEmbeddingLevel = bidiEmbeddingLevel; }
 
         ADD_BOOLEAN_BITFIELD(dirty, Dirty);
         ADD_BOOLEAN_BITFIELD(extracted, Extracted);
         ADD_BOOLEAN_BITFIELD(hasVirtualLogicalHeight, HasVirtualLogicalHeight);
-        ADD_BOOLEAN_BITFIELD(isHorizontal, IsHorizontal);
         // for RootInlineBox
         ADD_BOOLEAN_BITFIELD(endsWithBreak, EndsWithBreak); // Whether the line ends with a <br>.
         // shared between RootInlineBox and InlineTextBox
         ADD_BOOLEAN_BITFIELD(hasSelectedChildrenOrCanHaveLeadingExpansion, HasSelectedChildrenOrCanHaveLeadingExpansion);
         ADD_BOOLEAN_BITFIELD(knownToHaveNoOverflow, KnownToHaveNoOverflow);
         ADD_BOOLEAN_BITFIELD(hasEllipsisBoxOrHyphen, HasEllipsisBoxOrHyphen);
         // for InlineTextBox
         ADD_BOOLEAN_BITFIELD(dirOverride, DirOverride);
         ADD_BOOLEAN_BITFIELD(isText, IsText); // Whether or not this object represents text with a non-zero height. Includes non-image list markers, text boxes.
 
@@ skipping 79 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