Switch line layout to LayoutUnit.

Source/core/layout/line/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/LayoutBoxModelObject.h"
 #include "core/layout/LayoutObject.h"
-#include "core/layout/line/FloatToLayoutUnit.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 LayoutObject (i.e., it represents a portion of that LayoutObject).
 class InlineBox {
     WTF_MAKE_NONCOPYABLE(InlineBox);
 public:
     InlineBox(LayoutObject& obj)
         : m_next(0)
         , m_prev(0)
         , m_parent(0)
         , m_layoutObject(obj)
         , m_logicalWidth()
 #if ENABLE(ASSERT)
         , m_hasBadParent(false)
 #endif
     {
     }
 
-    InlineBox(LayoutObject& obj, FloatPointWillBeLayoutPoint topLeft, FloatWillBeLayoutUnit logicalWidth, bool firstLine, bool constructed,
+    InlineBox(LayoutObject& obj, LayoutPoint topLeft, LayoutUnit 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_layoutObject(obj)
         , m_topLeft(topLeft)
         , m_logicalWidth(logicalWidth)
         , m_bitfields(firstLine, constructed, dirty, extracted, isHorizontal)
 #if ENABLE(ASSERT)
         , m_hasBadParent(false)
 #endif
     {
     }
 
     virtual ~InlineBox();
 
     virtual void destroy();
 
     virtual void deleteLine();
     virtual void extractLine();
     virtual void attachLine();
 
     virtual bool isLineBreak() const { return false; }
 
-    virtual void adjustPosition(FloatWillBeLayoutUnit dx, FloatWillBeLayoutUnit dy);
-    void adjustLogicalPosition(FloatWillBeLayoutUnit deltaLogicalLeft, FloatWillBeLayoutUnit deltaLogicalTop)
+    virtual void adjustPosition(LayoutUnit dx, LayoutUnit dy);
+    void adjustLogicalPosition(LayoutUnit deltaLogicalLeft, LayoutUnit deltaLogicalTop)
     {
         if (isHorizontal())
             adjustPosition(deltaLogicalLeft, deltaLogicalTop);
         else
             adjustPosition(deltaLogicalTop, deltaLogicalLeft);
     }
-    void adjustLineDirectionPosition(FloatWillBeLayoutUnit delta)
+    void adjustLineDirectionPosition(LayoutUnit delta)
     {
         if (isHorizontal())
             adjustPosition(delta, 0);
         else
             adjustPosition(0, delta);
     }
-    void adjustBlockDirectionPosition(FloatWillBeLayoutUnit delta)
+    void adjustBlockDirectionPosition(LayoutUnit delta)
     {
         if (isHorizontal())
             adjustPosition(0, delta);
         else
             adjustPosition(delta, 0);
     }
 
     virtual void paint(const PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom);
     virtual bool nodeAtPoint(HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom);
 
@@ skipping 18 matching lines @@
     virtual bool isInlineFlowBox() const { return false; }
     virtual bool isInlineTextBox() const { return false; }
     virtual bool isRootInlineBox() const { return false; }
 
     virtual bool isSVGInlineTextBox() const { return false; }
     virtual bool isSVGInlineFlowBox() const { return false; }
     virtual bool isSVGRootInlineBox() const { return false; }
 
     bool hasVirtualLogicalHeight() const { return m_bitfields.hasVirtualLogicalHeight(); }
     void setHasVirtualLogicalHeight() { m_bitfields.setHasVirtualLogicalHeight(true); }
-    virtual FloatWillBeLayoutUnit virtualLogicalHeight() const
+    virtual LayoutUnit virtualLogicalHeight() const
     {
         ASSERT_NOT_REACHED();
-        return FloatWillBeLayoutUnit();
+        return LayoutUnit();
     }
 
     bool isHorizontal() const { return m_bitfields.isHorizontal(); }
     void setIsHorizontal(bool isHorizontal) { m_bitfields.setIsHorizontal(isHorizontal); }
 
-    virtual FloatRectWillBeLayoutRect calculateBoundaries() const
+    virtual LayoutRect calculateBoundaries() const
     {
         ASSERT_NOT_REACHED();
-        return FloatRectWillBeLayoutRect();
+        return LayoutRect();
     }
 
     bool isConstructed() { return m_bitfields.constructed(); }
     virtual void setConstructed() { m_bitfields.setConstructed(true); }
 
     void setExtracted(bool extracted = true) { m_bitfields.setExtracted(extracted); }
 
     void setFirstLineStyleBit(bool firstLine) { m_bitfields.setFirstLine(firstLine); }
     bool isFirstLineStyle() const { return m_bitfields.firstLine(); }
 
@@ skipping 30 matching lines @@
     {
         ASSERT(!m_hasBadParent);
         return m_parent;
     }
     void setParent(InlineFlowBox* par) { m_parent = par; }
 
     const RootInlineBox& root() const;
     RootInlineBox& root();
 
     // x() is the left side of the box in the containing block's coordinate system.
-    void setX(FloatWillBeLayoutUnit x) { m_topLeft.setX(x); }
-    FloatWillBeLayoutUnit x() const { return m_topLeft.x(); }
-    FloatWillBeLayoutUnit left() const { return m_topLeft.x(); }
+    void setX(LayoutUnit x) { m_topLeft.setX(x); }
+    LayoutUnit x() const { return m_topLeft.x(); }
+    LayoutUnit left() const { return m_topLeft.x(); }
 
     // y() is the top side of the box in the containing block's coordinate system.
-    void setY(FloatWillBeLayoutUnit y) { m_topLeft.setY(y); }
-    FloatWillBeLayoutUnit y() const { return m_topLeft.y(); }
-    FloatWillBeLayoutUnit top() const { return m_topLeft.y(); }
+    void setY(LayoutUnit y) { m_topLeft.setY(y); }
+    LayoutUnit y() const { return m_topLeft.y(); }
+    LayoutUnit top() const { return m_topLeft.y(); }
 
-    const FloatPointWillBeLayoutPoint& topLeft() const { return m_topLeft; }
+    const LayoutPoint& topLeft() const { return m_topLeft; }
 
-    FloatWillBeLayoutUnit width() const { return isHorizontal() ? logicalWidth() : hasVirtualLogicalHeight() ? virtualLogicalHeight() : logicalHeight(); }
-    FloatWillBeLayoutUnit height() const { return isHorizontal() ? hasVirtualLogicalHeight() ? virtualLogicalHeight() : logicalHeight() : logicalWidth(); }
-    FloatSizeWillBeLayoutSize size() const { return FloatSizeWillBeLayoutSize(width(), height()); }
-    FloatWillBeLayoutUnit right() const { return left() + width(); }
-    FloatWillBeLayoutUnit bottom() const { return top() + height(); }
+    LayoutUnit width() const { return isHorizontal() ? logicalWidth() : hasVirtualLogicalHeight() ? virtualLogicalHeight() : logicalHeight(); }
+    LayoutUnit height() const { return isHorizontal() ? hasVirtualLogicalHeight() ? virtualLogicalHeight() : logicalHeight() : logicalWidth(); }
+    LayoutSize size() const { return LayoutSize(width(), height()); }
+    LayoutUnit right() const { return left() + width(); }
+    LayoutUnit 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.
-    FloatWillBeLayoutUnit logicalLeft() const { return isHorizontal() ? m_topLeft.x() : m_topLeft.y(); }
-    FloatWillBeLayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); }
-    void setLogicalLeft(FloatWillBeLayoutUnit left)
+    LayoutUnit logicalLeft() const { return isHorizontal() ? m_topLeft.x() : m_topLeft.y(); }
+    LayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); }
+    void setLogicalLeft(LayoutUnit left)
     {
         if (isHorizontal())
             setX(left);
         else
             setY(left);
     }
     int pixelSnappedLogicalLeft() const { return logicalLeft(); }
