[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 446 matching lines @@
   // 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 is
+    // computed again in the updateLogicalWidth call bellow.
+    if (sizesLogicalWidthToFitContent(styleRef().logicalWidth()) ||
+        styleRef().logicalWidth().isIntrinsicOrAuto()) {
+      // We do cache orthogonal items during the placeItemsOnGrid call, which is
+      // executed later. However, we are
+      // only interested on running this logic when we are performing a
+      // relayout, hence we have already cached
+      // the orthogonal items.
+      for (auto* child : m_orthogonalChildren) {
+        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 !=
@@ skipping 1406 matching lines @@
         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 =
@@ skipping 1374 matching lines @@
   if (!m_gridItemArea.isEmpty())
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const {
   SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
   return m_hasDefiniteLogicalHeight.value();
 }
 
 }  // namespace blink