[css-grid] Clearing override sizes before running grid's layout logic.

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 412 matching lines @@
     DCHECK(sizingData.sizingState > GridSizingData::RowSizingFirstIteration);
 
     // In orthogonal flow cases column track's size is determined by using the computed
     // row track's size, which it was estimated during the first cycle of the sizing
     // algorithm. Hence we need to repeat computeUsedBreadthOfGridTracks for both,
     // columns and rows, to determine the final values.
     // TODO (lajava): orthogonal flows is just one of the cases which may require
     // a new cycle of the sizing algorithm; there may be more. In addition, not all the
     // cases with orthogonal flows require this extra cycle; we need a more specific
     // condition to detect whether child's min-content contribution has changed or not.
-    if (m_hasAnyOrthogonalChild) {
+    if (!m_orthogonalChildren.isEmpty()) {
         computeTrackSizesForDefiniteSize(ForColumns, sizingData, availableSpaceForColumns);
         computeTrackSizesForDefiniteSize(ForRows, sizingData, availableSpaceForRows);
     }
 }
 
 void LayoutGrid::layoutBlock(bool relayoutChildren)
 {
     ASSERT(needsLayout());
 
     if (!relayoutChildren && simplifiedLayout())
         return;
 
     SubtreeLayoutScope layoutScope(*this);
 
     {
         // LayoutState needs this deliberate scope to pop before updating scroll information (which
         // may trigger relayout).
         LayoutState state(*this, locationOffset());
 
         LayoutSize previousSize = size();
 
+        // We need to clear both own and containingBlock override sizes to ensure we get the same
+        // result when grid's intrinsic size it's computed again.

[cbiesinger, 2016/09/27 09:47:42]

Please add "in the updateLogicalWidth call below" to the end of this comment

(also typo: it's -> is)

+        if (sizesLogicalWidthToFitContent(styleRef().logicalWidth()) || styleRef().logicalWidth().isIntrinsicOrAuto()) {
+            for (auto* child : m_orthogonalChildren) {

[cbiesinger, 2016/09/27 09:47:42]

This is a little subtle because m_orthogonalChildren gets initialized by
placeItemsOnGrid which is only called below. But this is correct anyway because
we only need to call this on children that previously did go through the grid
algorithm (and also, when we compute our intrinsic size we also call
placeItemsOnGrid). Could you add a comment explaining this?

+                if (child->isOutOfFlowPositioned())
+                    continue;
+                child->clearOverrideSize();
+                child->clearContainingBlockOverrideSize();
+                child->forceLayout();
+            }
+        }
+
         updateLogicalWidth();
         m_hasDefiniteLogicalHeight = hasDefiniteLogicalHeight();
 
         TextAutosizer::LayoutScope textAutosizerLayoutScope(this, &layoutScope);
 
         // TODO(svillar): we won't need to do this once the intrinsic width computation is isolated
         // from the LayoutGrid object state (it should not touch any attribute) (see crbug.com/627812)
         if (m_autoRepeatColumns && m_autoRepeatColumns != computeAutoRepeatTracksCount(ForColumns, TrackSizing))
             dirtyGrid();
         placeItemsOnGrid(TrackSizing);
@@ skipping 1096 matching lines @@
         m_autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
     m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
 
     populateExplicitGridAndOrderIterator();
 
     // We clear the dirty bit here as the grid sizes have been updated.
     m_gridIsDirty = false;
 
     Vector<LayoutBox*> autoMajorAxisAutoGridItems;
     Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
-    m_hasAnyOrthogonalChild = false;
+    m_orthogonalChildren.shrink(0);
     for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
         if (child->isOutOfFlowPositioned())
             continue;
 
-        m_hasAnyOrthogonalChild = m_hasAnyOrthogonalChild || isOrthogonalChild(*child);
+        if (isOrthogonalChild(*child))
+            m_orthogonalChildren.append(child);
 
         GridArea area = cachedGridArea(*child);
         if (!area.rows.isIndefinite())
             area.rows.translate(abs(m_smallestRowStart));
         if (!area.columns.isIndefinite())
             area.columns.translate(abs(m_smallestColumnStart));
         m_gridItemArea.set(child, area);
 
         if (area.rows.isIndefinite() || area.columns.isIndefinite()) {
             GridSpan majorAxisPositions = (autoPlacementMajorAxisDirection() == ForColumns) ? area.columns : area.rows;
@@ skipping 1080 matching lines @@
         GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const
 {
     SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
     return m_hasDefiniteLogicalHeight.value();
 }
 
 } // namespace blink