[css-grid] repeat() syntax should take a <track-list> argument

third_party/WebKit/Source/core/style/GridPositionsResolver.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "GridPositionsResolver.h"
 
 #include "core/layout/LayoutBox.h"
 #include "core/style/GridArea.h"
 #include <algorithm>
 
 namespace blink {
 
 static inline GridTrackSizingDirection directionFromSide(GridPositionSide side)
 {
     return side == ColumnStartSide || side == ColumnEndSide ? ForColumns : ForRows;
 }
 
 static inline String implicitNamedGridLineForSide(const String& lineName, GridPositionSide side)
 {
     return lineName + ((side == ColumnStartSide || side == RowStartSide) ? "-start" : "-end");
 }
 
 NamedLineCollection::NamedLineCollection(const ComputedStyle& gridContainerStyle, const String& namedLine, GridTrackSizingDirection direction, size_t lastLine, size_t autoRepeatTracksCount)
     : m_lastLine(lastLine)
-    , m_repetitions(autoRepeatTracksCount)
+    , m_autoRepeatTotalTracks(autoRepeatTracksCount)
 {
     bool isRowAxis = direction == ForColumns;
     const NamedGridLinesMap& gridLineNames = isRowAxis ? gridContainerStyle.namedGridColumnLines() : gridContainerStyle.namedGridRowLines();
     const NamedGridLinesMap& autoRepeatGridLineNames = isRowAxis ? gridContainerStyle.autoRepeatNamedGridColumnLines() : gridContainerStyle.autoRepeatNamedGridRowLines();
 
     if (!gridLineNames.isEmpty()) {
         auto it = gridLineNames.find(namedLine);
         m_namedLinesIndexes = it == gridLineNames.end() ? nullptr : &it->value;
     }
 
     if (!autoRepeatGridLineNames.isEmpty()) {
         auto it = autoRepeatGridLineNames.find(namedLine);
         m_autoRepeatNamedLinesIndexes = it == autoRepeatGridLineNames.end() ? nullptr : &it->value;
     }
 
     m_insertionPoint = isRowAxis ? gridContainerStyle.gridAutoRepeatColumnsInsertionPoint() : gridContainerStyle.gridAutoRepeatRowsInsertionPoint();
+
+    m_autoRepeatTrackListLength = isRowAxis ? gridContainerStyle.gridAutoRepeatColumns().size() : gridContainerStyle.gridAutoRepeatRows().size();
 }
 
 bool NamedLineCollection::isValidNamedLineOrArea(const String& namedLine, const ComputedStyle& gridContainerStyle, GridPositionSide side)
 {
     bool isRowAxis = directionFromSide(side) == ForColumns;
     const NamedGridLinesMap& gridLineNames = isRowAxis ? gridContainerStyle.namedGridColumnLines() : gridContainerStyle.namedGridRowLines();
     const NamedGridLinesMap& autoRepeatGridLineNames = isRowAxis ? gridContainerStyle.autoRepeatNamedGridColumnLines() : gridContainerStyle.autoRepeatNamedGridRowLines();
 
     if (gridLineNames.contains(namedLine) || autoRepeatGridLineNames.contains(namedLine))
         return true;
 
     String implicitName = implicitNamedGridLineForSide(namedLine, side);
     return gridLineNames.contains(implicitName) || autoRepeatGridLineNames.contains(implicitName);
 }
 
 bool NamedLineCollection::hasNamedLines()
 {
     return m_namedLinesIndexes || m_autoRepeatNamedLinesIndexes;
 }
 
 size_t NamedLineCollection::find(size_t line)
 {
     if (line > m_lastLine)
         return kNotFound;
 
     if (!m_autoRepeatNamedLinesIndexes || line < m_insertionPoint)
         return m_namedLinesIndexes ? m_namedLinesIndexes->find(line) : kNotFound;
 
-    if (line <= (m_insertionPoint + m_repetitions)) {
+    if (line <= (m_insertionPoint + m_autoRepeatTotalTracks)) {
         size_t localIndex = line - m_insertionPoint;
 
+        size_t indexInFirstRepetition = localIndex % m_autoRepeatTrackListLength;
+        if (indexInFirstRepetition)
+            return m_autoRepeatNamedLinesIndexes->find(indexInFirstRepetition);
+
         // The line names defined in the last line are also present in the first line of the next
-        // repetition (if any). Same for the line names defined in the first line.  Note that there
-        // is only one auto-repeated track allowed by the syntax, that's why it's enough to store
-        // indexes 0 and 1 (before and after the track size).
-        if (localIndex == m_repetitions)
-            return m_autoRepeatNamedLinesIndexes->find(static_cast<size_t>(1));
+        // repetition (if any). Same for the line names defined in the first line.
+        if (localIndex == m_autoRepeatTotalTracks)
+            return m_autoRepeatNamedLinesIndexes->find(m_autoRepeatTrackListLength);
         size_t position = m_autoRepeatNamedLinesIndexes->find(static_cast<size_t>(0));
         if (position != kNotFound)
             return position;
-        return localIndex == 0 ? kNotFound : m_autoRepeatNamedLinesIndexes->find(static_cast<size_t>(1));
+        return localIndex == 0 ? kNotFound : m_autoRepeatNamedLinesIndexes->find(m_autoRepeatTrackListLength);
     }
 
-    return m_namedLinesIndexes ? m_namedLinesIndexes->find(line - (m_repetitions - 1)) : kNotFound;
+    return m_namedLinesIndexes ? m_namedLinesIndexes->find(line - (m_autoRepeatTotalTracks - 1)) : kNotFound;
 }
 
 bool NamedLineCollection::contains(size_t line)
 {
     CHECK(hasNamedLines());
     return find(line) != kNotFound;
 }
 
 size_t NamedLineCollection::firstPosition()
 {
     CHECK(hasNamedLines());
 
     size_t firstLine = 0;
 
     if (!m_autoRepeatNamedLinesIndexes) {
         if (m_insertionPoint == 0 || m_insertionPoint < m_namedLinesIndexes->at(firstLine))
-            return m_namedLinesIndexes->at(firstLine) + (m_repetitions ? m_repetitions - 1 : 0);
+            return m_namedLinesIndexes->at(firstLine) + (m_autoRepeatTotalTracks ? m_autoRepeatTotalTracks - 1 : 0);
         return m_namedLinesIndexes->at(firstLine);
     }
 
     if (!m_namedLinesIndexes)
         return m_autoRepeatNamedLinesIndexes->at(firstLine) + m_insertionPoint;
 
     if (m_insertionPoint == 0)
-        return m_autoRepeatNamedLinesIndexes->at(firstLine);
+        return std::min(m_namedLinesIndexes->at(firstLine) + m_autoRepeatTotalTracks, m_autoRepeatNamedLinesIndexes->at(firstLine));
 
     return std::min(m_namedLinesIndexes->at(firstLine), m_autoRepeatNamedLinesIndexes->at(firstLine) + m_insertionPoint);
 }
 
 GridPositionSide GridPositionsResolver::initialPositionSide(GridTrackSizingDirection direction)
 {
     return (direction == ForColumns) ? ColumnStartSide : RowStartSide;
 }
 
 GridPositionSide GridPositionsResolver::finalPositionSide(GridTrackSizingDirection direction)
@@ skipping 250 matching lines @@
 
     if (endLine < startLine)
         std::swap(endLine, startLine);
     else if (endLine == startLine)
         endLine = startLine + 1;
 
     return GridSpan::untranslatedDefiniteGridSpan(startLine, endLine);
 }
 
 } // namespace blink