Switch line layout to LayoutUnit.

Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 304 matching lines @@
         plainTextBuilder.append(text);
         if (textBox->nextTextBox() && textBox->nextTextBox()->start() > textBox->end() && text.length() && !text.right(1).containsOnlyWhitespace())
             plainTextBuilder.append(spaceCharacter);
     }
     return plainTextBuilder.toString();
 }
 
 void LayoutText::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
-        rects.append(enclosingIntRect(FloatRect(FloatPoint(accumulatedOffset) + box->topLeft().toFloatPoint(), box->size().toFloatSize())));
+        rects.append(enclosingIntRect(LayoutRect(LayoutPoint(accumulatedOffset) + box->topLeft(), box->size())));
 }
 
 static FloatRect localQuadForTextBox(InlineTextBox* box, unsigned start, unsigned end, bool useSelectionHeight)
 {
     unsigned realEnd = std::min(box->end() + 1, end);
     LayoutRect r = box->localSelectionRect(start, realEnd);
     if (r.height()) {
         if (!useSelectionHeight) {
             // Change the height and y position (or width and x for vertical text)
             // because selectionRect uses selection-specific values.
@@ skipping 18 matching lines @@
     // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but
     // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
     ASSERT(end == UINT_MAX || end <= INT_MAX);
     ASSERT(start <= INT_MAX);
     start = std::min(start, static_cast<unsigned>(INT_MAX));
     end = std::min(end, static_cast<unsigned>(INT_MAX));
 
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         // Note: box->end() returns the index of the last character, not the index past it
         if (start <= box->start() && box->end() < end) {
-            FloatRect r = box->calculateBoundaries().toFloatRect();
+            FloatRect r(box->calculateBoundaries());
             if (useSelectionHeight) {
                 LayoutRect selectionRect = box->localSelectionRect(start, end);
                 if (box->isHorizontal()) {
                     r.setHeight(selectionRect.height().toFloat());
                     r.setY(selectionRect.y().toFloat());
                 } else {
                     r.setWidth(selectionRect.width().toFloat());
                     r.setX(selectionRect.x().toFloat());
                 }
             }
@@ skipping 27 matching lines @@
         if (ellipsisEndPosition >= truncation && ellipsisStartPosition <= truncation)
             return ellipsis->selectionRect();
     }
 
     return IntRect();
 }
 
 void LayoutText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed, ClippingOption option) const
 {
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
-        FloatRect boundaries = box->calculateBoundaries().toFloatRect();
+        FloatRect boundaries(box->calculateBoundaries());
 
         // Shorten the width of this text box if it ends in an ellipsis.
         // FIXME: ellipsisRectForBox should switch to return FloatRect soon with the subpixellayout branch.
         IntRect ellipsisRect = (option == ClipToEllipsis) ? ellipsisRectForBox(box, 0, textLength()) : IntRect();
         if (!ellipsisRect.isEmpty()) {
             if (style()->isHorizontalWritingMode())
                 boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
             else
                 boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
         }
@@ skipping 14 matching lines @@
     // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but
     // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
     ASSERT(end == UINT_MAX || end <= INT_MAX);
     ASSERT(start <= INT_MAX);
     start = std::min(start, static_cast<unsigned>(INT_MAX));
     end = std::min(end, static_cast<unsigned>(INT_MAX));
 
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         // Note: box->end() returns the index of the last character, not the index past it
         if (start <= box->start() && box->end() < end) {
-            FloatRect r = box->calculateBoundaries().toFloatRect();
+            LayoutRect r(box->calculateBoundaries());
             if (useSelectionHeight) {
                 LayoutRect selectionRect = box->localSelectionRect(start, end);
                 if (box->isHorizontal()) {
-                    r.setHeight(selectionRect.height().toFloat());
-                    r.setY(selectionRect.y().toFloat());
+                    r.setHeight(selectionRect.height());
+                    r.setY(selectionRect.y());
                 } else {
-                    r.setWidth(selectionRect.width().toFloat());
-                    r.setX(selectionRect.x().toFloat());
+                    r.setWidth(selectionRect.width());
+                    r.setX(selectionRect.x());
                 }
             }
-            quads.append(localToAbsoluteQuad(r, 0, wasFixed));
+            quads.append(localToAbsoluteQuad(FloatRect(r), 0, wasFixed));
         } else {
             FloatRect rect = localQuadForTextBox(box, start, end, useSelectionHeight);
             if (!rect.isZero())
                 quads.append(localToAbsoluteQuad(rect, 0, wasFixed));
         }
     }
 }
 
 enum ShouldAffinityBeDownstream { AlwaysDownstream, AlwaysUpstream, UpstreamIfPositionIsNotAtStart };
 
