[css-grid] Implement repeat(auto-fit)

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

Index: third_party/WebKit/Source/core/layout/LayoutGrid.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
index 1ac1d2d35d3cc99dcec4971c84193397ebd0a8ea..fdf52cfb9d4876d107b110bbbcc236d2ba9dc84f 100644
--- a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
@@ -1307,6 +1307,48 @@ size_t LayoutGrid::computeAutoRepeatTracksCount(GridTrackSizingDirection directi
     return repetitions;
 }
 
+std::unique_ptr<Vector<size_t>> LayoutGrid::computeEmptyTracksCountForAutoRepeat(GridTrackSizingDirection direction, size_t insertionPoint) const
+{

[Manuel Rego, 2016/06/21 21:57:38]

I think we need a comment explaining what this method is returning
as I think it's pretty complex.

E.g. repeat(auto-fit, 100px) with an available space of 300px
without items. This method will return: [1, 2, 3]

However, if there's 1 item in the 2nd column: [1, 1, 2]

[svillar, 2016/06/23 08:09:42]

Acknowledged.

+    std::unique_ptr<Vector<size_t>> emptyTracksCounter;
+    size_t repetitions = autoRepeatCountForDirection(direction);
+    if (m_gridItemArea.isEmpty()) {
+        emptyTracksCounter = wrapUnique(new Vector<size_t>(repetitions));
+        for (size_t i = 0; i < repetitions; i++)
+            emptyTracksCounter->at(i) = i + 1;
+        return emptyTracksCounter;
+    }
+
+    size_t emptyTracksCount = 0;

[Manuel Rego, 2016/06/21 21:57:37]

emptyTracksCount and emptyTracksCounter in the very same function
seems quite confusing.

[svillar, 2016/06/23 08:09:42]

I agree, I even had build issues because I was replacing them with the other
one.

+    size_t firstAutoRepeatTrack = insertionPoint + std::abs(direction == ForColumns ? m_smallestColumnStart : m_smallestRowStart);
+    size_t lastAutoRepeatTrack = firstAutoRepeatTrack + repetitions;
+    for (size_t trackIndex = firstAutoRepeatTrack; trackIndex < lastAutoRepeatTrack; ++trackIndex) {
+        GridIterator iterator(m_grid, direction, trackIndex);
+        if (!iterator.nextGridItem())
+            ++emptyTracksCount;
+
+        if (!emptyTracksCounter)

[jfernandez, 2016/06/21 07:40:26]

Isn't this name a bit confusing ? I understood the first time I read it that you
were entering in this branch if tracksCounter was NOT empty. 

What about explicitly comparing with nullptr ? 

[Manuel Rego, 2016/06/21 21:57:37]

Maybe we can rename emptyTracksCounter to droppedTracksCounter
to avoid confusion.
Also m_emptyColumnsCounter to m_droppedColumnsCounter, etc.

[svillar, 2016/06/23 08:09:42]

OK

[svillar, 2016/06/23 08:09:42]

Well it's a pointer that's the standard way to know that it's nullptr
Against coding style 

[svillar, 2016/06/23 08:19:14]

So the thing about your suggestion is that it is not accurate, there are no
dropped tracks at the moment. We're just computing the amount of empty tracks,
we'll remove them later.

+            emptyTracksCounter = wrapUnique(new Vector<size_t>(repetitions));
+        emptyTracksCounter->at(trackIndex - firstAutoRepeatTrack) = emptyTracksCount;
+    }
+    return emptyTracksCounter;
+}
+
+size_t LayoutGrid::droppedTracksBeforeLine(GridTrackSizingDirection direction, size_t line) const
+{
+    bool isRowAxis = direction == ForColumns;
+    auto* droppedTracksCounter = isRowAxis ? m_emptyColumnsCounter.get() : m_emptyRowsCounter.get();
+    size_t smallestStart = abs(isRowAxis ? m_smallestColumnStart : m_smallestRowStart);
+    size_t firstAutoRepeatTrack = (isRowAxis ? styleRef().gridAutoRepeatColumnsInsertionPoint() : styleRef().gridAutoRepeatRowsInsertionPoint()) + smallestStart;
+    if (droppedTracksCounter && line > firstAutoRepeatTrack) {
+        size_t lastAutoRepeatTrack = firstAutoRepeatTrack + droppedTracksCounter->size();
+        size_t trackIndex = line - firstAutoRepeatTrack - 1;
+        size_t droppedTracks = line < lastAutoRepeatTrack ? droppedTracksCounter->at(trackIndex) : droppedTracksCounter->last();
+        DCHECK_GE(droppedTracksCounter->size(), droppedTracks);
+        return droppedTracks;
+    }
+    return 0;
+}
+
 void LayoutGrid::placeItemsOnGrid()
 {
     if (!m_gridIsDirty)
@@ -1354,6 +1396,44 @@ void LayoutGrid::placeItemsOnGrid()
 
     m_grid.shrinkToFit();
 
+    /* auto-fit */

[Manuel Rego, 2016/06/21 21:57:38]

Nit: I would move this to a separated method,
it doesn't use any of the local variables defined above.

[svillar, 2016/06/23 08:09:42]

I guess it's a matter of taste. I don't usually like to create more methods if
they are going to be called just once (unless they clearly simplify the code).
In this case I think having this code here helps understanding how the
auto-repeat flow computation goes.

+    if (m_autoRepeatColumns && styleRef().gridAutoRepeatColumnsType() == AutoFit)
+        m_emptyColumnsCounter = computeEmptyTracksCountForAutoRepeat(ForColumns, styleRef().gridAutoRepeatColumnsInsertionPoint());
+    else
+        m_emptyColumnsCounter = nullptr;
+
+    if (m_autoRepeatRows && styleRef().gridAutoRepeatRowsType() == AutoFit)
+        m_emptyRowsCounter = computeEmptyTracksCountForAutoRepeat(ForRows, styleRef().gridAutoRepeatRowsInsertionPoint());
+    else
+        m_emptyRowsCounter = nullptr;
+
+    if (m_emptyRowsCounter || m_emptyColumnsCounter) {
+        for (auto* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
+            if (child->isOutOfFlowPositioned())
+                continue;
+
+            GridArea area = cachedGridArea(*child);
+            size_t droppedColumns = droppedTracksBeforeLine(ForColumns, area.columns.startLine());
+            size_t droppedRows = droppedTracksBeforeLine(ForRows, area.rows.startLine());
+            if (droppedColumns || droppedRows) {
+                area.adjustForDroppedTracks(droppedColumns, droppedRows);
+                m_gridItemArea.set(child, area);
+            }
+        }
+
+        size_t droppedColumnsCount = m_emptyColumnsCounter ? m_emptyColumnsCounter->last() : 0;
+        size_t droppedRowsCount = m_emptyRowsCounter ? m_emptyRowsCounter->last() : 0;
+        DCHECK_GE(m_autoRepeatColumns, droppedColumnsCount);
+        DCHECK_GE(m_autoRepeatRows, droppedRowsCount);
+
+        m_autoRepeatColumns -= droppedColumnsCount;
+        m_autoRepeatRows -= droppedRowsCount;
+
+        m_grid.shrink(m_grid.size() - droppedRowsCount);
+        for (auto& row : m_grid)
+            row.shrink(row.size() - droppedColumnsCount);
+    }
+
 #if ENABLE(ASSERT)
     for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
         if (child->isOutOfFlowPositioned())
@@ -1700,7 +1780,7 @@ void LayoutGrid::offsetAndBreadthForPositionedChild(const LayoutBox& child, Grid
     }
 
     // For positioned items we cannot use GridSpan::translate(). Because we could end up with negative values, as the positioned items do not create implicit tracks per spec.
-    int smallestStart = abs(isForColumns ? m_smallestColumnStart : m_smallestRowStart);
+    size_t smallestStart = abs(isForColumns ? m_smallestColumnStart : m_smallestRowStart);
     int startLine = positions.untranslatedStartLine() + smallestStart;
     int endLine = positions.untranslatedEndLine() + smallestStart;
 
@@ -1719,6 +1799,9 @@ void LayoutGrid::offsetAndBreadthForPositionedChild(const LayoutBox& child, Grid
 
     LayoutUnit start;
     if (!startIsAuto) {
+        startLine -= droppedTracksBeforeLine(direction, startLine);
+        DCHECK_GE(startLine, 0);
+
         if (isForColumns) {
             if (styleRef().isLeftToRightDirection())
                 start = m_columnPositions[startLine] - borderLogicalLeft();
@@ -1731,6 +1814,9 @@ void LayoutGrid::offsetAndBreadthForPositionedChild(const LayoutBox& child, Grid
 
     LayoutUnit end = isForColumns ? clientLogicalWidth() : clientLogicalHeight();
     if (!endIsAuto) {
+        endLine -= droppedTracksBeforeLine(direction, endLine);
+        DCHECK_GE(endLine, 0);
+
         if (isForColumns) {
             if (styleRef().isLeftToRightDirection())
                 end = m_columnPositions[endLine] - borderLogicalLeft();