[CSS Grid Layout] Support "sparse" in auto-placed items locked to a row/column

Source/core/rendering/RenderGrid.cpp

Index: Source/core/rendering/RenderGrid.cpp
diff --git a/Source/core/rendering/RenderGrid.cpp b/Source/core/rendering/RenderGrid.cpp
index 8dda784767969d0cb39c7a2208b537a678182900..79b46f2b2cc85a0287b5f48aaf89b8df419eea0d 100644
--- a/Source/core/rendering/RenderGrid.cpp
+++ b/Source/core/rendering/RenderGrid.cpp
@@ -978,15 +978,26 @@ PassOwnPtr<GridCoordinate> RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOu
 
 void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>& autoGridItems)
 {
+    GridTrackSizingDirection direction = autoPlacementMajorAxisDirection();
+    bool isGridAutoFlowDense = style()->isGridAutoFlowAlgorithmDense();
+
+    Vector<size_t> minorAxisCursors;

[Julien - ping for review, 2015/02/23 16:15:16]

I would love a comment about this vector to explain what it's doing.

[Manuel Rego, 2015/02/23 22:22:00]

I agree. But finally I'm changing the Vector for a HashMap as
suggested by @svillar. Of course, adding a comment to explain the map. :-)

Using the HashMap has some small benefits:
* The code is clearer (as you don't need to initialize the values).
* You won't need to reserve memory for all the tracks if you just have a few
  items with this auto-placement.
* Testing it in a 200x200 grid, it's slightly faster than the Vector.

+    if (!isGridAutoFlowDense)
+        minorAxisCursors.grow(direction == ForColumns ? gridColumnCount() : gridRowCount());
+
     for (const auto& autoGridItem : autoGridItems) {
         OwnPtr<GridSpan> majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(*style(), *autoGridItem, autoPlacementMajorAxisDirection());
         GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), *autoGridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
 
-        GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions->resolvedInitialPosition.toInt());
+        GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions->resolvedInitialPosition.toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors[majorAxisPositions->resolvedInitialPosition.toInt()]);

[Julien - ping for review, 2015/02/18 21:08:40]

That's relying on the default value in minorAxisCursor (we set it below), which
is weird and unintuitive.

I would have assumed that we would just reuse the position from the previous run
and get the algorithm straight. Why do we need all this complexity?

[Manuel Rego, 2015/02/18 21:23:10]

We can use minorAxisCursors.fill(0) before to make it clear that it's 
the initial value.
We cannot do that, as it's not guaranteed the order of the elements.

For example:
  <div style="grid-row: 1;">item 1</div>
  <div style="grid-row: 2;">item 2</div>
  <div style="grid-row: 1;">item 3</div>

Imagine that "item 1" is placed in the 4th column (due to other fixed 
elements before) and "item 2" in the 2nd column.
Then, if for "item 3" we use the value from the previous run, we'll be 
trying to place it in 3rd column first, which is wrong as we should be
starting in 5th column.

We could sort the elements by row, and process them per row, but then 
we'll be breaking the order-modified document order.

[Julien - ping for review, 2015/02/23 16:15:16]

minorAxisCursors.fill(0) makes the code more clear and more readable but it's
some extra unneeded work. I don't have an opinion on whether we should do it or
just put a comment.
I see the issue and that we're processing step 1. of the auto placement
algorithm, not the general case.

+
         OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions->integerSpan(), minorAxisPositions.integerSpan());
         if (!emptyGridArea)
             emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), *majorAxisPositions);
         insertItemIntoGrid(*autoGridItem, *emptyGridArea);
+
+        if (!isGridAutoFlowDense)
+            minorAxisCursors[majorAxisPositions->resolvedInitialPosition.toInt()] = (direction == ForColumns) ? emptyGridArea->rows.resolvedInitialPosition.toInt() : emptyGridArea->columns.resolvedInitialPosition.toInt();
     }
 }