Switch line layout to LayoutUnit.

Source/core/layout/line/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 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.
  *
@@ skipping 66 matching lines @@
     m_start = 0;
     InlineBox::markDirty();
 }
 
 LayoutRect InlineTextBox::logicalOverflowRect() const
 {
     if (knownToHaveNoOverflow() || !gTextBoxesWithOverflow) {
         // FIXME: the call to rawValue() below is temporary and should be removed once the transition
         // to LayoutUnit-based types is complete (crbug.com/321237). The call to enclosingIntRect()
         // should also likely be switched to LayoutUnit pixel-snapping.
-        return LayoutRect(enclosingIntRect(logicalFrameRect().rawValue()));
+        return LayoutRect(enclosingIntRect(logicalFrameRect()));
     }
 
     return gTextBoxesWithOverflow->get(this);
 }
 
 void InlineTextBox::setLogicalOverflowRect(const LayoutRect& rect)
 {
     ASSERT(!knownToHaveNoOverflow());
     if (!gTextBoxesWithOverflow)
         gTextBoxesWithOverflow = new InlineTextBoxOverflowMap;
@@ skipping 88 matching lines @@
 
     LayoutUnit selTop = root().selectionTop();
     LayoutUnit selHeight = root().selectionHeight();
     const ComputedStyle& styleToUse = layoutObject().styleRef(isFirstLineStyle());
     const Font& font = styleToUse.font();
 
     StringBuilder charactersWithHyphen;
     bool respectHyphen = ePos == m_len && hasHyphen();
     TextRun textRun = constructTextRun(styleToUse, font, respectHyphen ? &charactersWithHyphen : 0);
 
-    FloatPointWillBeLayoutPoint startingPoint = FloatPointWillBeLayoutPoint(logicalLeft(), selTop.toFloat());
+    LayoutPoint startingPoint = LayoutPoint(logicalLeft(), selTop.toFloat());
     LayoutRect r;
     if (sPos || ePos != static_cast<int>(m_len)) {
-        r = LayoutRect(enclosingIntRect(font.selectionRectForText(textRun, startingPoint.toFloatPoint(), selHeight, sPos, ePos)));
+        r = LayoutRect(enclosingIntRect(font.selectionRectForText(textRun, FloatPoint(startingPoint), selHeight, sPos, ePos)));
     } else { // Avoid computing the font width when the entire line box is selected as an optimization.
         // FIXME: the call to rawValue() below is temporary and should be removed once the transition
         // to LayoutUnit-based types is complete (crbug.com/321237)
-        r = LayoutRect(enclosingIntRect(FloatRectWillBeLayoutRect(startingPoint, FloatSizeWillBeLayoutSize(m_logicalWidth, selHeight.toFloat())).rawValue()));
+        r = LayoutRect(enclosingIntRect(LayoutRect(startingPoint, LayoutSize(m_logicalWidth, selHeight.toFloat()))));
     }
 
     LayoutUnit logicalWidth = r.width();
     if (r.x() > logicalRight())
         logicalWidth  = 0;
     else if (r.maxX() > logicalRight())
         logicalWidth = logicalRight() - r.x();
 
     LayoutPoint topPoint = isHorizontal() ? LayoutPoint(r.x(), selTop) : LayoutPoint(selTop, r.x());
     LayoutUnit width = isHorizontal() ? logicalWidth : selHeight;
@@ skipping 17 matching lines @@
 }
 
 void InlineTextBox::attachLine()
 {
     if (!extracted())
         return;
 
     layoutObject().attachTextBox(this);
 }
 
