More explicit LayoutUnit conversions

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

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 120 matching lines @@
 public:
     ContentAlignmentData() {};
     ContentAlignmentData(LayoutUnit position, LayoutUnit distribution)
         : positionOffset(position)
         , distributionOffset(distribution)
     {
     }
 
     bool isValid() { return positionOffset >= 0 && distributionOffset >= 0; }
 
-    LayoutUnit positionOffset = -1;
-    LayoutUnit distributionOffset = -1;
+    LayoutUnit positionOffset = LayoutUnit(-1);
+    LayoutUnit distributionOffset = LayoutUnit(-1);
 };
 
 enum TrackSizeRestriction {
     AllowInfinity,
     ForbidInfinity,
 };
 
 class LayoutGrid::GridIterator {
     WTF_MAKE_NONCOPYABLE(GridIterator);
 public:
@@ skipping 191 matching lines @@
         return;
 
     {
         // LayoutState needs this deliberate scope to pop before updating scroll information (which
         // may trigger relayout).
         LayoutState state(*this, locationOffset());
 
         LayoutSize previousSize = size();
 
         updateLogicalWidth();
-        bool logicalHeightWasIndefinite = computeContentLogicalHeight(MainOrPreferredSize, style()->logicalHeight(), -1) == -1;
+        bool logicalHeightWasIndefinite = computeContentLogicalHeight(MainOrPreferredSize, style()->logicalHeight(), LayoutUnit(-1)) == LayoutUnit(-1);
 
         TextAutosizer::LayoutScope textAutosizerLayoutScope(this);
 
         placeItemsOnGrid();
 
         GridSizingData sizingData(gridColumnCount(), gridRowCount());
 
         // At this point the logical width is always definite as the above call to updateLogicalWidth()
         // properly resolves intrinsic sizes. We cannot do the same for heights though because many code
         // paths inside updateLogicalHeight() require a previous call to setLogicalHeight() to resolve
@@ skipping 35 matching lines @@
     updateScrollInfoAfterLayout();
 
     clearNeedsLayout();
 }
 
 LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction, size_t span) const
 {
     ASSERT(span >= 1);
 
     if (span == 1)
-        return 0;
+        return LayoutUnit();
 
     const Length& trackGap = direction == ForColumns ? styleRef().gridColumnGap() : styleRef().gridRowGap();
-    return valueForLength(trackGap, 0) * (span - 1);
+    return valueForLength(trackGap, LayoutUnit()) * (span - 1);
 }
 
 void LayoutGrid::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     const_cast<LayoutGrid*>(this)->placeItemsOnGrid();
 
     GridSizingData sizingData(gridColumnCount(), gridRowCount());
-    sizingData.freeSpaceForDirection(ForColumns) = 0;
+    sizingData.freeSpaceForDirection(ForColumns) = LayoutUnit();
     const_cast<LayoutGrid*>(this)->computeUsedBreadthOfGridTracks(ForColumns, sizingData, minLogicalWidth, maxLogicalWidth, AvailableSpaceIndefinite);
 
     LayoutUnit totalGuttersSize = guttersSize(ForColumns, sizingData.columnTracks.size());
     minLogicalWidth += totalGuttersSize;
     maxLogicalWidth += totalGuttersSize;
 
