Continue converting to explicit LayoutUnit constructors

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

 /*
  * This file is part of the layout object implementation for KHTML.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003 Apple Computer, Inc.
  *
  * 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 129 matching lines @@
 {
 }
 
 static LayoutUnit marginWidthForChild(LayoutBox* child)
 {
     // A margin basically has three types: fixed, percentage, and auto (variable).
     // Auto and percentage margins simply become 0 when computing min/max width.
     // Fixed margins can be added in as is.
     Length marginLeft = child->style()->marginLeft();
     Length marginRight = child->style()->marginRight();
-    LayoutUnit margin = 0;
+    LayoutUnit margin;
     if (marginLeft.isFixed())
         margin += marginLeft.value();
     if (marginRight.isFixed())
         margin += marginRight.value();
     return margin;
 }
 
 static bool childDoesNotAffectWidthOrFlexing(LayoutObject* child)
 {
     // Positioned children and collapsed children don't affect the min/max width.
@@ skipping 43 matching lines @@
                 continue;
 
             LayoutUnit margin = marginWidthForChild(child);
             minLogicalWidth += child->minPreferredLogicalWidth() + margin;
             maxLogicalWidth += child->maxPreferredLogicalWidth() + margin;
         }
     }
 
     maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
 
-    LayoutUnit scrollbarWidth = intrinsicScrollbarLogicalWidth();
+    LayoutUnit scrollbarWidth(intrinsicScrollbarLogicalWidth());
     maxLogicalWidth += scrollbarWidth;
     minLogicalWidth += scrollbarWidth;
 }
 
 void LayoutDeprecatedFlexibleBox::layoutBlock(bool relayoutChildren)
 {
     ASSERT(needsLayout());
 
     if (!relayoutChildren && simplifiedLayout())
         return;
@@ skipping 65 matching lines @@
         }
     }
 }
 
 void LayoutDeprecatedFlexibleBox::layoutHorizontalBox(bool relayoutChildren)
 {
     LayoutUnit toAdd = borderBottom() + paddingBottom() + horizontalScrollbarHeight();
     LayoutUnit yPos = borderTop() + paddingTop();
     LayoutUnit xPos = borderLeft() + paddingLeft();
     bool heightSpecified = false;
-    LayoutUnit oldHeight = 0;
+    LayoutUnit oldHeight;
 
-    LayoutUnit remainingSpace = 0;
+    LayoutUnit remainingSpace;
 
 
     FlexBoxIterator iterator(this);
     unsigned highestFlexGroup = 0;
     unsigned lowestFlexGroup = 0;
     bool haveFlex = false, flexingChildren = false;
     gatherFlexChildrenInfo(iterator, relayoutChildren, highestFlexGroup, lowestFlexGroup, haveFlex);
 
     LayoutBlock::startDelayUpdateScrollInfo();
 
     // We do 2 passes.  The first pass is simply to lay everyone out at
     // their preferred widths.  The second pass handles flexing the children.
     do {
         // Reset our height.
         setHeight(yPos);
 
         xPos = borderLeft() + paddingLeft();
 
         // Our first pass is done without flexing.  We simply lay the children
         // out within the box.  We have to do a layout first in order to determine
         // our box's intrinsic height.
-        LayoutUnit maxAscent = 0, maxDescent = 0;
+        LayoutUnit maxAscent;
+        LayoutUnit maxDescent;
         for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
             if (child->isOutOfFlowPositioned())
                 continue;
 
             SubtreeLayoutScope layoutScope(*child);
             // TODO(jchaffraix): It seems incorrect to check isAtomicInlineLevel in this file.
             // We probably want to check if the element is replaced.
             if (relayoutChildren || (child->isAtomicInlineLevel() && (child->style()->width().hasPercent() || child->style()->height().hasPercent())))
                 layoutScope.setChildNeedsLayout(child);
 
             // Compute the child's vertical margins.
             child->computeAndSetBlockDirectionMargins(this);
 
             if (!child->needsLayout())
                 child->markForPaginationRelayoutIfNeeded(layoutScope);
 
             // Now do the layout.
             child->layoutIfNeeded();
 
             // Update our height and overflow height.
             if (style()->boxAlign() == BBASELINE) {
-                LayoutUnit ascent = child->firstLineBoxBaseline();
+                LayoutUnit ascent(child->firstLineBoxBaseline());
                 if (ascent == -1)
                     ascent = child->size().height() + child->marginBottom();
                 ascent += child->marginTop();
                 LayoutUnit descent = (child->size().height() + child->marginHeight()) - ascent;
 
                 // Update our maximum ascent.
                 maxAscent = std::max(maxAscent, ascent);
 
                 // Update our maximum descent.
                 maxDescent = std::max(maxDescent, descent);
@@ skipping 55 matching lines @@
             if (!child->needsLayout())
                 child->markForPaginationRelayoutIfNeeded(layoutScope);
 
             child->layoutIfNeeded();
 
             // We can place the child now, using our value of box-align.
             xPos += child->marginLeft();
             LayoutUnit childY = yPos;
             switch (style()->boxAlign()) {
             case BCENTER:
-                childY += child->marginTop() + ((contentHeight() - (child->size().height() + child->marginHeight())) / 2).clampToZero();
+                childY += child->marginTop() + ((contentHeight() - (child->size().height() + child->marginHeight())) / 2).clampNegativeToZero();
                 break;
             case BBASELINE: {
-                LayoutUnit ascent = child->firstLineBoxBaseline();
+                LayoutUnit ascent(child->firstLineBoxBaseline());
                 if (ascent == -1)
                     ascent = child->size().height() + child->marginBottom();
                 ascent += child->marginTop();
                 childY += child->marginTop() + (maxAscent - ascent);
                 break;
             }
             case BEND:
                 childY += contentHeight() - child->marginBottom() - child->size().height();
                 break;
             default: // BSTART
@@ skipping 41 matching lines @@
                         LayoutUnit allowedFlex = allowedChildFlex(child, expanding, i);
                         if (allowedFlex) {
                             LayoutUnit projectedFlex = (allowedFlex == LayoutUnit::max()) ? allowedFlex : LayoutUnit(allowedFlex * (totalFlex / child->style()->boxFlex()));
                             spaceAvailableThisPass = expanding ? std::min(spaceAvailableThisPass, projectedFlex) : std::max(spaceAvailableThisPass, projectedFlex);
                         }
                     }
 
                     // The flex groups may not have any flexible objects this time around.
                     if (!spaceAvailableThisPass || totalFlex == 0.0f) {
                         // If we just couldn't grow/shrink any more, then it's time to transition to the next flex group.
-                        groupRemainingSpace = 0;
+                        groupRemainingSpace = LayoutUnit();
                         continue;
                     }
 
                     // Now distribute the space to objects.
                     for (LayoutBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
                         if (child->style()->visibility() == COLLAPSE)
                             continue;
 
                         if (allowedChildFlex(child, expanding, i)) {
                             LayoutUnit spaceAdd = LayoutUnit(spaceAvailableThisPass * (child->style()->boxFlex() / totalFlex));
                             if (spaceAdd) {
                                 child->setOverrideLogicalContentWidth(contentWidthForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                             }
 
                             spaceAvailableThisPass -= spaceAdd;
                             remainingSpace -= spaceAdd;
                             groupRemainingSpace -= spaceAdd;
 
                             totalFlex -= child->style()->boxFlex();
                         }
                     }
                     if (groupRemainingSpace == groupRemainingSpaceAtBeginning) {
                         // This is not advancing, avoid getting stuck by distributing the remaining pixels.
-                        LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
+                        LayoutUnit spaceAdd = LayoutUnit(groupRemainingSpace > 0 ? 1 : -1);
                         for (LayoutBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
                             if (allowedChildFlex(child, expanding, i)) {
                                 child->setOverrideLogicalContentWidth(contentWidthForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                                 remainingSpace -= spaceAdd;
                                 groupRemainingSpace -= spaceAdd;
                             }
                         }
                     }
                 } while (absoluteValue(groupRemainingSpace) >= 1);
             }
 
             // We didn't find any children that could grow.
             if (haveFlex && !flexingChildren)
                 haveFlex = false;
         }
     } while (haveFlex);
 
     LayoutBlock::finishDelayUpdateScrollInfo();
 
     if (remainingSpace > 0 && ((style()->isLeftToRightDirection() && style()->boxPack() != Start)
         || (!style()->isLeftToRightDirection() && style()->boxPack() != End))) {
         // Children must be repositioned.
-        LayoutUnit offset = 0;
+        LayoutUnit offset;
         if (style()->boxPack() == Justify) {
             // Determine the total number of children.
             int totalChildren = 0;
             for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                 if (childDoesNotAffectWidthOrFlexing(child))
                     continue;
                 ++totalChildren;
             }
 
             // Iterate over the children and space them out according to the
@@ skipping 35 matching lines @@
     // a height change, we revert our height back to the intrinsic height before returning.
     if (heightSpecified)
         setHeight(oldHeight);
 }
 
 void LayoutDeprecatedFlexibleBox::layoutVerticalBox(bool relayoutChildren)
 {
     LayoutUnit yPos = borderTop() + paddingTop();
     LayoutUnit toAdd = borderBottom() + paddingBottom() + horizontalScrollbarHeight();
     bool heightSpecified = false;
-    LayoutUnit oldHeight = 0;
+    LayoutUnit oldHeight;
 
-    LayoutUnit remainingSpace = 0;
+    LayoutUnit remainingSpace;
 
     FlexBoxIterator iterator(this);
     unsigned highestFlexGroup = 0;
     unsigned lowestFlexGroup = 0;
     bool haveFlex = false, flexingChildren = false;
     gatherFlexChildrenInfo(iterator, relayoutChildren, highestFlexGroup, lowestFlexGroup, haveFlex);
 
     // We confine the line clamp ugliness to vertical flexible boxes (thus keeping it out of
     // mainstream block layout); this is not really part of the XUL box model.
     bool haveLineClamp = !style()->lineClamp().isNone();
@@ skipping 44 matching lines @@
                 child->markForPaginationRelayoutIfNeeded(layoutScope);
 
             // Now do a layout.
             child->layoutIfNeeded();
 
             // We can place the child now, using our value of box-align.
             LayoutUnit childX = borderLeft() + paddingLeft();
             switch (style()->boxAlign()) {
             case BCENTER:
             case BBASELINE: // Baseline just maps to center for vertical boxes
-                childX += child->marginLeft() + std::max<LayoutUnit>(LayoutUnit(), (contentWidth() - (child->size().width() + child->marginWidth())) / 2);
+                childX += child->marginLeft() + ((contentWidth() - (child->size().width() + child->marginWidth())) / 2).clampNegativeToZero();
                 break;
             case BEND:
                 if (!style()->isLeftToRightDirection())
                     childX += child->marginLeft();
                 else
                     childX += contentWidth() - child->marginRight() - child->size().width();
                 break;
             default: // BSTART/BSTRETCH
                 if (style()->isLeftToRightDirection())
                     childX += child->marginLeft();
@@ skipping 59 matching lines @@
                         LayoutUnit allowedFlex = allowedChildFlex(child, expanding, i);
                         if (allowedFlex) {
                             LayoutUnit projectedFlex = (allowedFlex == LayoutUnit::max()) ? allowedFlex : static_cast<LayoutUnit>(allowedFlex * (totalFlex / child->style()->boxFlex()));
                             spaceAvailableThisPass = expanding ? std::min(spaceAvailableThisPass, projectedFlex) : std::max(spaceAvailableThisPass, projectedFlex);
                         }
                     }
 
                     // The flex groups may not have any flexible objects this time around.
                     if (!spaceAvailableThisPass || totalFlex == 0.0f) {
                         // If we just couldn't grow/shrink any more, then it's time to transition to the next flex group.
-                        groupRemainingSpace = 0;
+                        groupRemainingSpace = LayoutUnit();
                         continue;
                     }
 
                     // Now distribute the space to objects.
                     for (LayoutBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
                         if (allowedChildFlex(child, expanding, i)) {
                             LayoutUnit spaceAdd = static_cast<LayoutUnit>(spaceAvailableThisPass * (child->style()->boxFlex() / totalFlex));
                             if (spaceAdd) {
                                 child->setOverrideLogicalContentHeight(contentHeightForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                             }
 
                             spaceAvailableThisPass -= spaceAdd;
                             remainingSpace -= spaceAdd;
                             groupRemainingSpace -= spaceAdd;
 
                             totalFlex -= child->style()->boxFlex();
                         }
                     }
                     if (groupRemainingSpace == groupRemainingSpaceAtBeginning) {
                         // This is not advancing, avoid getting stuck by distributing the remaining pixels.
-                        LayoutUnit spaceAdd = groupRemainingSpace > 0 ? 1 : -1;
+                        LayoutUnit spaceAdd = LayoutUnit(groupRemainingSpace > 0 ? 1 : -1);
                         for (LayoutBox* child = iterator.first(); child && groupRemainingSpace; child = iterator.next()) {
                             if (allowedChildFlex(child, expanding, i)) {
                                 child->setOverrideLogicalContentHeight(contentHeightForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                                 remainingSpace -= spaceAdd;
                                 groupRemainingSpace -= spaceAdd;
                             }
                         }
                     }
                 } while (absoluteValue(groupRemainingSpace) >= 1);
             }
 
             // We didn't find any children that could grow.
             if (haveFlex && !flexingChildren)
                 haveFlex = false;
         }
     } while (haveFlex);
 
     LayoutBlock::finishDelayUpdateScrollInfo();
 
     if (style()->boxPack() != Start && remainingSpace > 0) {
         // Children must be repositioned.
-        LayoutUnit offset = 0;
+        LayoutUnit offset;
         if (style()->boxPack() == Justify) {
             // Determine the total number of children.
             int totalChildren = 0;
             for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
                 if (childDoesNotAffectWidthOrFlexing(child))
                     continue;
 
                 ++totalChildren;
             }
 
@@ skipping 70 matching lines @@
 
     for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child) || !child->style()->height().isAuto() || !child->isLayoutBlock())
             continue;
 
         LayoutBlock* blockChild = toLayoutBlock(child);
         int lineCount = blockChild->lineCount();
         if (lineCount <= numVisibleLines)
             continue;
 
-        LayoutUnit newHeight = blockChild->heightForLineCount(numVisibleLines);
+        LayoutUnit newHeight(blockChild->heightForLineCount(numVisibleLines));
         if (newHeight == child->size().height())
             continue;
 
         child->setOverrideLogicalContentHeight(newHeight - child->borderAndPaddingHeight());
         child->forceChildLayout();
 
         // FIXME: For now don't support RTL.
         if (style()->direction() != LTR)
             continue;
 
@@ skipping 22 matching lines @@
         if (!leftToRight)
             continue;
 
         LayoutUnit blockRightEdge = destBlock.logicalRightOffsetForLine(lastVisibleLine->y(), DoNotIndentText);
         if (!lastVisibleLine->lineCanAccommodateEllipsis(leftToRight, blockRightEdge, lastVisibleLine->x() + lastVisibleLine->logicalWidth(), totalWidth))
             continue;
 
         // Let the truncation code kick in.
         // FIXME: the text alignment should be recomputed after the width changes due to truncation.
         LayoutUnit blockLeftEdge = destBlock.logicalLeftOffsetForLine(lastVisibleLine->y(), DoNotIndentText);
-        lastVisibleLine->placeEllipsis(ellipsisStr, leftToRight, blockLeftEdge, blockRightEdge, totalWidth);
+        lastVisibleLine->placeEllipsis(ellipsisStr, leftToRight, blockLeftEdge, blockRightEdge, LayoutUnit(totalWidth));
         destBlock.setHasMarkupTruncation(true);
     }
 }
 
 void LayoutDeprecatedFlexibleBox::clearLineClamp()
 {
     FlexBoxIterator iterator(this);
     for (LayoutBox* child = iterator.first(); child; child = iterator.next()) {
         if (childDoesNotAffectWidthOrFlexing(child))
             continue;
@@ skipping 16 matching lines @@
     // FIXME Investigate if this can be removed based on other flags. crbug.com/370010
     child->setMayNeedPaintInvalidation();
 
     // Place the child.
     child->setLocation(location);
 }
 
 LayoutUnit LayoutDeprecatedFlexibleBox::allowedChildFlex(LayoutBox* child, bool expanding, unsigned group)
 {
     if (childDoesNotAffectWidthOrFlexing(child) || child->style()->boxFlex() == 0.0f || child->style()->boxFlexGroup() != group)
-        return 0;
+        return LayoutUnit();
 
     if (expanding) {
         if (isHorizontal()) {
             // FIXME: For now just handle fixed values.
             LayoutUnit maxWidth = LayoutUnit::max();
             LayoutUnit width = contentWidthForChild(child);
             if (child->style()->maxWidth().isFixed())
-                maxWidth = child->style()->maxWidth().value();
+                maxWidth = LayoutUnit(child->style()->maxWidth().value());
             if (maxWidth == LayoutUnit::max())
                 return maxWidth;
-            return std::max<LayoutUnit>(0, maxWidth - width);
+            return (maxWidth - width).clampNegativeToZero();
         }
         // FIXME: For now just handle fixed values.
         LayoutUnit maxHeight = LayoutUnit::max();
         LayoutUnit height = contentHeightForChild(child);
         if (child->style()->maxHeight().isFixed())
-            maxHeight = child->style()->maxHeight().value();
+            maxHeight = LayoutUnit(child->style()->maxHeight().value());
         if (maxHeight == LayoutUnit::max())
             return maxHeight;
-        return std::max<LayoutUnit>(0, maxHeight - height);
+        return (maxHeight - height).clampNegativeToZero();
     }
 
     // FIXME: For now just handle fixed values.
     if (isHorizontal()) {
         LayoutUnit minWidth = child->minPreferredLogicalWidth();
         LayoutUnit width = contentWidthForChild(child);
         if (child->style()->minWidth().isFixed())
-            minWidth = child->style()->minWidth().value();
+            minWidth = LayoutUnit(child->style()->minWidth().value());
         else if (child->style()->minWidth().type() == Auto)
-            minWidth = 0;
+            minWidth = LayoutUnit();
 
-        LayoutUnit allowedShrinkage = std::min<LayoutUnit>(0, minWidth - width);
+        LayoutUnit allowedShrinkage = (minWidth - width).clampPositiveToZero();
         return allowedShrinkage;
     }
     Length minHeight = child->style()->minHeight();
     if (minHeight.isFixed() || minHeight.isAuto()) {
-        LayoutUnit minHeight = child->style()->minHeight().value();
+        LayoutUnit minHeight(child->style()->minHeight().value());
         LayoutUnit height = contentHeightForChild(child);
-        LayoutUnit allowedShrinkage = std::min<LayoutUnit>(0, minHeight - height);
+        LayoutUnit allowedShrinkage = (minHeight - height).clampPositiveToZero();
         return allowedShrinkage;
     }
-    return 0;
+    return LayoutUnit();
 }
 
 } // namespace blink