Disallow cast/implicit conversion from LayoutUnit to int/unsigned

third_party/WebKit/Source/core/layout/LayoutBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 1419 matching lines @@
     // just like a block.
     if (isAtomicInlineLevel() && linePositionMode == PositionOnContainingLine)
         return LayoutBox::lineHeight(firstLine, direction, linePositionMode);
 
     const ComputedStyle& style = styleRef(firstLine && document().styleEngine().usesFirstLineRules());
     return LayoutUnit(style.computedLineHeight());
 }
 
 int LayoutBlock::beforeMarginInLineDirection(LineDirectionMode direction) const
 {
-    return direction == HorizontalLine ? marginTop() : marginRight();
+    return (direction == HorizontalLine ? marginTop() : marginRight()).toInt();
 }
 
 int LayoutBlock::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
 {
     // Inline blocks are replaced elements. Otherwise, just pass off to
     // the base class.  If we're being queried as though we're the root line
     // box, then the fact that we're an inline-block is irrelevant, and we behave
     // just like a block.
     if (isInline() && linePositionMode == PositionOnContainingLine) {
         // For "leaf" theme objects, let the theme decide what the baseline position is.
@@ skipping 19 matching lines @@
             return beforeMarginInLineDirection(direction) + baselinePos;
 
         return LayoutBox::baselinePosition(baselineType, firstLine, direction, linePositionMode);
     }
 
     // If we're not replaced, we'll only get called with PositionOfInteriorLineBoxes.
     // Note that inline-block counts as replaced here.
     ASSERT(linePositionMode == PositionOfInteriorLineBoxes);
 
     const FontMetrics& fontMetrics = style(firstLine)->getFontMetrics();
-    return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
+    return (fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2).toInt();
 }
 
 LayoutUnit LayoutBlock::minLineHeightForReplacedObject(bool isFirstLine, LayoutUnit replacedHeight) const
 {
     if (!document().inNoQuirksMode() && replacedHeight)
         return replacedHeight;
 
     return std::max<LayoutUnit>(replacedHeight, lineHeight(isFirstLine, isHorizontalWritingMode() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes));
 }
 
 // TODO(mstensho): Figure out if all of this baseline code is needed here, or if it should be moved
 // down to LayoutBlockFlow. LayoutDeprecatedFlexibleBox and LayoutGrid lack baseline calculation
 // overrides, so the code is here just for them. Just walking the block children in logical order
 // seems rather wrong for those two layout modes, though.
 
 int LayoutBlock::firstLineBoxBaseline() const
 {
     ASSERT(!childrenInline());
     if (isWritingModeRoot() && !isRubyRun())
         return -1;
 
     for (LayoutBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {
         if (!curr->isFloatingOrOutOfFlowPositioned()) {
             int result = curr->firstLineBoxBaseline();
             if (result != -1)
-                return curr->logicalTop() + result; // Translate to our coordinate space.
+                return (curr->logicalTop() + result).toInt(); // Translate to our coordinate space.
         }
     }
     return -1;
 }
 
 int LayoutBlock::inlineBlockBaseline(LineDirectionMode lineDirection) const
 {
     ASSERT(!childrenInline());
     if ((!style()->isOverflowVisible() && !shouldIgnoreOverflowPropertyForInlineBlockBaseline()) || style()->containsSize()) {
         // We are not calling LayoutBox::baselinePosition here because the caller should add the margin-top/margin-right, not us.
-        return lineDirection == HorizontalLine ? size().height() + marginBottom() : size().width() + marginLeft();
+        return (lineDirection == HorizontalLine ? size().height() + marginBottom() : size().width() + marginLeft()).toInt();
     }
 
     if (isWritingModeRoot() && !isRubyRun())
         return -1;
 
     bool haveNormalFlowChild = false;
     for (LayoutBox* curr = lastChildBox(); curr; curr = curr->previousSiblingBox()) {
         if (!curr->isFloatingOrOutOfFlowPositioned()) {
             haveNormalFlowChild = true;
             int result = curr->inlineBlockBaseline(lineDirection);
             if (result != -1)
-                return curr->logicalTop() + result; // Translate to our coordinate space.
+                return (curr->logicalTop() + result).toInt(); // Translate to our coordinate space.
         }
     }
     if (!haveNormalFlowChild && hasLineIfEmpty()) {
         const FontMetrics& fontMetrics = firstLineStyle()->getFontMetrics();
-        return fontMetrics.ascent()
+        return (fontMetrics.ascent()
             + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
-            + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
+            + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight())).toInt();
     }
     return -1;
 }
 
 const LayoutBlock* LayoutBlock::enclosingFirstLineStyleBlock() const
 {
     const LayoutBlock* firstLineBlock = this;
     bool hasPseudo = false;
     while (true) {
         hasPseudo = firstLineBlock->style()->hasPseudoStyle(PseudoIdFirstLine);
@@ skipping 323 matching lines @@
         for (TrackedLayoutBoxListHashSet::const_iterator it = positionedDescendantSet->begin(); it != end; ++it) {
             LayoutBox* currBox = *it;
             ASSERT(!currBox->needsLayout());
         }
     }
 }
 
 #endif
 
 } // namespace blink