[CSSGridLayout] Skip items spanning flex tracks in track sizing algo

Source/core/rendering/RenderGrid.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 664 matching lines @@
     GridItemWithSpan(RenderBox& gridItem, const GridCoordinate& coordinate, GridTrackSizingDirection direction)
         : m_gridItem(gridItem)
         , m_coordinate(coordinate)
     {
         const GridSpan& span = (direction == ForRows) ? coordinate.rows : coordinate.columns;
         m_span = span.resolvedFinalPosition.toInt() - span.resolvedInitialPosition.toInt() + 1;
     }
 
     RenderBox& gridItem() const { return *m_gridItem; }
     GridCoordinate coordinate() const { return m_coordinate; }
+    bool spansMultipleTracks() const { return m_span > 1; }
 
     bool operator<(const GridItemWithSpan other) const { return m_span < other.m_span; }
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_gridItem);
     }
 
 private:
     RawPtrWillBeMember<RenderBox> m_gridItem;
@@ skipping 10 matching lines @@
     // needsDestruction is by default defined in terms of IsPod<>, but as
     // it doesn't handle embedded structs/enums (e.g., GridCoordinate),
     // override it here.
     static const bool needsDestruction = false;
 };
 
 } // namespace WTF
 
 namespace blink {
 
+bool RenderGrid::itemSpansFlexibleSizedTracks(const GridItemWithSpan& gridItemWithSpan, GridTrackSizingDirection direction) const
+{
+    const GridCoordinate coordinate = gridItemWithSpan.coordinate();
+    const GridResolvedPosition initialTrackPosition = (direction == ForColumns) ? coordinate.columns.resolvedInitialPosition : coordinate.rows.resolvedInitialPosition;
+    const GridResolvedPosition finalTrackPosition = (direction == ForColumns) ? coordinate.columns.resolvedFinalPosition : coordinate.rows.resolvedFinalPosition;
+
+    for (GridResolvedPosition trackPosition = initialTrackPosition; trackPosition <= finalTrackPosition; ++trackPosition) {
+        const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition.toInt());

[Julien - ping for review, 2014/10/15 16:04:58]

Too bad we have this call, else we could have moved this function to
GridItemWithSpan.

[svillar, 2014/10/16 06:36:30]

Acknowledged.

+        if (trackSize.minTrackBreadth().isFlex() || trackSize.maxTrackBreadth().isFlex())
+            return true;
+    }
+
+    return false;
+}
+
 void RenderGrid::resolveContentBasedTrackSizingFunctions(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit& availableLogicalSpace)
 {
     sizingData.itemsSortedByIncreasingSpan.shrink(0);
     HashSet<RenderBox*> itemsSet;
     size_t contentSizedTracksCount = sizingData.contentSizedTracksIndex.size();
     for (size_t i = 0; i < contentSizedTracksCount; ++i) {
         GridIterator iterator(m_grid, direction, sizingData.contentSizedTracksIndex[i]);
         while (RenderBox* gridItem = iterator.nextGridItem()) {
             if (itemsSet.add(gridItem).isNewEntry)
                 sizingData.itemsSortedByIncreasingSpan.append(GridItemWithSpan(*gridItem, cachedGridCoordinate(*gridItem), direction));
         }
     }
     std::sort(sizingData.itemsSortedByIncreasingSpan.begin(), sizingData.itemsSortedByIncreasingSpan.end());
 
     Vector<GridItemWithSpan>::iterator end = sizingData.itemsSortedByIncreasingSpan.end();
     for (Vector<GridItemWithSpan>::iterator it = sizingData.itemsSortedByIncreasingSpan.begin(); it != end; ++it) {
-        // FIXME: do not consider items with a span > 1 that span a track with a flexible sizing function.
         GridItemWithSpan itemWithSpan = *it;
+        // We should not consider items spanning more than one track that span tracks with flexible sizing functions.
+        if (itemWithSpan.spansMultipleTracks() && itemSpansFlexibleSizedTracks(itemWithSpan, direction))
+            continue;
+
         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMinTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth);
         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMinTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth);
         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMaxTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMaxTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
     }
 
     for (size_t i = 0; i < contentSizedTracksCount; ++i) {
         size_t trackIndex = sizingData.contentSizedTracksIndex[i];
         GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackIndex] : sizingData.rowTracks[trackIndex];
         if (track.m_maxBreadth == infinity)
@@ skipping 675 matching lines @@
     if (isOutOfFlowPositioned())
         return "RenderGrid (positioned)";
     if (isAnonymous())
         return "RenderGrid (generated)";
     if (isRelPositioned())
         return "RenderGrid (relative positioned)";
     return "RenderGrid";
 }
 
 } // namespace blink