-    LayoutUnit scrollbarWidth = intrinsicScrollbarLogicalWidth();
+    LayoutUnit scrollbarWidth = LayoutUnit(intrinsicScrollbarLogicalWidth());
     minLogicalWidth += scrollbarWidth;
     maxLogicalWidth += scrollbarWidth;
 }
 
 void LayoutGrid::computeIntrinsicLogicalHeight(GridSizingData& sizingData)
 {
     ASSERT(tracksAreWiderThanMinTrackBreadth(ForColumns, sizingData));
-    sizingData.freeSpaceForDirection(ForRows) = 0;
+    sizingData.freeSpaceForDirection(ForRows) = LayoutUnit();
     computeUsedBreadthOfGridTracks(ForRows, sizingData, m_minContentHeight, m_maxContentHeight, AvailableSpaceIndefinite);
 
     LayoutUnit totalGuttersSize = guttersSize(ForRows, gridRowCount());
     m_minContentHeight += totalGuttersSize;
     m_maxContentHeight += totalGuttersSize;
 
     ASSERT(tracksAreWiderThanMinTrackBreadth(ForRows, sizingData));
 }
 
 LayoutUnit LayoutGrid::computeIntrinsicLogicalContentHeightUsing(const Length& logicalHeightLength, LayoutUnit intrinsicContentHeight, LayoutUnit borderAndPadding) const
 {
     if (logicalHeightLength.isMinContent())
         return m_minContentHeight;
 
     if (logicalHeightLength.isMaxContent())
         return m_maxContentHeight;
 
     if (logicalHeightLength.isFitContent()) {
         if (m_minContentHeight == -1 || m_maxContentHeight == -1)
-            return -1;
+            return LayoutUnit(-1);
         LayoutUnit fillAvailableExtent = containingBlock()->availableLogicalHeight(ExcludeMarginBorderPadding);
         return std::min<LayoutUnit>(m_maxContentHeight, std::max(m_minContentHeight, fillAvailableExtent));
     }
 
     if (logicalHeightLength.isFillAvailable())
         return containingBlock()->availableLogicalHeight(ExcludeMarginBorderPadding) - borderAndPadding;
     ASSERT_NOT_REACHED();
-    return 0;
+    return LayoutUnit();
 }
 
 static inline double normalizedFlexFraction(const GridTrack& track, double flexFactor)
 {
     return track.baseSize() / std::max<double>(1, flexFactor);
 }
 
 void LayoutGrid::computeUsedBreadthOfGridTracks(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit& baseSizesWithoutMaximization, LayoutUnit& growthLimitsWithoutMaximization, AvailableSpaceType availableSpaceType)
 {
     LayoutUnit& freeSpace = sizingData.freeSpaceForDirection(direction);
@@ skipping 17 matching lines @@
         if (trackSize.isContentSized())
             sizingData.contentSizedTracksIndex.append(i);
         if (trackSize.maxTrackBreadth().isFlex())
             flexibleSizedTracksIndex.append(i);
     }
 
     // 2. Resolve content-based TrackSizingFunctions.
     if (!sizingData.contentSizedTracksIndex.isEmpty())
         resolveContentBasedTrackSizingFunctions(direction, sizingData);
 
-    baseSizesWithoutMaximization = growthLimitsWithoutMaximization = 0;
+    baseSizesWithoutMaximization = growthLimitsWithoutMaximization = LayoutUnit();
 
     for (const auto& track: tracks) {
         ASSERT(!track.infiniteGrowthPotential());
         baseSizesWithoutMaximization += track.baseSize();
         growthLimitsWithoutMaximization += track.growthLimit();
     }
     freeSpace = initialFreeSpace - baseSizesWithoutMaximization;
 
     bool hasDefiniteFreeSpace = availableSpaceType == AvailableSpaceDefinite;
     if (hasDefiniteFreeSpace && freeSpace <= 0)