-FloatWillBeLayoutUnit InlineTextBox::placeEllipsisBox(bool flowIsLTR, FloatWillBeLayoutUnit visibleLeftEdge, FloatWillBeLayoutUnit visibleRightEdge, FloatWillBeLayoutUnit ellipsisWidth, FloatWillBeLayoutUnit &truncatedWidth, bool& foundBox)
+LayoutUnit InlineTextBox::placeEllipsisBox(bool flowIsLTR, LayoutUnit visibleLeftEdge, LayoutUnit visibleRightEdge, LayoutUnit ellipsisWidth, LayoutUnit &truncatedWidth, bool& foundBox)
 {
     if (foundBox) {
         m_truncation = cFullTruncation;
         return -1;
     }
 
     // For LTR this is the left edge of the box, for RTL, the right edge in parent coordinates.
-    FloatWillBeLayoutUnit ellipsisX = flowIsLTR ? visibleRightEdge - ellipsisWidth : visibleLeftEdge + ellipsisWidth;
+    LayoutUnit ellipsisX = flowIsLTR ? visibleRightEdge - ellipsisWidth : visibleLeftEdge + ellipsisWidth;
 
     // Criteria for full truncation:
     // LTR: the left edge of the ellipsis is to the left of our text run.
     // RTL: the right edge of the ellipsis is to the right of our text run.
     bool ltrFullTruncation = flowIsLTR && ellipsisX <= logicalLeft();
     bool rtlFullTruncation = !flowIsLTR && ellipsisX >= logicalLeft() + logicalWidth();
     if (ltrFullTruncation || rtlFullTruncation) {
         // Too far.  Just set full truncation, but return -1 and let the ellipsis just be placed at the edge of the box.
         m_truncation = cFullTruncation;
         foundBox = true;
@@ skipping 22 matching lines @@
             m_truncation = cFullTruncation;
             truncatedWidth += ellipsisWidth;
             return std::min(ellipsisX, logicalLeft());
         }
 
         // Set the truncation index on the text run.
         m_truncation = offset;
 
         // If we got here that means that we were only partially truncated and we need to return the pixel offset at which
         // to place the ellipsis.
-        FloatWillBeLayoutUnit widthOfVisibleText = layoutObject().width(m_start, offset, textPos(), flowIsLTR ? LTR : RTL, isFirstLineStyle());
+        LayoutUnit widthOfVisibleText = layoutObject().width(m_start, offset, textPos(), flowIsLTR ? LTR : RTL, isFirstLineStyle());
 
         // The ellipsis needs to be placed just after the last visible character.
         // Where "after" is defined by the flow directionality, not the inline
         // box directionality.
         // e.g. In the case of an LTR inline box truncated in an RTL flow then we can
         // have a situation such as |Hello| -> |...He|
         truncatedWidth += widthOfVisibleText + ellipsisWidth;
         if (flowIsLTR)
             return logicalLeft() + widthOfVisibleText;
         return logicalRight() - widthOfVisibleText - ellipsisWidth;
     }
     truncatedWidth += logicalWidth();
     return -1;
 }
 
 bool InlineTextBox::isLineBreak() const
 {
     return layoutObject().isBR() || (layoutObject().style()->preserveNewline() && len() == 1 && (*layoutObject().text().impl())[start()] == '\n');
 }
 
 bool InlineTextBox::nodeAtPoint(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/)
 {
     if (isLineBreak())
         return false;
 
-    FloatPointWillBeLayoutPoint boxOrigin = locationIncludingFlipping();
+    LayoutPoint boxOrigin = locationIncludingFlipping();
     boxOrigin.moveBy(accumulatedOffset);
-    FloatRectWillBeLayoutRect rect(boxOrigin, size());
+    LayoutRect rect(boxOrigin, size());
     // FIXME: both calls to rawValue() below is temporary and should be removed once the transition
     // to LayoutUnit-based types is complete (crbug.com/321237)
-    if (m_truncation != cFullTruncation && visibleToHitTestRequest(result.hitTestRequest()) && locationInContainer.intersects(rect.rawValue())) {
+    if (m_truncation != cFullTruncation && visibleToHitTestRequest(result.hitTestRequest()) && locationInContainer.intersects(rect)) {
         layoutObject().updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(accumulatedOffset)));
-        if (!result.addNodeToListBasedTestResult(layoutObject().node(), locationInContainer, rect.rawValue()))
+        if (!result.addNodeToListBasedTestResult(layoutObject().node(), locationInContainer, rect))
             return true;
     }
     return false;
 }
 
 bool InlineTextBox::getEmphasisMarkPosition(const ComputedStyle& style, TextEmphasisPosition& emphasisPosition) const
 {
     // This function returns true if there are text emphasis marks and they are suppressed by ruby text.
     if (style.textEmphasisMark() == TextEmphasisMarkNone)
         return false;
@@ skipping 31 matching lines @@
         if (layoutObject().selectionState() == LayoutObject::SelectionStart)
             endPos = layoutObject().textLength();
         else if (layoutObject().selectionState() == LayoutObject::SelectionEnd)
             startPos = 0;
     }
 
     sPos = std::max(startPos - m_start, 0);
     ePos = std::min(endPos - m_start, (int)m_len);
 }
 
-void InlineTextBox::paintDocumentMarker(GraphicsContext* pt, const FloatPointWillBeLayoutPoint& boxOrigin, DocumentMarker* marker, const ComputedStyle& style, const Font& font, bool grammar)
+void InlineTextBox::paintDocumentMarker(GraphicsContext* pt, const LayoutPoint& boxOrigin, DocumentMarker* marker, const ComputedStyle& style, const Font& font, bool grammar)
 {
-    InlineTextBoxPainter(*this).paintDocumentMarker(pt, boxOrigin.toFloatPoint(), marker, style, font, grammar);
+    InlineTextBoxPainter(*this).paintDocumentMarker(pt, boxOrigin, marker, style, font, grammar);
 }
 
-void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, const FloatPointWillBeLayoutPoint& boxOrigin, DocumentMarker* marker, const ComputedStyle& style, const Font& font)
+void InlineTextBox::paintTextMatchMarker(GraphicsContext* pt, const LayoutPoint& boxOrigin, DocumentMarker* marker, const ComputedStyle& style, const Font& font)
 {
-    InlineTextBoxPainter(*this).paintTextMatchMarker(pt, boxOrigin.toFloatPoint(), marker, style, font);
+    InlineTextBoxPainter(*this).paintTextMatchMarker(pt, boxOrigin, marker, style, font);
 }
 
 int InlineTextBox::caretMinOffset() const
 {
     return m_start;
 }
 
 int InlineTextBox::caretMaxOffset() const
 {
     return m_start + m_len;
 }
 
-FloatWillBeLayoutUnit InlineTextBox::textPos() const
+LayoutUnit InlineTextBox::textPos() const
 {
     // When computing the width of a text run, LayoutBlock::computeInlineDirectionPositionsForLine() doesn't include the actual offset
     // from the containing block edge in its measurement. textPos() should be consistent so the text are laid out in the same width.
     if (logicalLeft() == 0)
         return 0;
     return logicalLeft() - root().logicalLeft();
 }
 
-int InlineTextBox::offsetForPosition(FloatWillBeLayoutUnit lineOffset, bool includePartialGlyphs) const
+int InlineTextBox::offsetForPosition(LayoutUnit lineOffset, bool includePartialGlyphs) const
 {
     if (isLineBreak())
         return 0;
 
     if (lineOffset - logicalLeft() > logicalWidth())
         return isLeftToRightDirection() ? len() : 0;
     if (lineOffset - logicalLeft() < 0)
         return isLeftToRightDirection() ? 0 : len();
 
     LayoutText& text = layoutObject();
     const ComputedStyle& style = text.styleRef(isFirstLineStyle());
     const Font& font = style.font();
-    return font.offsetForPosition(constructTextRun(style, font), lineOffset - logicalLeft(), includePartialGlyphs);
+    return font.offsetForPosition(constructTextRun(style, font), (lineOffset - logicalLeft()).toFloat(), includePartialGlyphs);
 }
 
-FloatWillBeLayoutUnit InlineTextBox::positionForOffset(int offset) const
+LayoutUnit InlineTextBox::positionForOffset(int offset) const
 {
     ASSERT(offset >= m_start);
     ASSERT(offset <= m_start + m_len);
 
     if (isLineBreak())
         return logicalLeft();
 
     LayoutText& text = layoutObject();
     const ComputedStyle& styleToUse = text.styleRef(isFirstLineStyle());
     const Font& font = styleToUse.font();
@@ skipping 20 matching lines @@
         return false;
 
     // Offsets at the end are "out" for line breaks (they are on the next line).
     if (isLineBreak())
         return false;
 
     // Offsets at the end are "in" for normal boxes (but the caller has to check affinity).
     return true;
 }
 
-void InlineTextBox::characterWidths(Vector<FloatWillBeLayoutUnit>& widths) const
+void InlineTextBox::characterWidths(Vector<float>& widths) const
 {
     FontCachePurgePreventer fontCachePurgePreventer;
 
     const ComputedStyle& styleToUse = layoutObject().styleRef(isFirstLineStyle());
     const Font& font = styleToUse.font();
 
     TextRun textRun = constructTextRun(styleToUse, font);
 
     SimpleShaper shaper(&font, textRun);
-    FloatWillBeLayoutUnit lastWidth;
+    float lastWidth = 0;
     widths.resize(m_len);
     for (unsigned i = 0; i < m_len; i++) {
         shaper.advance(i + 1);
         widths[i] = shaper.runWidthSoFar() - lastWidth;
         lastWidth = shaper.runWidthSoFar();
     }
 }
 
 TextRun InlineTextBox::constructTextRun(const ComputedStyle& style, const Font& font, StringBuilder* charactersWithHyphen) const
 {
@@ skipping 15 matching lines @@
         const AtomicString& hyphenString = style.hyphenString();
         charactersWithHyphen->reserveCapacity(string.length() + hyphenString.length());
         charactersWithHyphen->append(string);
         charactersWithHyphen->append(hyphenString);
         string = charactersWithHyphen->toString().createView();
         maximumLength = string.length();
     }
 
     ASSERT(maximumLength >= static_cast<int>(string.length()));
 
-    TextRun run(string, textPos(), expansion(), expansionBehavior(), direction(), dirOverride() || style.rtlOrdering() == VisualOrder, !layoutObject().canUseSimpleFontCodePath());
+    TextRun run(string, textPos().toFloat(), expansion(), expansionBehavior(), direction(), dirOverride() || style.rtlOrdering() == VisualOrder, !layoutObject().canUseSimpleFontCodePath());
     run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
     run.setCodePath(layoutObject().canUseSimpleFontCodePath() ? TextRun::ForceSimple : TextRun::ForceComplex);
     run.setTextJustify(style.textJustify());
 
     // Propagate the maximum length of the characters buffer to the TextRun, even when we're only processing a substring.
     run.setCharactersLength(maximumLength);
     ASSERT(run.charactersLength() >= run.length());
     return run;
 }
 
@@ skipping 31 matching lines @@
     printedCharacters = fprintf(stderr, "\t%s %p", obj.name(), &obj);
     const int layoutObjectCharacterOffset = 75;
     for (; printedCharacters < layoutObjectCharacterOffset; printedCharacters++)
         fputc(' ', stderr);
     fprintf(stderr, "(%d,%d) \"%s\"\n", start(), start() + len(), value.utf8().data());
 }
 
 #endif
 
 } // namespace blink