[css-align] Don't resolve 'auto' values for computed style.

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 79 matching lines @@
   // layout of the grid, for that reason we don't need to mark the grid as dirty
   // when they are removed.
   if (child->IsOutOfFlowPositioned())
     return;
 
   // The grid needs to be recomputed as it might contain auto-placed items that
   // will change their position.
   DirtyGrid();
 }
 
+bool LayoutGrid::SelfAlignmentChangedToStretchInRowAxis(
+    const ComputedStyle& old_style,
+    const ComputedStyle& new_style,
+    const LayoutBox& child) {
+  return child.StyleRef()
+                 .ResolvedJustifySelf(SelfAlignmentNormalBehavior(&child),
+                                      &old_style)
+                 .GetPosition() != kItemPositionStretch &&
+         child.StyleRef()
+                 .ResolvedJustifySelf(SelfAlignmentNormalBehavior(&child),
+                                      &new_style)
+                 .GetPosition() == kItemPositionStretch;
+}
+
+bool LayoutGrid::SelfAlignmentChangedFromStretchInRowAxis(
+    const ComputedStyle& old_style,
+    const ComputedStyle& new_style,
+    const LayoutBox& child) {
+  return child.StyleRef()
+                 .ResolvedJustifySelf(SelfAlignmentNormalBehavior(&child),
+                                      &old_style)
+                 .GetPosition() == kItemPositionStretch &&
+         child.StyleRef()
+                 .ResolvedJustifySelf(SelfAlignmentNormalBehavior(&child),
+                                      &new_style)
+                 .GetPosition() != kItemPositionStretch;
+}
+
+bool LayoutGrid::SelfAlignmentChangedFromStretchInColumnAxis(
+    const ComputedStyle& old_style,
+    const ComputedStyle& new_style,
+    const LayoutBox& child) {
+  return child.StyleRef()
+                 .ResolvedAlignSelf(SelfAlignmentNormalBehavior(&child),
+                                    &old_style)
+                 .GetPosition() == kItemPositionStretch &&
+         child.StyleRef()
+                 .ResolvedAlignSelf(SelfAlignmentNormalBehavior(&child),
+                                    &new_style)
+                 .GetPosition() != kItemPositionStretch;
+}
+
 void LayoutGrid::StyleDidChange(StyleDifference diff,
                                 const ComputedStyle* old_style) {
   LayoutBlock::StyleDidChange(diff, old_style);
   if (!old_style)
     return;
 
+  const ComputedStyle& new_style = StyleRef();
+  if (old_style &&
+      old_style->ResolvedAlignItems(SelfAlignmentNormalBehavior(this))
+              .GetPosition() == kItemPositionStretch &&
+      diff.NeedsFullLayout()) {
+    // Grid items that were not previously stretched in row-axis need to be
+    // relayed out so we can compute new available space.
+    // Grid items that were previously stretching in column-axis need to be
+    // relayed out so we can compute new available space.

[cbiesinger, 2017/05/24 16:54:15]

This comment is not quite correct -- in the row axis you check if it changed
either to or from stretching. In the column axis you only check if it changed
from stretching.

And why don't you need to relayout a child if it now stretching but didn't use
to?

[jfernandez, 2017/05/24 22:46:58]

The reason is that such case, to-stretch in the column axis, is already handled
by the regular Grid layout logic (applyStetchAlignmentIfNeeded). The item will
have a new overrideHeight and will be marked for layout (if needed). 

In case of from-stretch in the column axis, the function mentioned before is not
executed because he item has not stretch alignment anymore. We just clear the
overrideHeight. This new code ensures the item is marked for layout as well.

In the case of the changes applying to the row-axis properties, stretching
is not handled by the Grid logic. The general LayoutBox width computation
stretches the item (by default), so we only avoid that by applying the
fit-content logic in case of no-stretch alignment. In both cases we need to
ensure the item will be laid out.
As I commented before, this is already done by the Grid layout logic, as part of
the applyStetchAlignmentIfNeeded function.

+    // This is only necessary for stretching since other alignment values don't
+    // change the size of the box.
+    for (LayoutBox* child = FirstInFlowChildBox(); child;
+         child = child->NextInFlowSiblingBox()) {
+      if (SelfAlignmentChangedToStretchInRowAxis(*old_style, new_style,
+                                                 *child) ||
+          SelfAlignmentChangedFromStretchInRowAxis(*old_style, new_style,
+                                                   *child) ||
+          SelfAlignmentChangedFromStretchInColumnAxis(*old_style, new_style,
+                                                      *child)) {
+        child->SetNeedsLayout(LayoutInvalidationReason::kGridChanged);
+      }
+    }
+  }
+
   // FIXME: The following checks could be narrowed down if we kept track of
   // which type of grid items we have:
   // - explicit grid size changes impact negative explicitely positioned and
   //   auto-placed grid items.
   // - named grid lines only impact grid items with named grid lines.
   // - auto-flow changes only impacts auto-placed children.
 
   if (ExplicitGridDidResize(*old_style) ||
       NamedGridLinesDefinitionDidChange(*old_style) ||
       old_style->GetGridAutoFlow() != StyleRef().GetGridAutoFlow() ||
@@ skipping 1407 matching lines @@
   // values. Hence, we need to compute margins in order to determine the
   // available height before stretching.
   return grid_area_breadth_for_child -
          (child.NeedsLayout()
               ? ComputeMarginLogicalSizeForChild(kBlockDirection, child)
               : MarginLogicalHeightForChild(child));
 }
 
 StyleSelfAlignmentData LayoutGrid::AlignSelfForChild(
     const LayoutBox& child) const {
-  if (!child.IsAnonymous()) {
-    return child.StyleRef().ResolvedAlignSelf(
-        SelfAlignmentNormalBehavior(&child));
-  }
-  // All the 'auto' values has been solved by the StyleAdjuster, but it's
-  // possible that some grid items generate Anonymous boxes, which need to be
-  // solved during layout.
   return child.StyleRef().ResolvedAlignSelf(SelfAlignmentNormalBehavior(&child),
                                             Style());
 }
 
 StyleSelfAlignmentData LayoutGrid::JustifySelfForChild(
     const LayoutBox& child) const {
-  if (!child.IsAnonymous()) {
-    return child.StyleRef().ResolvedJustifySelf(
-        SelfAlignmentNormalBehavior(&child));
-  }
-  // All the 'auto' values has been solved by the StyleAdjuster, but it's
-  // possible that some grid items generate Anonymous boxes, which need to be
-  // solved during layout.
   return child.StyleRef().ResolvedJustifySelf(
       SelfAlignmentNormalBehavior(&child), Style());
 }
 
 GridTrackSizingDirection LayoutGrid::FlowAwareDirectionForChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction) const {
   return !IsOrthogonalChild(child)
              ? direction
              : (direction == kForColumns ? kForRows : kForColumns);
@@ skipping 827 matching lines @@
   if (direction == kForRows)
     return grid.NumTracks(kForRows);
 
   return grid.NumTracks(kForRows)
              ? grid.NumTracks(kForColumns)
              : GridPositionsResolver::ExplicitGridColumnCount(
                    StyleRef(), grid.AutoRepeatTracks(kForColumns));
 }
 
 }  // namespace blink