@@ skipping 53 matching lines @@
 
             baseSizesWithoutMaximization += increment;
             growthLimitsWithoutMaximization += increment;
         }
     }
 }
 
 LayoutUnit LayoutGrid::computeUsedBreadthOfMinLength(const GridLength& gridLength, LayoutUnit maxSize) const
 {
     if (gridLength.isFlex())
-        return 0;
+        return LayoutUnit();
 
     const Length& trackLength = gridLength.length();
     if (trackLength.isSpecified())
         return valueForLength(trackLength, maxSize);
 
     ASSERT(trackLength.isMinContent() || trackLength.isAuto() || trackLength.isMaxContent());
-    return 0;
+    return LayoutUnit();
 }
 
 LayoutUnit LayoutGrid::computeUsedBreadthOfMaxLength(const GridLength& gridLength, LayoutUnit usedBreadth, LayoutUnit maxSize) const
 {
     if (gridLength.isFlex())
         return usedBreadth;
 
     const Length& trackLength = gridLength.length();
     if (trackLength.isSpecified())
         return valueForLength(trackLength, maxSize);
 
     ASSERT(trackLength.isMinContent() || trackLength.isAuto() || trackLength.isMaxContent());
-    return infinity;
+    return LayoutUnit(infinity);
 }
 
 double LayoutGrid::computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, GridTrackSizingDirection direction, double flexFactorSum, LayoutUnit& leftOverSpace, const Vector<size_t, 8>& flexibleTracksIndexes, PassOwnPtr<TrackIndexSet> tracksToTreatAsInflexible) const
 {
     // We want to avoid the effect of flex factors sum below 1 making the factor unit size to grow exponentially.
     double hypotheticalFactorUnitSize = leftOverSpace / std::max<double>(1, flexFactorSum);
 
     // product of the hypothetical "flex factor unit" and any flexible track's "flex factor" must be grater than such track's "base size".
     OwnPtr<TrackIndexSet> additionalTracksToTreatAsInflexible = tracksToTreatAsInflexible;
     bool validFlexFactorUnit = true;
@@ skipping 80 matching lines @@
 
     bool hasOverrideHeight = child.hasOverrideLogicalContentHeight();
     // We need to clear the stretched height to properly compute logical height during layout.
     if (hasOverrideHeight && child.needsLayout())
         child.clearOverrideLogicalContentHeight();
 
     child.setOverrideContainingBlockContentLogicalWidth(overrideContainingBlockContentLogicalWidth);
     // If |child| has a relative logical height, we shouldn't let it override its intrinsic height, which is
     // what we are interested in here. Thus we need to set the override logical height to -1 (no possible resolution).
     if (child.hasRelativeLogicalHeight())
-        child.setOverrideContainingBlockContentLogicalHeight(-1);
+        child.setOverrideContainingBlockContentLogicalHeight(LayoutUnit(-1));
     child.layoutIfNeeded();
     // If the child was stretched we should use its intrinsic height.
     return (hasOverrideHeight ? childIntrinsicHeight(child) : child.logicalHeight()) + child.marginLogicalHeight();
 }
 
 LayoutUnit LayoutGrid::minSizeForChild(LayoutBox& child, GridTrackSizingDirection direction, Vector<GridTrack>& columnTracks)
 {
     bool hasOrthogonalWritingMode = child.isHorizontalWritingMode() != isHorizontalWritingMode();
     // TODO(svillar): Properly support orthogonal writing mode.
     if (hasOrthogonalWritingMode)
         return LayoutUnit();
 
     const Length& childMinSize = direction == ForColumns ? child.style()->logicalMinWidth() : child.style()->logicalMinHeight();
     if (childMinSize.isAuto()) {
         // TODO(svillar): Implement intrinsic aspect ratio support (transferred size in specs).
         return minContentForChild(child, direction, columnTracks);
     }
 
     if (direction == ForColumns)
         return child.computeLogicalWidthUsing(MinSize, childMinSize, contentLogicalWidth(), this);
 
     return child.computeContentLogicalHeight(MinSize, childMinSize, child.logicalHeight()) + child.scrollbarLogicalHeight();
 }
 
 LayoutUnit LayoutGrid::minContentForChild(LayoutBox& child, GridTrackSizingDirection direction, Vector<GridTrack>& columnTracks)
 {
     bool hasOrthogonalWritingMode = child.isHorizontalWritingMode() != isHorizontalWritingMode();
     // FIXME: Properly support orthogonal writing mode.
     if (hasOrthogonalWritingMode)
-        return 0;
+        return LayoutUnit();
 
     if (direction == ForColumns) {
         // If |child| has a relative logical width, we shouldn't let it override its intrinsic width, which is
         // what we are interested in here. Thus we need to set the override logical width to -1 (no possible resolution).
         if (child.hasRelativeLogicalWidth())
-            child.setOverrideContainingBlockContentLogicalWidth(-1);
+            child.setOverrideContainingBlockContentLogicalWidth(LayoutUnit(-1));
 
         // FIXME: It's unclear if we should return the intrinsic width or the preferred width.
         // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
         return child.minPreferredLogicalWidth() + marginIntrinsicLogicalWidthForChild(child);
     }
 
     return logicalHeightForChild(child, columnTracks);
 }
 
 LayoutUnit LayoutGrid::maxContentForChild(LayoutBox& child, GridTrackSizingDirection direction, Vector<GridTrack>& columnTracks)
 {
     bool hasOrthogonalWritingMode = child.isHorizontalWritingMode() != isHorizontalWritingMode();
     // FIXME: Properly support orthogonal writing mode.
     if (hasOrthogonalWritingMode)
         return LayoutUnit();
 
     if (direction == ForColumns) {
         // If |child| has a relative logical width, we shouldn't let it override its intrinsic width, which is
         // what we are interested in here. Thus we need to set the override logical width to -1 (no possible resolution).
         if (child.hasRelativeLogicalWidth())
-            child.setOverrideContainingBlockContentLogicalWidth(-1);
+            child.setOverrideContainingBlockContentLogicalWidth(LayoutUnit(-1));
 
         // FIXME: It's unclear if we should return the intrinsic width or the preferred width.
         // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
         return child.maxPreferredLogicalWidth() + marginIntrinsicLogicalWidthForChild(child);
     }
 
     return logicalHeightForChild(child, columnTracks);
 }
 
 // We're basically using a class instead of a std::pair because of accessing gridItem() or gridSpan() is much more
