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

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

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1289 matching lines @@
 
     // Provided the grid container does not have a definite size or max-size in the relevant axis,
     // if the min size is definite then the number of repetitions is the largest possible positive
     // integer that fulfills that minimum requirement.
     if (needsToFulfillMinimumSize)
         ++repetitions;
 
     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)
         return;
 
     ASSERT(m_gridItemArea.isEmpty());
 
     m_autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns);
     m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows);
 
@@ skipping 27 matching lines @@
     }
 
     DCHECK_GE(gridRowCount(), GridPositionsResolver::explicitGridRowCount(*style(), m_autoRepeatRows));
     DCHECK_GE(gridColumnCount(), GridPositionsResolver::explicitGridColumnCount(*style(), m_autoRepeatColumns));
 
     placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems);
     placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems);
 
     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())
             continue;
 
         GridArea area = cachedGridArea(*child);
         ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
     }
 #endif
 }
@@ skipping 326 matching lines @@
     bool isForColumns = direction == ForColumns;
 
     GridSpan positions = GridPositionsResolver::resolveGridPositionsFromStyle(*style(), child, direction, autoRepeatCountForDirection(direction));
     if (positions.isIndefinite()) {
         offset = LayoutUnit();
         breadth = isForColumns ? clientLogicalWidth() : clientLogicalHeight();
         return;
     }
 
     // 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;
 
     GridPosition startPosition = isForColumns ? child.style()->gridColumnStart() : child.style()->gridRowStart();
     GridPosition endPosition = isForColumns ? child.style()->gridColumnEnd() : child.style()->gridRowEnd();
     int lastLine = isForColumns ? gridColumnCount() : gridRowCount();
 
     bool startIsAuto = startPosition.isAuto()
         || (startPosition.isNamedGridArea() && !NamedLineCollection::isValidNamedLineOrArea(startPosition.namedGridLine(), styleRef(), GridPositionsResolver::initialPositionSide(direction)))
         || (startLine < 0)
         || (startLine > lastLine);
     bool endIsAuto = endPosition.isAuto()
         || (endPosition.isNamedGridArea() && !NamedLineCollection::isValidNamedLineOrArea(endPosition.namedGridLine(), styleRef(), GridPositionsResolver::finalPositionSide(direction)))
         || (endLine < 0)
         || (endLine > lastLine);
 
     LayoutUnit start;
     if (!startIsAuto) {
+        startLine -= droppedTracksBeforeLine(direction, startLine);
+        DCHECK_GE(startLine, 0);
+
         if (isForColumns) {
             if (styleRef().isLeftToRightDirection())
                 start = m_columnPositions[startLine] - borderLogicalLeft();
             else
                 start = logicalWidth() - translateRTLCoordinate(m_columnPositions[startLine]) - borderLogicalRight();
         } else {
             start = m_rowPositions[startLine] - borderBefore();
         }
     }
 
     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();
             else
                 end = logicalWidth() - translateRTLCoordinate(m_columnPositions[endLine]) - borderLogicalRight();
         } else {
             end = m_rowPositions[endLine] - borderBefore();
         }
 
         // These vectors store line positions including gaps, but we shouldn't consider them for the edges of the grid.
@@ skipping 507 matching lines @@
     return LayoutPoint(rowAxisOffset, columnAxisOffsetForChild(child, sizingData));
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
 {
     if (!m_gridItemArea.isEmpty())
         GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 } // namespace blink