Switch line layout to LayoutUnit.

Source/core/layout/line/InlineBox.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2007 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 21 matching lines @@
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 struct SameSizeAsInlineBox {
     virtual ~SameSizeAsInlineBox() { }
     void* a[4];
-    FloatPointWillBeLayoutPoint b;
-    FloatWillBeLayoutUnit c;
+    LayoutPoint b;
+    LayoutUnit c;
     uint32_t d : 32;
 #if ENABLE(ASSERT)
     bool f;
 #endif
 };
 
 static_assert(sizeof(InlineBox) == sizeof(SameSizeAsInlineBox), "InlineBox should stay small");
 
 #if ENABLE(ASSERT)
 
@@ skipping 68 matching lines @@
     printedCharacters += fprintf(stderr, "%s %p", boxName(), this);
     for (; printedCharacters < showTreeCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "\t%s %p {pos=%g,%g size=%g,%g} baseline=%i/%i\n",
         layoutObject().decoratedName().ascii().data(), &layoutObject(),
         x().toFloat(), y().toFloat(), width().toFloat(), height().toFloat(),
         baselinePosition(AlphabeticBaseline), baselinePosition(IdeographicBaseline));
 }
 #endif
 
-FloatWillBeLayoutUnit InlineBox::logicalHeight() const
+LayoutUnit InlineBox::logicalHeight() const
 {
     if (hasVirtualLogicalHeight())
         return virtualLogicalHeight();
 
     if (layoutObject().isText())
-        return m_bitfields.isText() ? FloatWillBeLayoutUnit(layoutObject().style(isFirstLineStyle())->fontMetrics().height()) : FloatWillBeLayoutUnit();
+        return m_bitfields.isText() ? LayoutUnit(layoutObject().style(isFirstLineStyle())->fontMetrics().height()) : LayoutUnit();
     if (layoutObject().isBox() && parent())
         return isHorizontal() ? toLayoutBox(layoutObject()).size().height() : toLayoutBox(layoutObject()).size().width();
 
     ASSERT(isInlineFlowBox());
     LayoutBoxModelObject* flowObject = boxModelObject();
     const FontMetrics& fontMetrics = layoutObject().style(isFirstLineStyle())->fontMetrics();
-    FloatWillBeLayoutUnit result = fontMetrics.height();
+    LayoutUnit result = fontMetrics.height();
     if (parent())
         result += flowObject->borderAndPaddingLogicalHeight();
     return result;
 }
 
 int InlineBox::baselinePosition(FontBaseline baselineType) const
 {
     return boxModelObject()->baselinePosition(baselineType, m_bitfields.firstLine(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 }
 
@@ skipping 33 matching lines @@
         toLayoutBox(layoutObject()).setInlineBoxWrapper(0);
 }
 
 void InlineBox::attachLine()
 {
     m_bitfields.setExtracted(false);
     if (layoutObject().isBox())
         toLayoutBox(layoutObject()).setInlineBoxWrapper(this);
 }
 
-void InlineBox::adjustPosition(FloatWillBeLayoutUnit dx, FloatWillBeLayoutUnit dy)
+void InlineBox::adjustPosition(LayoutUnit dx, LayoutUnit dy)
 {
     m_topLeft.move(dx, dy);
 
     if (layoutObject().isReplaced())
         toLayoutBox(layoutObject()).move(dx, dy);
 }
 
 void InlineBox::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit /* lineTop */, LayoutUnit /* lineBottom */)
 {
     // Text clips are painted only for the direct inline children of the object that has a text clip style on it, not block children.
@@ skipping 97 matching lines @@
 {
     // Non-replaced elements can always accommodate an ellipsis.
     if (!layoutObject().isReplaced())
         return true;
 
     IntRect boxRect(left(), 0, m_logicalWidth, 10);
     IntRect ellipsisRect(ltr ? blockEdge - ellipsisWidth : blockEdge, 0, ellipsisWidth, 10);
     return !(boxRect.intersects(ellipsisRect));
 }
 
-FloatWillBeLayoutUnit InlineBox::placeEllipsisBox(bool, FloatWillBeLayoutUnit, FloatWillBeLayoutUnit, FloatWillBeLayoutUnit, FloatWillBeLayoutUnit& truncatedWidth, bool&)
+LayoutUnit InlineBox::placeEllipsisBox(bool, LayoutUnit, LayoutUnit, LayoutUnit, LayoutUnit& truncatedWidth, bool&)
 {
     // Use -1 to mean "we didn't set the position."
     truncatedWidth += logicalWidth();
     return -1;
 }
 
 void InlineBox::clearKnownToHaveNoOverflow()
 {
     m_bitfields.setKnownToHaveNoOverflow(false);
     if (parent() && parent()->knownToHaveNoOverflow())
         parent()->clearKnownToHaveNoOverflow();
 }
 
-FloatPointWillBeLayoutPoint InlineBox::locationIncludingFlipping()
+LayoutPoint InlineBox::locationIncludingFlipping()
 {
-    return logicalPositionToPhysicalPoint(m_topLeft.toFloatPoint(), size().toFloatSize());
+    return logicalPositionToPhysicalPoint(m_topLeft, size());
 }
 
-FloatPointWillBeLayoutPoint InlineBox::logicalPositionToPhysicalPoint(const FloatPoint& point, const FloatSize& size)
+LayoutPoint InlineBox::logicalPositionToPhysicalPoint(const LayoutPoint& point, const LayoutSize& size)
 {
     if (!UNLIKELY(layoutObject().hasFlippedBlocksWritingMode()))
-        return FloatPointWillBeLayoutPoint(point.x(), point.y());
+        return LayoutPoint(point.x(), point.y());
 
     LayoutBlockFlow& block = root().block();
     if (block.style()->isHorizontalWritingMode())
-        return FloatPointWillBeLayoutPoint(point.x(), block.size().height() - size.height() - point.y());
+        return LayoutPoint(point.x(), block.size().height() - size.height() - point.y());
 
-    return FloatPointWillBeLayoutPoint(block.size().width() - size.width() - point.x(), point.y());
+    return LayoutPoint(block.size().width() - size.width() - point.x(), point.y());
 }
 
 LayoutRect InlineBox::logicalRectToPhysicalRect(const LayoutRect& current)
 {
     LayoutRect retval = current;
     if (!isHorizontal()) {
         retval = retval.transposedRect();
     }
-    retval.setLocation(logicalPositionToPhysicalPoint(FloatPoint(retval.location()), FloatSize(retval.size())).toLayoutPoint());
+    retval.setLocation(logicalPositionToPhysicalPoint(retval.location(), retval.size()));
     return retval;
 }
 
 void InlineBox::flipForWritingMode(FloatRect& rect)
 {
     if (!UNLIKELY(layoutObject().hasFlippedBlocksWritingMode()))
         return;
     root().block().flipForWritingMode(rect);
 }
 
@@ skipping 32 matching lines @@
 
 void showLineTree(const blink::InlineBox* b)
 {
     if (b)
         b->showLineTreeForThis();
     else
         fprintf(stderr, "Cannot showLineTree for (nil) InlineBox.\n");
 }
 
 #endif