@@ skipping 197 matching lines @@
     case ResolveIntrinsicMinimums:
         return minSizeForChild(gridItem, direction, columnTracks);
     case ResolveContentBasedMinimums:
     case ResolveIntrinsicMaximums:
         return minContentForChild(gridItem, direction, columnTracks);
     case ResolveMaxContentMinimums:
     case ResolveMaxContentMaximums:
         return maxContentForChild(gridItem, direction, columnTracks);
     case MaximizeTracks:
         ASSERT_NOT_REACHED();
-        return 0;
+        return LayoutUnit();
     }
 
     ASSERT_NOT_REACHED();
-    return 0;
+    return LayoutUnit();
 }
 
 template <TrackSizeComputationPhase phase>
 void LayoutGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection direction, GridSizingData& sizingData, const GridItemsSpanGroupRange& gridItemsWithSpan)
 {
     Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
     for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
         GridTrack& track = tracks[trackIndex];
         track.setPlannedSize(trackSizeForTrackSizeComputationPhase(phase, track, AllowInfinity));
     }
@@ skipping 394 matching lines @@
     unsigned numberOfAutoSizedTracks = autoSizedTracksIndex.size();
     if (numberOfAutoSizedTracks < 1)
         return;
 
     LayoutUnit sizeToIncrease = availableSpace / numberOfAutoSizedTracks;
     for (const auto& trackIndex : autoSizedTracksIndex) {
         GridTrack* track = tracks.data() + trackIndex;
         LayoutUnit baseSize = track->baseSize() + sizeToIncrease;
         track->setBaseSize(baseSize);
     }
-    availableSpace = 0;
+    availableSpace = LayoutUnit();
 }
 
 void LayoutGrid::layoutGridItems(GridSizingData& sizingData)
 {
     populateGridPositions(sizingData);
     m_gridItemsOverflowingGridArea.resize(0);
 
     for (LayoutBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
         if (child->isOutOfFlowPositioned()) {
             prepareChildForPositionedLayout(*child);
@@ skipping 222 matching lines @@
         return offset.clampNegativeToZero();
     case OverflowAlignmentUnsafe:
     case OverflowAlignmentDefault:
         // If we overflow our alignment container and overflow is 'true' (default), we
         // ignore the overflow and just return the value regardless (which may cause data
         // loss as we overflow the 'start' edge).
         return offset;
     }
 
     ASSERT_NOT_REACHED();
-    return 0;
+    return LayoutUnit();
 }
 
 static inline LayoutUnit constrainedChildIntrinsicContentLogicalHeight(const LayoutBox& child)
 {
     LayoutUnit childIntrinsicContentLogicalHeight = child.intrinsicContentLogicalHeight();
     return child.constrainLogicalHeightByMinMax(childIntrinsicContentLogicalHeight + child.borderAndPaddingLogicalHeight(), childIntrinsicContentLogicalHeight);
 }
 
 // FIXME: This logic is shared by LayoutFlexibleBox, so it should be moved to LayoutBox.
 bool LayoutGrid::needToStretchChildLogicalHeight(const LayoutBox& child) const
@@ skipping 28 matching lines @@
 
 // FIXME: This logic is shared by LayoutFlexibleBox, so it should be moved to LayoutBox.
 LayoutUnit LayoutGrid::marginLogicalHeightForChild(const LayoutBox& child) const
 {
     return isHorizontalWritingMode() ? child.marginHeight() : child.marginWidth();
 }
 
 LayoutUnit LayoutGrid::computeMarginLogicalHeightForChild(const LayoutBox& child) const
 {
     if (!child.styleRef().hasMargin())
-        return 0;
+        return LayoutUnit();
 
     LayoutUnit marginBefore;
     LayoutUnit marginAfter;
     child.computeMarginsForDirection(BlockDirection, this, child.containingBlockLogicalWidthForContent(), child.logicalHeight(), marginBefore, marginAfter,
         child.style()->marginBeforeUsing(style()),
         child.style()->marginAfterUsing(style()));
 
     return marginBefore + marginAfter;
 }
 
@@ skipping 14 matching lines @@
 
     auto& childStyle = child.styleRef();
     bool isHorizontalMode = isHorizontalWritingMode();
     bool hasAutoSizeInColumnAxis = isHorizontalMode ? childStyle.height().isAuto() : childStyle.width().isAuto();
     bool allowedToStretchChildAlongColumnAxis = hasAutoSizeInColumnAxis && !childStyle.marginBeforeUsing(style()).isAuto() && !childStyle.marginAfterUsing(style()).isAuto();
     if (allowedToStretchChildAlongColumnAxis && ComputedStyle::resolveAlignment(styleRef(), childStyle, ItemPositionStretch) == ItemPositionStretch) {
         // TODO (lajava): If the child has orthogonal flow, then it already has an override height set, so use it.
         // TODO (lajava): grid track sizing and positioning do not support orthogonal modes yet.
         if (child.isHorizontalWritingMode() == isHorizontalMode) {
             LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(child.overrideContainingBlockContentLogicalHeight(), child);
-            LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, -1);
+            LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, LayoutUnit(-1));
             child.setOverrideLogicalContentHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
             if (desiredLogicalHeight != child.logicalHeight()) {
                 // TODO (lajava): Can avoid laying out here in some cases. See https://webkit.org/b/87905.
                 child.setLogicalHeight(0);
                 child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
             }
         }
     }
 }
 