-    int pixelSnappedLogicalRight() const { return ceilf(logicalRight()); }
+    int pixelSnappedLogicalRight() const { return logicalRight().ceil(); }
     int pixelSnappedLogicalTop() const { return logicalTop(); }
-    int pixelSnappedLogicalBottom() const { return ceilf(logicalBottom()); }
+    int pixelSnappedLogicalBottom() const { return logicalBottom().ceil(); }
 
     // The logicalTop[ position is the top edge of the line box in a horizontal line and the left edge in a vertical line.
-    FloatWillBeLayoutUnit logicalTop() const { return isHorizontal() ? m_topLeft.y() : m_topLeft.x(); }
-    FloatWillBeLayoutUnit logicalBottom() const { return logicalTop() + logicalHeight(); }
-    void setLogicalTop(FloatWillBeLayoutUnit top)
+    LayoutUnit logicalTop() const { return isHorizontal() ? m_topLeft.y() : m_topLeft.x(); }
+    LayoutUnit logicalBottom() const { return logicalTop() + logicalHeight(); }
+    void setLogicalTop(LayoutUnit top)
     {
         if (isHorizontal())
             setY(top);
         else
             setX(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(FloatWillBeLayoutUnit w) { m_logicalWidth = w; }
-    FloatWillBeLayoutUnit logicalWidth() const { return m_logicalWidth; }
+    void setLogicalWidth(LayoutUnit w) { m_logicalWidth = w; }
+    LayoutUnit 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.
-    FloatWillBeLayoutUnit logicalHeight() const;
+    LayoutUnit logicalHeight() const;
 
-    FloatRectWillBeLayoutRect logicalFrameRect() const { return isHorizontal() ? FloatRectWillBeLayoutRect(m_topLeft.x(), m_topLeft.y(), m_logicalWidth, logicalHeight()) : FloatRectWillBeLayoutRect(m_topLeft.y(), m_topLeft.x(), m_logicalWidth, logicalHeight()); }
+    LayoutRect logicalFrameRect() const { return isHorizontal() ? LayoutRect(m_topLeft.x(), m_topLeft.y(), m_logicalWidth, logicalHeight()) : LayoutRect(m_topLeft.y(), m_topLeft.x(), 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; }
     bool isLeftToRightDirection() const { return direction() == LTR; }
     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 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&);
+    virtual LayoutUnit placeEllipsisBox(bool ltr, LayoutUnit visibleLeftEdge, LayoutUnit visibleRightEdge, LayoutUnit ellipsisWidth, LayoutUnit &truncatedWidth, bool&);
 
 #if ENABLE(ASSERT)
     void setHasBadParent();
 #endif
 
     int expansion() const { return m_bitfields.expansion(); }
 
     bool visibleToHitTestRequest(const HitTestRequest& request) const { return layoutObject().visibleToHitTestRequest(request); }
 
     EVerticalAlign verticalAlign() const { return layoutObject().style(m_bitfields.firstLine())->verticalAlign(); }
 
     // Use with caution! The type is not checked!
     LayoutBoxModelObject* boxModelObject() const
     {
         if (!layoutObject().isText())
             return toLayoutBoxModelObject(&layoutObject());
         return 0;
     }
 
-    FloatPointWillBeLayoutPoint locationIncludingFlipping();
+    LayoutPoint locationIncludingFlipping();
 
     // Converts from a rect in the logical space of the InlineBox to one in the physical space
     // of the containing block. The logical space of an InlineBox may be transposed for vertical text and
     // flipped for right-to-left text.
     LayoutRect logicalRectToPhysicalRect(const LayoutRect&);
 
     void flipForWritingMode(FloatRect&);
     FloatPoint flipForWritingMode(const FloatPoint&);
     void flipForWritingMode(LayoutRect&);
     LayoutPoint flipForWritingMode(const LayoutPoint&);
@@ skipping 80 matching lines @@
 
     public:
         signed expansion() const { return m_expansion; }
         void setExpansion(signed expansion) { m_expansion = expansion; }
     };
 #undef ADD_BOOLEAN_BITFIELD
 
 private:
     // Converts the given (top-left) position from the logical space of the InlineBox to the physical space of the
     // containing block. The size indicates the size of the box whose point is being flipped.
-    FloatPointWillBeLayoutPoint logicalPositionToPhysicalPoint(const FloatPoint&, const FloatSize&);
+    LayoutPoint logicalPositionToPhysicalPoint(const LayoutPoint&, const LayoutSize&);
 
     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.
     LayoutObject& m_layoutObject;
 
 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); }
 
     // For InlineTextBox
     bool hasHyphen() const { return m_bitfields.hasEllipsisBoxOrHyphen(); }
     void setHasHyphen(bool hasHyphen) { m_bitfields.setHasEllipsisBoxOrHyphen(hasHyphen); }
     bool canHaveLeadingExpansion() const { return m_bitfields.hasSelectedChildrenOrCanHaveLeadingExpansion(); }
     void setCanHaveLeadingExpansion(bool canHaveLeadingExpansion) { m_bitfields.setHasSelectedChildrenOrCanHaveLeadingExpansion(canHaveLeadingExpansion); }
     signed expansion() { return m_bitfields.expansion(); }
     void setExpansion(signed expansion) { m_bitfields.setExpansion(expansion); }
 
     // For InlineFlowBox and InlineTextBox
     bool extracted() const { return m_bitfields.extracted(); }
 
-    FloatPointWillBeLayoutPoint m_topLeft;
-    FloatWillBeLayoutUnit m_logicalWidth;
+    LayoutPoint m_topLeft;
+    LayoutUnit m_logicalWidth;
 
 private:
     InlineBoxBitfields m_bitfields;
 
 #if ENABLE(ASSERT)
     bool m_hasBadParent;
 #endif
 };
 
 #if !ENABLE(ASSERT)
@@ skipping 17 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