Switch line layout to LayoutUnit.

Source/core/layout/LayoutInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * 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.
  *
@@ skipping 257 matching lines @@
     ASSERT_UNUSED(inlineBox, !inlineBox);
 
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = 0;
 
     LayoutRect caretRect = localCaretRectForEmptyElement(borderAndPaddingWidth(), 0);
 
     if (InlineBox* firstBox = firstLineBox()) {
         // FIXME: the call to roundedLayoutPoint() below is temporary and should be removed once
         // the transition to LayoutUnit-based types is complete (crbug.com/321237)
-        caretRect.moveBy(firstBox->topLeft().roundedLayoutPoint());
+        caretRect.moveBy(firstBox->topLeft());
     }
 
     return caretRect;
 }
 
 void LayoutInline::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     if (continuation())
         return addChildToContinuation(newChild, beforeChild);
     return addChildIgnoringContinuation(newChild, beforeChild);
@@ skipping 265 matching lines @@
     InlinePainter(*this).paint(paintInfo, paintOffset);
 }
 
 template<typename GeneratorContext>
 void LayoutInline::generateLineBoxRects(GeneratorContext& yield) const
 {
     if (!alwaysCreateLineBoxes()) {
         generateCulledLineBoxRects(yield, this);
     } else if (InlineFlowBox* curr = firstLineBox()) {
         for (; curr; curr = curr->nextLineBox())
-            yield(FloatRect(curr->topLeft().toFloatPoint(), curr->size().toFloatSize()));
+            yield(LayoutRect(curr->topLeft(), curr->size()));
     } else {
-        yield(FloatRect());
+        yield(LayoutRect());
     }
 }
 
 template<typename GeneratorContext>
 void LayoutInline::generateCulledLineBoxRects(GeneratorContext& yield, const LayoutInline* container) const
 {
     if (!culledInlineFirstLineBox()) {
-        yield(FloatRect());
+        yield(LayoutRect());
         return;
     }
 
     bool isHorizontal = style()->isHorizontalWritingMode();
 
     for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
         // direction (aligned to the root box's baseline).
         if (curr->isBox()) {
             LayoutBox* currBox = toLayoutBox(curr);
             if (currBox->inlineBoxWrapper()) {
                 RootInlineBox& rootBox = currBox->inlineBoxWrapper()->root();
                 int logicalTop = rootBox.logicalTop() + (rootBox.layoutObject().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
                 int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
                 if (isHorizontal)
-                    yield(FloatRect(currBox->inlineBoxWrapper()->x() - currBox->marginLeft(), logicalTop, (currBox->size().width() + currBox->marginWidth()).toFloat(), logicalHeight));
+                    yield(LayoutRect(currBox->inlineBoxWrapper()->x() - currBox->marginLeft(), logicalTop, currBox->size().width() + currBox->marginWidth(), logicalHeight));
                 else
-                    yield(FloatRect(logicalTop, currBox->inlineBoxWrapper()->y() - currBox->marginTop(), logicalHeight, (currBox->size().height() + currBox->marginHeight()).toFloat()));
+                    yield(LayoutRect(logicalTop, currBox->inlineBoxWrapper()->y() - currBox->marginTop(), logicalHeight, currBox->size().height() + currBox->marginHeight()));
             }
         } else if (curr->isLayoutInline()) {
             // If the child doesn't need line boxes either, then we can recur.
             LayoutInline* currInline = toLayoutInline(curr);
             if (!currInline->alwaysCreateLineBoxes()) {
                 currInline->generateCulledLineBoxRects(yield, container);
             } else {
                 for (InlineFlowBox* childLine = currInline->firstLineBox(); childLine; childLine = childLine->nextLineBox()) {
                     RootInlineBox& rootBox = childLine->root();
                     int logicalTop = rootBox.logicalTop() + (rootBox.layoutObject().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
                     int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
                     if (isHorizontal) {
-                        yield(FloatRect(childLine->x() - childLine->marginLogicalLeft(),
+                        yield(LayoutRect(childLine->x() - childLine->marginLogicalLeft(),
                             logicalTop,
                             childLine->logicalWidth() + childLine->marginLogicalLeft() + childLine->marginLogicalRight(),
                             logicalHeight));
                     } else {
-                        yield(FloatRect(logicalTop,
+                        yield(LayoutRect(logicalTop,
                             childLine->y() - childLine->marginLogicalLeft(),
                             logicalHeight,
                             childLine->logicalWidth() + childLine->marginLogicalLeft() + childLine->marginLogicalRight()));
                     }
                 }
             }
         } else if (curr->isText()) {
             LayoutText* currText = toLayoutText(curr);
             for (InlineTextBox* childText = currText->firstTextBox(); childText; childText = childText->nextTextBox()) {
                 RootInlineBox& rootBox = childText->root();
                 int logicalTop = rootBox.logicalTop() + (rootBox.layoutObject().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
                 int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
                 if (isHorizontal)
-                    yield(FloatRect(childText->x(), logicalTop, childText->logicalWidth(), logicalHeight));
+                    yield(LayoutRect(childText->x(), logicalTop, childText->logicalWidth(), logicalHeight));
                 else
-                    yield(FloatRect(logicalTop, childText->y(), logicalHeight, childText->logicalWidth()));
+                    yield(LayoutRect(logicalTop, childText->y(), logicalHeight, childText->logicalWidth()));
             }
         }
     }
 }
 
 namespace {
 
 class AbsoluteRectsGeneratorContext {
 public:
     AbsoluteRectsGeneratorContext(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset)
         : m_rects(rects)
         , m_accumulatedOffset(accumulatedOffset) { }
 
-    void operator()(const FloatRect& rect)
+    void operator()(const LayoutRect& rect)
     {
         IntRect intRect = enclosingIntRect(rect);
         intRect.move(m_accumulatedOffset.x(), m_accumulatedOffset.y());
         m_rects.append(intRect);
     }
 private:
     Vector<IntRect>& m_rects;
     const LayoutPoint& m_accumulatedOffset;
 };
 
@@ skipping 43 matching lines @@
     generateLineBoxRects(context);
 
     if (const LayoutBoxModelObject* continuation = this->continuation())
         continuation->absoluteQuads(quads, wasFixed);
 }
 
 LayoutUnit LayoutInline::offsetLeft() const
 {
     LayoutPoint topLeft;
     if (InlineBox* firstBox = firstLineBoxIncludingCulling()) {
-        // FIXME: the call to flooredLayoutPoint() below is temporary and should be removed once
-        // the transition to LayoutUnit-based types is complete (crbug.com/321237)
-        topLeft = firstBox->topLeft().flooredLayoutPoint();
+        topLeft = firstBox->topLeft();
     }
     return adjustedPositionRelativeToOffsetParent(topLeft).x();
 }
 
 LayoutUnit LayoutInline::offsetTop() const
 {
     LayoutPoint topLeft;
     if (InlineBox* firstBox = firstLineBoxIncludingCulling()) {
-        // FIXME: the call to flooredLayoutPoint() below is temporary and should be removed once
-        // the transition to LayoutUnit-based types is complete (crbug.com/321237)
-        topLeft = firstBox->topLeft().flooredLayoutPoint();
+        topLeft = firstBox->topLeft();
     }
     return adjustedPositionRelativeToOffsetParent(topLeft).y();
 }
 
 static LayoutUnit computeMargin(const LayoutInline* layoutObject, const Length& margin)
 {
     if (margin.isFixed())
         return margin.value();
     if (margin.hasPercent())
         return minimumValueForLength(margin, std::max(LayoutUnit(), layoutObject->containingBlock()->availableLogicalWidth()));
@@ skipping 141 matching lines @@
     }
 
     IntRect result;
 
     // See <rdar://problem/5289721>, for an unknown reason the linked list here is sometimes inconsistent, first is non-zero and last is zero.  We have been
     // unable to reproduce this at all (and consequently unable to figure ot why this is happening).  The assert will hopefully catch the problem in debug
     // builds and help us someday figure out why.  We also put in a redundant check of lastLineBox() to avoid the crash for now.
     ASSERT(!firstLineBox() == !lastLineBox()); // Either both are null or both exist.
     if (firstLineBox() && lastLineBox()) {
         // Return the width of the minimal left side and the maximal right side.
-        float logicalLeftSide = 0;
-        float logicalRightSide = 0;
+        LayoutUnit logicalLeftSide = 0;
+        LayoutUnit logicalRightSide = 0;
         for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
             if (curr == firstLineBox() || curr->logicalLeft() < logicalLeftSide)
                 logicalLeftSide = curr->logicalLeft();
             if (curr == firstLineBox() || curr->logicalRight() > logicalRightSide)
                 logicalRightSide = curr->logicalRight();
         }
 
         bool isHorizontal = style()->isHorizontalWritingMode();
 
-        float x = isHorizontal ? logicalLeftSide : firstLineBox()->x().toFloat();
-        float y = isHorizontal ? firstLineBox()->y().toFloat() : logicalLeftSide;
-        float width = isHorizontal ? logicalRightSide - logicalLeftSide : lastLineBox()->logicalBottom() - x;
-        float height = isHorizontal ? lastLineBox()->logicalBottom() - y : logicalRightSide - logicalLeftSide;
-        result = enclosingIntRect(FloatRect(x, y, width, height));
+        LayoutUnit x = isHorizontal ? logicalLeftSide : firstLineBox()->x();
+        LayoutUnit y = isHorizontal ? firstLineBox()->y() : logicalLeftSide;
+        LayoutUnit width = isHorizontal ? logicalRightSide - logicalLeftSide : lastLineBox()->logicalBottom() - x;
+        LayoutUnit height = isHorizontal ? lastLineBox()->logicalBottom() - y : logicalRightSide - logicalLeftSide;
+        result = enclosingIntRect(LayoutRect(x, y, width, height));
     }
 
     return result;
 }
 
 InlineBox* LayoutInline::culledInlineFirstLineBox() const
 {
     for (LayoutObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
@@ skipping 419 matching lines @@
         return LayoutSize();
 
     // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
     // box from the rest of the content, but only in the cases where we know we're positioned
     // relative to the inline itself.
 
     LayoutSize logicalOffset;
     LayoutUnit inlinePosition;
     LayoutUnit blockPosition;
     if (firstLineBox()) {
-        inlinePosition = LayoutUnit::fromFloatRound(firstLineBox()->logicalLeft());
+        inlinePosition = firstLineBox()->logicalLeft();
         blockPosition = firstLineBox()->logicalTop();
     } else {
         inlinePosition = layer()->staticInlinePosition();
         blockPosition = layer()->staticBlockPosition();
     }
 
     // Per http://www.w3.org/TR/CSS2/visudet.html#abs-non-replaced-width an absolute positioned box
     // with a static position should locate itself as though it is a normal flow box in relation to
     // its containing block. If this relative-positioned inline has a negative offset we need to
     // compensate for it so that we align the positioned object with the edge of its containing block.
@@ skipping 101 matching lines @@
 }
 
 void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink