Handling of percent less than 1 while extra height distribution in spanning rows.

Source/core/layout/LayoutTableSection.cpp

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 275 matching lines @@
         if (!spanningRowsHeight.rowHeight[row])
             spanningRowsHeight.isAnyRowWithOnlySpanningCells |= rowHasOnlySpanningCells(actualRow);
 
         spanningRowsHeight.totalRowsHeight += spanningRowsHeight.rowHeight[row];
         spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing -= borderSpacingForRow(actualRow);
     }
     // We don't span the following row so its border-spacing (if any) should be included.
     spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing += borderSpacingForRow(rowIndex + rowSpan - 1);
 }
 
-void LayoutTableSection::distributeExtraRowSpanHeightToPercentRows(LayoutTableCell* cell, int totalPercent, int& extraRowSpanningHeight, Vector<int>& rowsHeight)
+void LayoutTableSection::distributeExtraRowSpanHeightToPercentRows(LayoutTableCell* cell, LayoutUnit totalPercent, int& extraRowSpanningHeight, Vector<int>& rowsHeight)
 {
     if (!extraRowSpanningHeight || !totalPercent)
         return;
 
     const unsigned rowSpan = cell->rowSpan();
     const unsigned rowIndex = cell->rowIndex();
-    int percent = std::min(totalPercent, 100);
+    LayoutUnit percent = 100;
+    percent = std::min(totalPercent, percent);
     const int tableHeight = m_rowPos[m_grid.size()] + extraRowSpanningHeight;
 
     // Our algorithm matches Firefox. Extra spanning height would be distributed Only in first percent height rows
     // those total percent is 100. Other percent rows would be uneffected even extra spanning height is remain.
     int accumulatedPositionIncrease = 0;
     for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
         if (percent > 0 && extraRowSpanningHeight > 0) {
             if (m_grid[row].logicalHeight.isPercent()) {
                 int toAdd = (tableHeight * m_grid[row].logicalHeight.percent() / 100) - rowsHeight[row - rowIndex];
                 // FIXME: Note that this is wrong if we have a percentage above 100% and may make us grow
                 // above the available space.
 
                 toAdd = std::min(toAdd, extraRowSpanningHeight);
                 accumulatedPositionIncrease += toAdd;
                 extraRowSpanningHeight -= toAdd;
                 percent -= m_grid[row].logicalHeight.percent();
             }
         }
         m_rowPos[row + 1] += accumulatedPositionIncrease;
     }
 }
 
-// Sometimes the multiplication of the 2 values below will overflow an integer.
-// So we convert the parameters to 'long long' instead of 'int' to avoid the
-// problem in this function.
-static void updatePositionIncreasedWithRowHeight(long long extraHeight, long long rowHeight, long long totalHeight, int& accumulatedPositionIncrease, int& remainder)
+static void updatePositionIncreasedWithRowHeight(int extraHeight, LayoutUnit rowHeight, LayoutUnit totalHeight, int& accumulatedPositionIncrease, int& remainder)
 {
     static_assert(sizeof(long long int) > sizeof(int), "int should be smaller than long long");
 
-    accumulatedPositionIncrease += (extraHeight * rowHeight) / totalHeight;
-    remainder += (extraHeight * rowHeight) % totalHeight;
+    // Multiplication of the 2 values below will overflow in LayoutUnit.
+    // So we converted to 'long long' instead of 'int' to avoid the problem in this function.
+    // Upto 2 digits of rational part is considered for calculation.

[Julien - ping for review, 2015/03/26 17:05:15]

That's a lot of computation, most of which makes little sense.

The comment makes no sense: rowHeight is a LayoutUnit so you're doing a
LayoutUnit multiplication that you cast to int :(

+    long long rHeight = static_cast<int>(rowHeight * 100);
+    long long tHeight = static_cast<int>(totalHeight * 100);
+
+    accumulatedPositionIncrease += (extraHeight * rHeight) / tHeight;
+    remainder += ((extraHeight * rHeight) % tHeight) / 100;
 }
 
 // This is mainly used to distribute whole extra rowspanning height in percent rows when all spanning rows are
 // percent rows.
 // Distributing whole extra rowspanning height in percent rows based on the ratios of percent because this method works
 // same as percent distribution when only percent rows are present and percent is 100. Also works perfectly fine when
 // percent is not equal to 100.
-void LayoutTableSection::distributeWholeExtraRowSpanHeightToPercentRows(LayoutTableCell* cell, int totalPercent, int& extraRowSpanningHeight, Vector<int>& rowsHeight)
+void LayoutTableSection::distributeWholeExtraRowSpanHeightToPercentRows(LayoutTableCell* cell, LayoutUnit totalPercent, int& extraRowSpanningHeight, Vector<int>& rowsHeight)
 {
     if (!extraRowSpanningHeight || !totalPercent)
         return;
 
     const unsigned rowSpan = cell->rowSpan();
     const unsigned rowIndex = cell->rowIndex();
     int remainder = 0;
 
     int accumulatedPositionIncrease = 0;
     for (unsigned row = rowIndex; row < (rowIndex + rowSpan); row++) {
         if (m_grid[row].logicalHeight.isPercent()) {
             updatePositionIncreasedWithRowHeight(extraRowSpanningHeight, m_grid[row].logicalHeight.percent(), totalPercent, accumulatedPositionIncrease, remainder);
 
             // While whole extra spanning height is distributing in percent spanning rows, rational parts remains
             // in every integer division. So accumulating all remainder part in integer division and when total remainder
             // is equvalent to divisor then 1 unit increased in row position.
             // Note that this algorithm is biased towards adding more space towards the lower rows.
             if (remainder >= totalPercent) {
-                remainder -= totalPercent;
+                remainder = remainder - totalPercent;
                 accumulatedPositionIncrease++;
             }
         }
         m_rowPos[row + 1] += accumulatedPositionIncrease;
     }
 
     ASSERT(!remainder);
 
     extraRowSpanningHeight -= accumulatedPositionIncrease;
 }
@@ skipping 240 matching lines @@
             extraHeightToPropagate = m_rowPos[spanningCellEndIndex] - originalBeforePosition;
             continue;
         }
 
         if (spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing <= spanningRowsHeight.totalRowsHeight) {
             extraHeightToPropagate = m_rowPos[rowIndex + rowSpan] - originalBeforePosition;
             continue;
         }
 
         // Below we are handling only row(s) who have at least one visible cell without rowspan value.
-        int totalPercent = 0;
+        LayoutUnit totalPercent = 0;
         int totalAutoRowsHeight = 0;
         int totalRemainingRowsHeight = spanningRowsHeight.totalRowsHeight;
 
         // FIXME: Inner spanning cell height should not change if it have fixed height when it's parent spanning cell
         // is distributing it's extra height in rows.
 
         // Calculate total percentage, total auto rows height and total rows height except percent rows.
         for (unsigned row = rowIndex; row < spanningCellEndIndex; row++) {
             if (m_grid[row].logicalHeight.isPercent()) {
                 totalPercent += m_grid[row].logicalHeight.percent();
@@ skipping 971 matching lines @@
     // FIXME: The table's direction should determine our row's direction, not the section's (see bug 96691).
     if (!style()->isLeftToRightDirection())
         cellLocation.setX(table()->columnPositions()[table()->numEffCols()] - table()->columnPositions()[table()->colToEffCol(cell->col() + cell->colSpan())] + horizontalBorderSpacing);
     else
         cellLocation.setX(table()->columnPositions()[effectiveColumn] + horizontalBorderSpacing);
 
     cell->setLogicalLocation(cellLocation);
 }
 
 } // namespace blink