More explicit LayoutUnit conversions

third_party/WebKit/Source/core/layout/line/RootInlineBox.cpp

 /*
  * Copyright (C) 2003, 2006, 2008 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 176 matching lines @@
     for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == box->lineLayoutItem(); prev = prev->prevRootBox()) {
         prev->setLineBreakInfo(0, 0, BidiStatus());
         prev->markDirty();
     }
 }
 
 LayoutUnit RootInlineBox::alignBoxesInBlockDirection(LayoutUnit heightOfBlock, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache)
 {
     // SVG will handle vertical alignment on its own.
     if (isSVGRootInlineBox())
-        return 0;
+        return LayoutUnit();
 
     LayoutUnit maxPositionTop;
     LayoutUnit maxPositionBottom;
     int maxAscent = 0;
     int maxDescent = 0;
     bool setMaxAscent = false;
     bool setMaxDescent = false;
 
     // Figure out if we're in no-quirks mode.
     bool noQuirksMode = lineLayoutItem().document().inNoQuirksMode();
 
     m_baselineType = dominantBaseline();
 
     computeLogicalBoxHeights(this, maxPositionTop, maxPositionBottom, maxAscent, maxDescent, setMaxAscent, setMaxDescent, noQuirksMode, textBoxDataMap, baselineType(), verticalPositionCache);
 
     if (maxAscent + maxDescent < std::max(maxPositionTop, maxPositionBottom))
         adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
 
-    LayoutUnit maxHeight = maxAscent + maxDescent;
+    LayoutUnit maxHeight = LayoutUnit(maxAscent + maxDescent);
     LayoutUnit lineTop = heightOfBlock;
     LayoutUnit lineBottom = heightOfBlock;
     LayoutUnit lineTopIncludingMargins = heightOfBlock;
     LayoutUnit lineBottomIncludingMargins = heightOfBlock;
     LayoutUnit selectionBottom = heightOfBlock;
     bool setLineTop = false;
     bool hasAnnotationsBefore = false;
     bool hasAnnotationsAfter = false;
     placeBoxesInBlockDirection(heightOfBlock, maxHeight, maxAscent, noQuirksMode, lineTop, lineBottom, selectionBottom, setLineTop, lineTopIncludingMargins, lineBottomIncludingMargins, hasAnnotationsBefore, hasAnnotationsAfter, baselineType());
     m_hasAnnotationsBefore = hasAnnotationsBefore;
@@ skipping 370 matching lines @@
 }
 
 LayoutUnit RootInlineBox::verticalPositionForBox(InlineBox* box, VerticalPositionCache& verticalPositionCache)
 {
     if (box->lineLayoutItem().isText())
         return box->parent()->logicalTop();
 
     LineLayoutBoxModel boxModel = box->boxModelObject();
     ASSERT(boxModel.isInline());
     if (!boxModel.isInline())
-        return 0;
+        return LayoutUnit();
 
     // This method determines the vertical position for inline elements.
     bool firstLine = isFirstLineStyle();
     if (firstLine && !boxModel.document().styleEngine().usesFirstLineRules())
         firstLine = false;
 
     // Check the cache.
     bool isLayoutInline = boxModel.isLayoutInline();
     if (isLayoutInline && !firstLine) {
-        LayoutUnit verticalPosition = verticalPositionCache.get(boxModel, baselineType());
+        LayoutUnit verticalPosition = LayoutUnit(verticalPositionCache.get(boxModel, baselineType()));
         if (verticalPosition != PositionUndefined)
             return verticalPosition;
     }
 
     LayoutUnit verticalPosition;
     EVerticalAlign verticalAlign = boxModel.style()->verticalAlign();
     if (verticalAlign == TOP || verticalAlign == BOTTOM)
-        return 0;
+        return LayoutUnit();
 
     LineLayoutItem parent = boxModel.parent();
     if (parent.isLayoutInline() && parent.style()->verticalAlign() != TOP && parent.style()->verticalAlign() != BOTTOM)
         verticalPosition = box->parent()->logicalTop();
 
     if (verticalAlign != BASELINE) {
         const Font& font = parent.style(firstLine)->font();
         const FontMetrics& fontMetrics = font.fontMetrics();
         int fontSize = font.fontDescription().computedPixelSize();
 
         LineDirectionMode lineDirection = parent.isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
 
         if (verticalAlign == SUB) {
             verticalPosition += fontSize / 5 + 1;
         } else if (verticalAlign == SUPER) {
             verticalPosition -= fontSize / 3 + 1;
         } else if (verticalAlign == TEXT_TOP) {
             verticalPosition += boxModel.baselinePosition(baselineType(), firstLine, lineDirection) - fontMetrics.ascent(baselineType());
         } else if (verticalAlign == MIDDLE) {
-            verticalPosition = (verticalPosition - static_cast<LayoutUnit>(fontMetrics.xHeight() / 2) - boxModel.lineHeight(firstLine, lineDirection) / 2 + boxModel.baselinePosition(baselineType(), firstLine, lineDirection)).round();
+            verticalPosition = LayoutUnit((verticalPosition - LayoutUnit(fontMetrics.xHeight() / 2)
+                - boxModel.lineHeight(firstLine, lineDirection) / 2
+                + boxModel.baselinePosition(baselineType(), firstLine, lineDirection)).round());
         } else if (verticalAlign == TEXT_BOTTOM) {
             verticalPosition += fontMetrics.descent(baselineType());
             // lineHeight - baselinePosition is always 0 for replaced elements (except inline blocks), so don't bother wasting time in that case.
             if (!boxModel.isAtomicInlineLevel() || boxModel.isInlineBlockOrInlineTable())
                 verticalPosition -= (boxModel.lineHeight(firstLine, lineDirection) - boxModel.baselinePosition(baselineType(), firstLine, lineDirection));
         } else if (verticalAlign == BASELINE_MIDDLE) {
             verticalPosition += -boxModel.lineHeight(firstLine, lineDirection) / 2 + boxModel.baselinePosition(baselineType(), firstLine, lineDirection);
         } else if (verticalAlign == LENGTH) {
             LayoutUnit lineHeight;
             // Per http://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align: 'Percentages: refer to the 'line-height' of the element itself'.
             if (boxModel.style()->verticalAlignLength().hasPercent())
-                lineHeight = boxModel.style()->computedLineHeight();
+                lineHeight = LayoutUnit(boxModel.style()->computedLineHeight());
             else
                 lineHeight = boxModel.lineHeight(firstLine, lineDirection);
             verticalPosition -= valueForLength(boxModel.style()->verticalAlignLength(), lineHeight);
         }
     }
 
     // Store the cached value.
     if (isLayoutInline && !firstLine)
         verticalPositionCache.set(boxModel, baselineType(), verticalPosition);
 
@@ skipping 32 matching lines @@
     endBox = nullptr;
     return nullptr;
 }
 
 const char* RootInlineBox::boxName() const
 {
     return "RootInlineBox";
 }
 
 } // namespace blink