@@ skipping 175 matching lines @@
             endOfRow -= guttersSize(ForRows, 2);
         LayoutUnit childBreadth = child.logicalHeight() + child.marginLogicalHeight();
         if (childEndLine - childStartLine > 1 && childEndLine < m_rowPositions.size() - 1)
             endOfRow -= offsetBetweenTracks(styleRef().alignContentDistribution(), m_rowPositions, childBreadth);
         LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(child.styleRef().alignSelfOverflowAlignment(), endOfRow - startOfRow, childBreadth);
         return startPosition + (axisPosition == GridAxisEnd ? offsetFromStartPosition : offsetFromStartPosition / 2);
     }
     }
 
     ASSERT_NOT_REACHED();
-    return 0;
+    return LayoutUnit();
 }
 
 LayoutUnit LayoutGrid::rowAxisOffsetForChild(const LayoutBox& child) const
 {
     const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
     size_t childStartLine = columnsSpan.resolvedInitialPosition();
     LayoutUnit startOfColumn = m_columnPositions[childStartLine];
     LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
     if (hasAutoMarginsInRowAxis(child))
         return startPosition;
@@ skipping 11 matching lines @@
             endOfColumn -= guttersSize(ForRows, 2);
         LayoutUnit childBreadth = child.logicalWidth() + child.marginLogicalWidth();
         if (childEndLine - childStartLine > 1 && childEndLine < m_columnPositions.size() - 1)
             endOfColumn -= offsetBetweenTracks(styleRef().justifyContentDistribution(), m_columnPositions, childBreadth);
         LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(child.styleRef().justifySelfOverflowAlignment(), endOfColumn - startOfColumn, childBreadth);
         return startPosition + (axisPosition == GridAxisEnd ? offsetFromStartPosition : offsetFromStartPosition / 2);
     }
     }
 
     ASSERT_NOT_REACHED();
