Removing more implicit LayoutUnit construction

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

 /*
  * Copyright (C) 2002 Lars Knoll (knoll@kde.org)
  *           (C) 2002 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2008, 2010 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.
  *
@@ skipping 196 matching lines @@
     return scale;
 }
 
 void TableLayoutAlgorithmAuto::computeIntrinsicLogicalWidths(LayoutUnit& minWidth, LayoutUnit& maxWidth)
 {
     TextAutosizer::TableLayoutScope textAutosizerTableLayoutScope(m_table);
 
     fullRecalc();
 
     int spanMaxLogicalWidth = calcEffectiveLogicalWidth();
-    minWidth = 0;
-    maxWidth = 0;
+    minWidth = LayoutUnit();
+    maxWidth = LayoutUnit();
     float maxPercent = 0;
     float maxNonPercent = 0;
     bool scaleColumns = shouldScaleColumns(m_table);
 
     // We substitute 0 percent by (epsilon / percentScaleFactor) percent in two places below to avoid division by zero.
     // FIXME: Handle the 0% cases properly.
     const float epsilon = 1 / 128.0f;
 
     float remainingPercent = 100;
     for (size_t i = 0; i < m_layoutStruct.size(); ++i) {
         minWidth += m_layoutStruct[i].effectiveMinLogicalWidth;
         maxWidth += m_layoutStruct[i].effectiveMaxLogicalWidth;
         if (scaleColumns) {
             if (m_layoutStruct[i].effectiveLogicalWidth.hasPercent()) {
                 float percent = std::min(static_cast<float>(m_layoutStruct[i].effectiveLogicalWidth.percent()), remainingPercent);
                 float logicalWidth = static_cast<float>(m_layoutStruct[i].effectiveMaxLogicalWidth) * 100 / std::max(percent, epsilon);
                 maxPercent = std::max(logicalWidth,  maxPercent);
                 remainingPercent -= percent;
             } else {
                 maxNonPercent += m_layoutStruct[i].effectiveMaxLogicalWidth;
             }
         }
     }
 
     if (scaleColumns) {
         maxNonPercent = maxNonPercent * 100 / std::max(remainingPercent, epsilon);
-        maxWidth = std::max<int>(maxWidth, static_cast<int>(std::min(maxNonPercent, static_cast<float>(tableMaxWidth))));
-        maxWidth = std::max<int>(maxWidth, static_cast<int>(std::min(maxPercent, static_cast<float>(tableMaxWidth))));
+        maxWidth = std::max(maxWidth, LayoutUnit(std::min(maxNonPercent, static_cast<float>(tableMaxWidth)))).floor();
+        maxWidth = std::max(maxWidth, LayoutUnit(std::min(maxPercent, static_cast<float>(tableMaxWidth)))).floor();
     }
 
-    maxWidth = std::max<int>(maxWidth, spanMaxLogicalWidth);
+    maxWidth = std::max(maxWidth.floor(), spanMaxLogicalWidth);
 }
 
 void TableLayoutAlgorithmAuto::applyPreferredLogicalWidthQuirks(LayoutUnit& minWidth, LayoutUnit& maxWidth) const
 {
     Length tableLogicalWidth = m_table->style()->logicalWidth();
     if (tableLogicalWidth.isFixed() && tableLogicalWidth.isPositive()) {
         // |minWidth| is the result of measuring the intrinsic content's size. Keep it to
         // make sure we are *never* smaller than the actual content.
         LayoutUnit minContentWidth = minWidth;
         // FIXME: This line looks REALLY suspicious as it could allow the minimum
         // preferred logical width to be smaller than the table content. This has
         // to be cross-checked against other browsers.
-        minWidth = maxWidth = std::max<int>(minWidth, tableLogicalWidth.value());
+        minWidth = maxWidth = std::max<int>(minWidth.floor(), tableLogicalWidth.value());
 
         const Length& styleMaxLogicalWidth = m_table->style()->logicalMaxWidth();
         if (styleMaxLogicalWidth.isFixed() && !styleMaxLogicalWidth.isNegative()) {
-            minWidth = std::min<int>(minWidth, styleMaxLogicalWidth.value());
+            minWidth = std::min<int>(minWidth.floor(), styleMaxLogicalWidth.value());
             minWidth = std::max(minWidth, minContentWidth);
             maxWidth = minWidth;
         }
     }
 }
 
 /*
   This method takes care of colspans.
   effWidth is the same as width for cells without colspans. If we have colspans, they get modified.
  */
@@ skipping 274 matching lines @@
         default:
             break;
         }
     }
 
     // allocate width to percent cols
     if (available > 0 && havePercent) {
         for (size_t i = 0; i < nEffCols; ++i) {
             Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
             if (logicalWidth.hasPercent()) {
-                int cellLogicalWidth = std::max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, minimumValueForLength(logicalWidth, tableLogicalWidth));
+                int cellLogicalWidth = std::max<int>(m_layoutStruct[i].effectiveMinLogicalWidth,
+                    minimumValueForLength(logicalWidth, LayoutUnit(tableLogicalWidth)));
                 available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;
                 m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;
             }
         }
         if (totalPercent > 100) {
             // remove overallocated space from the last columns
             int excess = tableLogicalWidth * (totalPercent - 100) / 100;
             for (unsigned i = nEffCols; i; ) {
                 --i;
                 if (m_layoutStruct[i].effectiveLogicalWidth.hasPercent()) {
@@ skipping 119 matching lines @@
             int reduce = available * minMaxDiff / logicalWidthBeyondMin;
             m_layoutStruct[i].computedLogicalWidth += reduce;
             available -= reduce;
             logicalWidthBeyondMin -= minMaxDiff;
             if (available >= 0)
                 break;
         }
     }
 }
 } // namespace blink