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

Source/core/rendering/RenderTableSection.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 314 matching lines @@
     const unsigned rowIndex = cell->rowIndex();
     int percent = std::min(totalPercent, 100);
     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];
+                int toAdd = (tableHeight * std::ceil(m_grid[row].logicalHeight.percent()) / 100) - rowsHeight[row - rowIndex];

[Julien - ping for review, 2015/01/02 10:13:37]

It's not a good change. 0.5% is not 1% but after this change, we will treat them
exactly the same :(

We should do a LayoutUnit computation that we snap down to pixels. Ideally we
should do a full LayoutUnit computation and round at paint time but that's a
broader change.

[a.suchit, 2015/01/07 11:17:09]

Yes you are right but should we start this change ?
OR
I can try change the percent variable and operations in float.

[Julien - ping for review, 2015/01/07 13:30:10]

As a rule floats should be used for local computation to prevent bad rounding
(like this bug).  We have some places (line box computations) doing computations
over floats but they are being changed to use LayoutUnits.

If we can use some LayoutUnit and fix the bug, it's the best move. I am not
asking for the broader change, just the minimal amount of LayoutUnit to fix the
logic. If that doesn't work, then the minimal amount of floats would be OK (but
I would like to know why it didn't work as it's important to know what blocking
switching to LayoutUnit).

                 // 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;
@@ skipping 21 matching lines @@
     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);
+            updatePositionIncreasedWithRowHeight(extraRowSpanningHeight, std::ceil(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;
                 accumulatedPositionIncrease++;
             }
         }
@@ skipping 245 matching lines @@
         int 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();
+                totalPercent += std::ceil(m_grid[row].logicalHeight.percent());
                 totalRemainingRowsHeight -= spanningRowsHeight.rowHeight[row - rowIndex];
             } else if (m_grid[row].logicalHeight.isAuto()) {
                 totalAutoRowsHeight += spanningRowsHeight.rowHeight[row - rowIndex];
             }
         }
 
         int extraRowSpanningHeight = spanningRowsHeight.spanningCellHeightIgnoringBorderSpacing - spanningRowsHeight.totalRowsHeight;
 
         if (totalPercent < 100 && !totalAutoRowsHeight && !totalRemainingRowsHeight) {
             // Distributing whole extra rowspanning height in percent row when only non-percent rows height is 0.
@@ skipping 961 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