-    return 0;
+    return LayoutUnit();
 }
 
 ContentPosition static resolveContentDistributionFallback(ContentDistributionType distribution)
 {
     switch (distribution) {
     case ContentDistributionSpaceBetween:
         return ContentPositionStart;
     case ContentDistributionSpaceAround:
         return ContentPositionCenter;
     case ContentDistributionSpaceEvenly:
@@ skipping 25 matching lines @@
         fallbackPosition = resolveContentDistributionFallback(distribution);
 
     if (availableFreeSpace <= 0)
         return {};
 
     LayoutUnit distributionOffset;
     switch (distribution) {
     case ContentDistributionSpaceBetween:
         if (numberOfGridTracks < 2)
             return {};
-        return {0, availableFreeSpace / (numberOfGridTracks - 1)};
+        return {LayoutUnit(), availableFreeSpace / (numberOfGridTracks - 1)};
     case ContentDistributionSpaceAround:
         if (numberOfGridTracks < 1)
             return {};
         distributionOffset = availableFreeSpace / numberOfGridTracks;
         return {distributionOffset / 2, distributionOffset};
     case ContentDistributionSpaceEvenly:
         distributionOffset = availableFreeSpace / (numberOfGridTracks + 1);
         return {distributionOffset, distributionOffset};
     case ContentDistributionStretch:
-        return {0, 0};
+        return {LayoutUnit(), LayoutUnit()};
     case ContentDistributionDefault:
         return {};
     }
 
     ASSERT_NOT_REACHED();
     return {};
 }
 
 ContentAlignmentData LayoutGrid::computeContentPositionAndDistributionOffset(GridTrackSizingDirection direction, const LayoutUnit& availableFreeSpace, unsigned numberOfGridTracks) const
 {
     bool isRowAxis = direction == ForColumns;
     ContentPosition position = isRowAxis ? styleRef().justifyContentPosition() : styleRef().alignContentPosition();
     ContentDistributionType distribution = isRowAxis ? styleRef().justifyContentDistribution() : styleRef().alignContentDistribution();
     // If <content-distribution> value can't be applied, 'position' will become the associated
     // <content-position> fallback value.
     ContentAlignmentData contentAlignment = contentDistributionOffset(availableFreeSpace, position, distribution, numberOfGridTracks);
     if (contentAlignment.isValid())
         return contentAlignment;
 
     OverflowAlignment overflow = isRowAxis ? styleRef().justifyContentOverflowAlignment() : styleRef().alignContentOverflowAlignment();
     if (availableFreeSpace <= 0 && overflow == OverflowAlignmentSafe)
-        return {0, 0};
+        return {LayoutUnit(), LayoutUnit()};
 
     switch (position) {
     case ContentPositionLeft:
         // The align-content's axis is always orthogonal to the inline-axis.
-        return {0, 0};
+        return {LayoutUnit(), LayoutUnit()};
     case ContentPositionRight:
         if (isRowAxis)
-            return {availableFreeSpace, 0};
+            return {availableFreeSpace, LayoutUnit()};
         // The align-content's axis is always orthogonal to the inline-axis.
-        return {0, 0};
+        return {LayoutUnit(), LayoutUnit()};
     case ContentPositionCenter:
-        return {availableFreeSpace / 2, 0};
+        return {availableFreeSpace / 2, LayoutUnit()};
     case ContentPositionFlexEnd: // Only used in flex layout, for other layout, it's equivalent to 'End'.
     case ContentPositionEnd:
         if (isRowAxis)
-            return {offsetToEndEdge(styleRef().isLeftToRightDirection(), availableFreeSpace), 0};
-        return {availableFreeSpace, 0};
+            return {offsetToEndEdge(styleRef().isLeftToRightDirection(), availableFreeSpace), LayoutUnit()};
+        return {availableFreeSpace, LayoutUnit()};
     case ContentPositionFlexStart: // Only used in flex layout, for other layout, it's equivalent to 'Start'.
     case ContentPositionStart:
         if (isRowAxis)
-            return {offsetToStartEdge(styleRef().isLeftToRightDirection(), availableFreeSpace), 0};
-        return {0, 0};
+            return {offsetToStartEdge(styleRef().isLeftToRightDirection(), availableFreeSpace), LayoutUnit()};
+        return {LayoutUnit(), LayoutUnit()};
     case ContentPositionBaseline:
     case ContentPositionLastBaseline:
         // FIXME: These two require implementing Baseline Alignment. For now, we always 'start' align the child.
         // crbug.com/234191
         if (isRowAxis)
-            return {offsetToStartEdge(styleRef().isLeftToRightDirection(), availableFreeSpace), 0};
-        return {0, 0};
+            return {offsetToStartEdge(styleRef().isLeftToRightDirection(), availableFreeSpace), LayoutUnit()};
+        return {LayoutUnit(), LayoutUnit()};
     case ContentPositionAuto:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return {0, 0};
+    return {LayoutUnit(), LayoutUnit()};
 }
 
 LayoutPoint LayoutGrid::findChildLogicalPosition(const LayoutBox& child, GridSizingData& sizingData) const
 {
     LayoutUnit rowAxisOffset = rowAxisOffsetForChild(child);
     // We stored m_columnPosition s's data ignoring the direction, hence we might need now
     // to translate positions from RTL to LTR, as it's more convenient for painting.
     if (!style()->isLeftToRightDirection()) {
         LayoutUnit alignmentOffset =  m_columnPositions[0] - borderAndPaddingStart();
         LayoutUnit rightGridEdgePosition = m_columnPositions[m_columnPositions.size() - 1] + alignmentOffset + borderAndPaddingLogicalLeft();
         rowAxisOffset = rightGridEdgePosition - (rowAxisOffset + child.logicalWidth());
     }
 
     return LayoutPoint(rowAxisOffset, columnAxisOffsetForChild(child));
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
 {
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 } // namespace blink