Removing more implicit LayoutUnit construction

third_party/WebKit/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 227 matching lines @@
         // FIXME: need to figure out how to make this return a valid rect, note that
         // there are no line boxes created in the above case.
         return LayoutRect();
     }
 
     ASSERT_UNUSED(inlineBox, !inlineBox);
 
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = LayoutUnit();
 
-    LayoutRect caretRect = localCaretRectForEmptyElement(borderAndPaddingWidth(), 0);
+    LayoutRect caretRect = localCaretRectForEmptyElement(borderAndPaddingWidth(), LayoutUnit());
 
     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());
     }
 
     return caretRect;
 }
 
@@ skipping 296 matching lines @@
     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.lineLayoutItem().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
-                int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
+                LayoutUnit logicalTop = rootBox.logicalTop() + (rootBox.lineLayoutItem().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
+                LayoutUnit logicalHeight(container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height());
                 if (isHorizontal) {
                     yield(LayoutRect(LayoutUnit(currBox->inlineBoxWrapper()->x() - currBox->marginLeft()), LayoutUnit(logicalTop),
                         LayoutUnit(currBox->size().width() + currBox->marginWidth()), LayoutUnit(logicalHeight)));
                 } else {
                     yield(LayoutRect(LayoutUnit(logicalTop), LayoutUnit(currBox->inlineBoxWrapper()->y() - currBox->marginTop()),
                         LayoutUnit(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.lineLayoutItem().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
-                    int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
+                    LayoutUnit logicalTop = rootBox.logicalTop() + (rootBox.lineLayoutItem().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
+                    LayoutUnit logicalHeight(container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height());
                     if (isHorizontal) {
                         yield(LayoutRect(LayoutUnit(childLine->x() - childLine->marginLogicalLeft()),
-                            LayoutUnit(logicalTop),
+                            logicalTop,
                             LayoutUnit(childLine->logicalWidth() + childLine->marginLogicalLeft() + childLine->marginLogicalRight()),
-                            LayoutUnit(logicalHeight)));
+                            logicalHeight));
                     } else {
-                        yield(LayoutRect(LayoutUnit(logicalTop),
+                        yield(LayoutRect(logicalTop,
                             LayoutUnit(childLine->y() - childLine->marginLogicalLeft()),
-                            LayoutUnit(logicalHeight),
+                            logicalHeight,
                             LayoutUnit(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.lineLayoutItem().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
-                int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
+                LayoutUnit logicalTop = LayoutUnit(rootBox.logicalTop()
+                    + (rootBox.lineLayoutItem().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent()
+                    - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent()));
+                LayoutUnit logicalHeight(container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height());
                 if (isHorizontal)
                     yield(LayoutRect(childText->x(), logicalTop, childText->logicalWidth(), logicalHeight));
                 else
                     yield(LayoutRect(logicalTop, childText->y(), logicalHeight, childText->logicalWidth()));
             }
         }
     }
 }
 
 namespace {
@@ skipping 86 matching lines @@
     LayoutPoint topLeft;
     if (InlineBox* firstBox = firstLineBoxIncludingCulling()) {
         topLeft = firstBox->topLeft();
     }
     return adjustedPositionRelativeToOffsetParent(topLeft).y();
 }
 
 static LayoutUnit computeMargin(const LayoutInline* layoutObject, const Length& margin)
 {
     if (margin.isFixed())
-        return margin.value();
+        return LayoutUnit(margin.value());
     if (margin.hasPercent())
         return minimumValueForLength(margin, std::max(LayoutUnit(), layoutObject->containingBlock()->availableLogicalWidth()));
     return LayoutUnit();
 }
 
 LayoutRectOutsets LayoutInline::marginBoxOutsets() const
 {
     return LayoutRectOutsets(marginTop(), marginRight(), marginBottom(), marginLeft());
 }
 
@@ skipping 334 matching lines @@
     if (overflowRect.isEmpty())
         return overflowRect;
 
     mapToVisibleRectInAncestorSpace(paintInvalidationContainer, overflowRect, paintInvalidationState);
     return overflowRect;
 }
 
 LayoutRect LayoutInline::visualOverflowRect() const
 {
     LayoutRect overflowRect = linesVisualOverflowBoundingBox();
-    LayoutUnit outlineOutset = style()->outlineOutsetExtent();
+    LayoutUnit outlineOutset(style()->outlineOutsetExtent());
     if (outlineOutset) {
         Vector<LayoutRect> rects;
         // We have already included outline extents of line boxes in linesVisualOverflowBoundingBox(),
         // so the following just add outline rects for children and continuations.
         addOutlineRectsForChildrenAndContinuations(rects, LayoutPoint(), outlineRectsShouldIncludeBlockVisualOverflow());
         if (!rects.isEmpty()) {
             LayoutRect outlineRect = unionRectEvenIfEmpty(rects);
             outlineRect.inflate(outlineOutset);
             overflowRect.unite(outlineRect);
         }
@@ skipping 209 matching lines @@
     InlineFlowBox* flowBox = createInlineFlowBox();
     m_lineBoxes.appendLineBox(flowBox);
     return flowBox;
 }
 
 LayoutUnit LayoutInline::lineHeight(bool firstLine, LineDirectionMode /*direction*/, LinePositionMode /*linePositionMode*/) const
 {
     if (firstLine && document().styleEngine().usesFirstLineRules()) {
         const ComputedStyle* s = style(firstLine);
         if (s != style())
-            return s->computedLineHeight();
+            return LayoutUnit(s->computedLineHeight());
     }
 
-    return style()->computedLineHeight();
+    return LayoutUnit(style()->computedLineHeight());
 }
 
 int LayoutInline::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
 {
     ASSERT(linePositionMode == PositionOnContainingLine);
     const FontMetrics& fontMetrics = style(firstLine)->fontMetrics();
     return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
 }
 
 LayoutSize LayoutInline::offsetForInFlowPositionedInline(const LayoutBox& child) const
@@ skipping 108 matching lines @@
 
     AnnotatedRegionValue region;
     region.draggable = style()->getDraggableRegionMode() == DraggableRegionDrag;
     region.bounds = LayoutRect(linesBoundingBox());
 
     LayoutObject* container = containingBlock();
     if (!container)
         container = this;
 
     FloatPoint absPos = container->localToAbsolute();
-    region.bounds.setX(absPos.x() + region.bounds.x());
-    region.bounds.setY(absPos.y() + region.bounds.y());
+    region.bounds.setX(LayoutUnit(absPos.x() + region.bounds.x()));
+    region.bounds.setY(LayoutUnit(absPos.y() + region.bounds.y()));
 
     regions.append(region);
 }
 
 void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason);
 
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box, invalidationReason);
 }
 
 } // namespace blink