@@ skipping 169 matching lines @@
     ASSERT(inlineBox->isInlineTextBox());
     if (!inlineBox->isInlineTextBox())
         return LayoutRect();
 
     InlineTextBox* box = toInlineTextBox(inlineBox);
 
     int height = box->root().selectionHeight();
     int top = box->root().selectionTop();
 
     // Go ahead and round left to snap it to the nearest pixel.
-    float left = box->positionForOffset(caretOffset);
+    LayoutUnit left = box->positionForOffset(caretOffset);
 
     // Distribute the caret's width to either side of the offset.
-    int caretWidthLeftOfOffset = caretWidth / 2;
+    LayoutUnit caretWidthLeftOfOffset = caretWidth() / 2;
     left -= caretWidthLeftOfOffset;
-    int caretWidthRightOfOffset = caretWidth - caretWidthLeftOfOffset;
+    LayoutUnit caretWidthRightOfOffset = caretWidth() - caretWidthLeftOfOffset;
 
-    left = roundf(left);
+    left = left.round();
 
-    float rootLeft = box->root().logicalLeft();
-    float rootRight = box->root().logicalRight();
+    LayoutUnit rootLeft = box->root().logicalLeft();
+    LayoutUnit rootRight = box->root().logicalRight();
 
     // FIXME: should we use the width of the root inline box or the
     // width of the containing block for this?
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = (box->root().logicalWidth() + rootLeft) - (left + 1);
 
     LayoutBlock* cb = containingBlock();
     const ComputedStyle& cbStyle = cb->styleRef();
 
-    float leftEdge;
-    float rightEdge;
-    leftEdge = std::min<float>(0, rootLeft);
-    rightEdge = std::max<float>(cb->logicalWidth().toFloat(), rootRight);
+    LayoutUnit leftEdge;
+    LayoutUnit rightEdge;
+    leftEdge = std::min(LayoutUnit(), rootLeft);
+    rightEdge = std::max(cb->logicalWidth(), rootRight);
 
     bool rightAligned = false;
     switch (cbStyle.textAlign()) {
     case RIGHT:
     case WEBKIT_RIGHT:
         rightAligned = true;
         break;
     case LEFT:
     case WEBKIT_LEFT:
     case CENTER:
     case WEBKIT_CENTER:
         break;
     case JUSTIFY:
     case TASTART:
         rightAligned = !cbStyle.isLeftToRightDirection();
         break;
     case TAEND:
         rightAligned = cbStyle.isLeftToRightDirection();
         break;
     }
 
     // for unicode-bidi: plaintext, use inlineBoxBidiLevel() to test the correct direction for the cursor.
     if (rightAligned && style()->unicodeBidi() == Plaintext) {
         if (inlineBox->bidiLevel()%2 != 1)
             rightAligned = false;
     }
 
     if (rightAligned) {
         left = std::max(left, leftEdge);
-        left = std::min(left, rootRight - caretWidth);
+        left = std::min(left, rootRight - caretWidth());
     } else {
         left = std::min(left, rightEdge - caretWidthRightOfOffset);
         left = std::max(left, rootLeft);
     }
 
-    return LayoutRect(style()->isHorizontalWritingMode() ? IntRect(left, top, caretWidth, height) : IntRect(top, left, height, caretWidth));
+    return LayoutRect(style()->isHorizontalWritingMode() ? IntRect(left, top, caretWidth(), height) : IntRect(top, left, height, caretWidth()));
 }
 
 ALWAYS_INLINE float LayoutText::widthFromCache(const Font& f, int start, int len, float xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
     if (style()->hasTextCombine() && isCombineText()) {
         const LayoutTextCombine* combineText = toLayoutTextCombine(this);
         if (combineText->isCombined())
             return combineText->combinedTextWidth(f);
     }
 
     TextRun run = constructTextRun(const_cast<LayoutText*>(this), f, this, start, len, styleRef(), textDirection);
     run.setCharactersLength(textLength() - start);
     ASSERT(run.charactersLength() >= run.length());
     run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
     run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
     run.setXPos(xPos);
     return f.width(run, fallbackFonts, glyphOverflow);
 }
 
