Removing more implicit LayoutUnit construction

third_party/WebKit/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 102 matching lines @@
     if (!isText() || !parent())
         return 0;
     if (parent()->lineLayoutItem() == lineLayoutItem().parent())
         return parent()->baselinePosition(baselineType);
     return LineLayoutBoxModel(lineLayoutItem().parent()).baselinePosition(baselineType, isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 }
 
 LayoutUnit InlineTextBox::lineHeight() const
 {
     if (!isText() || !lineLayoutItem().parent())
-        return 0;
+        return LayoutUnit();
     if (lineLayoutItem().isBR())
-        return toLayoutBR(lineLayoutItem())->lineHeight(isFirstLineStyle());
+        return LayoutUnit(toLayoutBR(lineLayoutItem())->lineHeight(isFirstLineStyle()));
     if (parent()->lineLayoutItem() == lineLayoutItem().parent())
         return parent()->lineHeight();
     return LineLayoutBoxModel(lineLayoutItem().parent()).lineHeight(isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOnContainingLine);
 }
 
 bool InlineTextBox::isSelected(int startPos, int endPos) const
 {
     int sPos = std::max(startPos - m_start, 0);
     // The position after a hard line break is considered to be past its end.
     // See the corresponding code in InlineTextBox::selectionState.
@@ skipping 100 matching lines @@
     if (sPos || ePos != static_cast<int>(m_len)) {
         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(LayoutRect(startingPoint, LayoutSize(m_logicalWidth, selHeight))));
     }
 
     LayoutUnit logicalWidth = r.width();
     if (r.x() > logicalRight())
-        logicalWidth  = 0;
+        logicalWidth = LayoutUnit();
     else if (r.maxX() > logicalRight())
         logicalWidth = logicalRight() - r.x();
 
     LayoutPoint topPoint;
     LayoutUnit width;
     LayoutUnit height;
     if (isHorizontal()) {
         topPoint = LayoutPoint(r.x(), selTop);
         width = logicalWidth;
         height = selHeight;
@@ skipping 48 matching lines @@
 
 void InlineTextBox::clearTruncation()
 {
     setTruncation(cNoTruncation);
 }
 
 LayoutUnit InlineTextBox::placeEllipsisBox(bool flowIsLTR, LayoutUnit visibleLeftEdge, LayoutUnit visibleRightEdge, LayoutUnit ellipsisWidth, LayoutUnit &truncatedWidth, bool& foundBox)
 {
     if (foundBox) {
         setTruncation(cFullTruncation);
-        return -1;
+        return LayoutUnit(-1);
     }
 
     // For LTR this is the left edge of the box, for RTL, the right edge in parent coordinates.
     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.
         setTruncation(cFullTruncation);
         foundBox = true;
-        return -1;
+        return LayoutUnit(-1);
     }
 
     bool ltrEllipsisWithinBox = flowIsLTR && (ellipsisX < logicalRight());
     bool rtlEllipsisWithinBox = !flowIsLTR && (ellipsisX > logicalLeft());
     if (ltrEllipsisWithinBox || rtlEllipsisWithinBox) {
         foundBox = true;
 
         // The inline box may have different directionality than it's parent.  Since truncation
         // behavior depends both on both the parent and the inline block's directionality, we
         // must keep track of these separately.
@@ skipping 24 matching lines @@
         // 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;
+    return LayoutUnit(-1);
 }
 
 bool InlineTextBox::isLineBreak() const
 {
     return lineLayoutItem().isBR() || (lineLayoutItem().style()->preserveNewline() && len() == 1 && (*lineLayoutItem().text().impl())[start()] == '\n');
 }
 
 bool InlineTextBox::nodeAtPoint(HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit /* lineTop */, LayoutUnit /*lineBottom*/)
 {
     if (isLineBreak() || m_truncation == cFullTruncation)
@@ skipping 79 matching lines @@
 int InlineTextBox::caretMaxOffset() const
 {
     return m_start + m_len;
 }
 
 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 LayoutUnit();
     return logicalLeft() - root().logicalLeft();
 }
 
 int InlineTextBox::offsetForPosition(LayoutUnit lineOffset, bool includePartialGlyphs) const
 {
     if (isLineBreak())
         return 0;
 
     if (lineOffset - logicalLeft() > logicalWidth())
         return isLeftToRightDirection() ? len() : 0;
@@ skipping 140 matching lines @@
     printedCharacters = fprintf(stderr, "\t%s %p", obj.name(), obj.debugPointer());
     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