-void LayoutText::trimmedPrefWidths(FloatWillBeLayoutUnit leadWidth,
-    FloatWillBeLayoutUnit& firstLineMinWidth, bool& hasBreakableStart,
-    FloatWillBeLayoutUnit& lastLineMinWidth, bool& hasBreakableEnd,
+void LayoutText::trimmedPrefWidths(LayoutUnit leadWidthLayoutUnit,
+    LayoutUnit& firstLineMinWidth, bool& hasBreakableStart,
+    LayoutUnit& lastLineMinWidth, bool& hasBreakableEnd,
     bool& hasBreakableChar, bool& hasBreak,
-    FloatWillBeLayoutUnit& firstLineMaxWidth, FloatWillBeLayoutUnit& lastLineMaxWidth,
-    FloatWillBeLayoutUnit& minWidth, FloatWillBeLayoutUnit& maxWidth, bool& stripFrontSpaces,
+    LayoutUnit& firstLineMaxWidth, LayoutUnit& lastLineMaxWidth,
+    LayoutUnit& minWidth, LayoutUnit& maxWidth, bool& stripFrontSpaces,
     TextDirection direction)
 {
     float floatMinWidth = 0.0f, floatMaxWidth = 0.0f;
 
+    // Convert leadWidth to a float here, to avoid multiple implict conversions below.
+    float leadWidth = leadWidthLayoutUnit.toFloat();
+
     bool collapseWhiteSpace = style()->collapseWhiteSpace();
     if (!collapseWhiteSpace)
         stripFrontSpaces = false;
 
     if (m_hasTab || preferredLogicalWidthsDirty())
         computePreferredLogicalWidths(leadWidth);
 
     hasBreakableStart = !stripFrontSpaces && m_hasBreakableStart;
     hasBreakableEnd = m_hasBreakableEnd;
 
     int len = textLength();
 
     if (!len || (stripFrontSpaces && text().impl()->containsOnlyWhitespace())) {
-        firstLineMinWidth = FloatWillBeLayoutUnit();
-        lastLineMinWidth = FloatWillBeLayoutUnit();
-        firstLineMaxWidth = FloatWillBeLayoutUnit();
-        lastLineMaxWidth = FloatWillBeLayoutUnit();
-        minWidth = FloatWillBeLayoutUnit();
-        maxWidth = FloatWillBeLayoutUnit();
+        firstLineMinWidth = LayoutUnit();
+        lastLineMinWidth = LayoutUnit();
+        firstLineMaxWidth = LayoutUnit();
+        lastLineMaxWidth = LayoutUnit();
+        minWidth = LayoutUnit();
+        maxWidth = LayoutUnit();
         hasBreak = false;
         return;
     }
 
     floatMinWidth = m_minWidth;
     floatMaxWidth = m_maxWidth;
 
     firstLineMinWidth = m_firstLineMinWidth;
     lastLineMinWidth = m_lastLineLineMinWidth;
 
@@ skipping 28 matching lines @@
         lastLineMaxWidth = floatMaxWidth;
         for (int i = 0; i < len; i++) {
             int linelen = 0;
             while (i + linelen < len && text[i + linelen] != newlineCharacter)
                 linelen++;
 
             if (linelen) {
                 lastLineMaxWidth = widthFromCache(f, i, linelen, leadWidth + lastLineMaxWidth, direction, 0, 0);
                 if (firstLine) {
                     firstLine = false;
-                    leadWidth = FloatWillBeLayoutUnit();
+                    leadWidth = 0.f;
                     firstLineMaxWidth = lastLineMaxWidth;
                 }
                 i += linelen;
             } else if (firstLine) {
-                firstLineMaxWidth = FloatWillBeLayoutUnit();
+                firstLineMaxWidth = LayoutUnit();
                 firstLine = false;
-                leadWidth = FloatWillBeLayoutUnit();
+                leadWidth = 0.f;
             }
 
             if (i == len - 1) {
                 // A <pre> run that ends with a newline, as in, e.g.,
                 // <pre>Some text\n\n<span>More text</pre>
-                lastLineMaxWidth = FloatWillBeLayoutUnit();
+                lastLineMaxWidth = LayoutUnit();
             }
         }
     }
 
     minWidth = LayoutUnit::fromFloatCeil(floatMinWidth);
     maxWidth = LayoutUnit::fromFloatCeil(floatMaxWidth);
 }
 
 float LayoutText::minLogicalWidth() const
 {
@@ skipping 622 matching lines @@
             m_lastTextBox = s->prevTextBox();
         else
             s->nextTextBox()->setPreviousTextBox(s->prevTextBox());
         s->destroy();
         return;
     }
 
     m_containsReversedText |= !s->isLeftToRightDirection();
 }
 
-float LayoutText::width(unsigned from, unsigned len, float xPos, TextDirection textDirection, bool firstLine, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float LayoutText::width(unsigned from, unsigned len, LayoutUnit xPos, TextDirection textDirection, bool firstLine, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
     if (from >= textLength())
         return 0;
 
     if (from + len > textLength())
         len = textLength() - from;
 
     return width(from, len, style(firstLine)->font(), xPos, textDirection, fallbackFonts, glyphOverflow);
 }
 
-float LayoutText::width(unsigned from, unsigned len, const Font& f, float xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
+float LayoutText::width(unsigned from, unsigned len, const Font& f, LayoutUnit xPos, TextDirection textDirection, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
     ASSERT(from + len <= textLength());
     if (!textLength())
         return 0;
 
     float w;
     if (&f == &style()->font()) {
         if (!style()->preserveNewline() && !from && len == textLength() && (!glyphOverflow || !glyphOverflow->computeBounds)) {
             if (fallbackFonts) {
                 ASSERT(glyphOverflow);
                 if (preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts) {
                     const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0, *fallbackFonts, *glyphOverflow);
                     // We shouldn't change our mind once we "know".
                     ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts
                         || (fallbackFonts->isEmpty() && glyphOverflow->isZero()));
                     m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts->isEmpty() && glyphOverflow->isZero();
                 }
                 w = m_maxWidth;
             } else {
                 w = maxLogicalWidth();
             }
         } else {
-            w = widthFromCache(f, from, len, xPos, textDirection, fallbackFonts, glyphOverflow);
+            w = widthFromCache(f, from, len, xPos.toFloat(), textDirection, fallbackFonts, glyphOverflow);
         }
     } else {
         TextRun run = constructTextRun(const_cast<LayoutText*>(this), f, this, from, len, styleRef(), textDirection);
         run.setCharactersLength(textLength() - from);
         ASSERT(run.charactersLength() >= run.length());
 
         run.setCodePath(canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
         run.setTabSize(!style()->collapseWhiteSpace(), style()->tabSize());
-        run.setXPos(xPos);
+        run.setXPos(xPos.toFloat());
         w = f.width(run, fallbackFonts, glyphOverflow);
     }
 
     return w;
 }
 
 IntRect LayoutText::linesBoundingBox() const
 {
     IntRect result;
 
     ASSERT(!firstTextBox() == !lastTextBox()); // Either both are null or both exist.
     if (firstTextBox() && lastTextBox()) {
         // Return the width of the minimal left side and the maximal right side.
         float logicalLeftSide = 0;
         float logicalRightSide = 0;
         for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
             if (curr == firstTextBox() || curr->logicalLeft() < logicalLeftSide)
-                logicalLeftSide = curr->logicalLeft();
+                logicalLeftSide = curr->logicalLeft().toFloat();
             if (curr == firstTextBox() || curr->logicalRight() > logicalRightSide)
-                logicalRightSide = curr->logicalRight();
+                logicalRightSide = curr->logicalRight().toFloat();
         }
 
         bool isHorizontal = style()->isHorizontalWritingMode();
 
         float x = isHorizontal ? logicalLeftSide : firstTextBox()->x().toFloat();
         float y = isHorizontal ? firstTextBox()->y().toFloat() : logicalLeftSide;
         float width = isHorizontal ? logicalRightSide - logicalLeftSide : lastTextBox()->logicalBottom() - x;
         float height = isHorizontal ? lastTextBox()->logicalBottom() - y : logicalRightSide - logicalLeftSide;
         result = enclosingIntRect(FloatRect(x, y, width, height));
     }
@@ skipping 321 matching lines @@
 }
 
 void LayoutText::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink