[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();
 }
 
+StyleSelfAlignmentData LayoutGrid::SelfAlignmentForChild(
+    GridAxis axis,
+    const LayoutBox& child,
+    const ComputedStyle* style) const {
+  return axis == kGridRowAxis ? JustifySelfForChild(child, style)
+                              : AlignSelfForChild(child, style);
+}
+
+bool LayoutGrid::SelfAlignmentChangedToStretch(GridAxis axis,
+                                               const ComputedStyle& old_style,
+                                               const ComputedStyle& new_style,
+                                               const LayoutBox& child) const {
+  return SelfAlignmentForChild(axis, child, &old_style).GetPosition() !=
+             kItemPositionStretch &&
+         SelfAlignmentForChild(axis, child, &new_style).GetPosition() ==
+             kItemPositionStretch;
+}
+
+bool LayoutGrid::SelfAlignmentChangedFromStretch(GridAxis axis,
+                                                 const ComputedStyle& old_style,
+                                                 const ComputedStyle& new_style,
+                                                 const LayoutBox& child) const {
+  return SelfAlignmentForChild(axis, child, &old_style).GetPosition() ==
+             kItemPositionStretch &&
+         SelfAlignmentForChild(axis, 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()) {
+    // Style changes on the grid container implying stretching (to-stretch) or
+    // shrinking (from-stretch) require the affected items to be laid out again.
+    // These logic only applies to 'stretch' since the rest of the alignment
+    // values don't change the size of the box.
+    // In any case, the items' overrideSize will be cleared and recomputed (if
+    // necessary)  as part of the Grid layout logic, triggered by this style
+    // change.
+    for (LayoutBox* child = FirstInFlowChildBox(); child;
+         child = child->NextInFlowSiblingBox()) {
+      if (SelfAlignmentChangedToStretch(kGridRowAxis, *old_style, new_style,
+                                        *child) ||
+          SelfAlignmentChangedFromStretch(kGridRowAxis, *old_style, new_style,
+                                          *child) ||
+          SelfAlignmentChangedToStretch(kGridColumnAxis, *old_style, new_style,
+                                        *child) ||
+          SelfAlignmentChangedFromStretch(kGridColumnAxis, *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 1404 matching lines @@
   // performed before children are laid out, so we can't use the child cached
   // 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.
+    const LayoutBox& child,
+    const ComputedStyle* style) const {
+  if (!style)
+    style = Style();
   return child.StyleRef().ResolvedAlignSelf(SelfAlignmentNormalBehavior(&child),
-                                            Style());
+                                            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.
+    const LayoutBox& child,
+    const ComputedStyle* style) const {
+  if (!style)
+    style = Style();
   return child.StyleRef().ResolvedJustifySelf(
-      SelfAlignmentNormalBehavior(&child), Style());
+      SelfAlignmentNormalBehavior(&child), style);
 }
 
 GridTrackSizingDirection LayoutGrid::FlowAwareDirectionForChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction) const {
   return !IsOrthogonalChild(child)
              ? direction
              : (direction == kForColumns ? kForRows : kForColumns);
 }
 
@@ skipping 207 matching lines @@
                                            GridAxis baseline_axis) const {
   return IsHorizontalGridAxis(baseline_axis) &&
          ((child.StyleRef().IsFlippedBlocksWritingMode() &&
            !StyleRef().IsFlippedBlocksWritingMode()) ||
           (child.StyleRef().IsFlippedLinesWritingMode() &&
            StyleRef().IsFlippedBlocksWritingMode()));
 }
 
 bool LayoutGrid::IsBaselineAlignmentForChild(const LayoutBox& child,
                                              GridAxis baseline_axis) const {
-  bool is_column_axis_baseline = baseline_axis == kGridColumnAxis;
-  ItemPosition align = is_column_axis_baseline
-                           ? AlignSelfForChild(child).GetPosition()
-                           : JustifySelfForChild(child).GetPosition();
-  bool has_auto_margins = is_column_axis_baseline
+  ItemPosition align =
+      SelfAlignmentForChild(baseline_axis, child).GetPosition();
+  bool has_auto_margins = baseline_axis == kGridColumnAxis
                               ? HasAutoMarginsInColumnAxis(child)
                               : HasAutoMarginsInRowAxis(child);
   return IsBaselinePosition(align) && !has_auto_margins;
 }
 
 const BaselineGroup& LayoutGrid::GetBaselineGroupForChild(
     const LayoutBox& child,
     GridAxis baseline_axis) const {
   DCHECK(IsBaselineAlignmentForChild(child, baseline_axis));
   auto& grid = track_sizing_algorithm_.GetGrid();
   bool is_column_axis_baseline = baseline_axis == kGridColumnAxis;
   bool is_row_axis_context = is_column_axis_baseline;
   const auto& span = is_row_axis_context
                          ? grid.GridItemSpan(child, kForRows)
                          : grid.GridItemSpan(child, kForColumns);
   auto& contexts_map = is_row_axis_context ? row_axis_alignment_context_
                                            : col_axis_alignment_context_;
   auto* context = contexts_map.at(span.StartLine());
   DCHECK(context);
-  ItemPosition align = is_column_axis_baseline
-                           ? AlignSelfForChild(child).GetPosition()
-                           : JustifySelfForChild(child).GetPosition();
+  ItemPosition align =
+      SelfAlignmentForChild(baseline_axis, child).GetPosition();
   return context->GetSharedGroup(child, align);
 }
 
 LayoutUnit LayoutGrid::MarginOverForChild(const LayoutBox& child,
                                           GridAxis axis) const {
   return IsHorizontalGridAxis(axis) ? child.MarginRight() : child.MarginTop();
 }
 
 LayoutUnit LayoutGrid::MarginUnderForChild(const LayoutBox& child,
                                            GridAxis axis) const {
@@ skipping 97 matching lines @@
   bool is_column_axis_baseline = baseline_axis == kGridColumnAxis;
   bool is_row_axis_context = is_column_axis_baseline;
   const auto& span = is_row_axis_context
                          ? grid.GridItemSpan(child, kForRows)
                          : grid.GridItemSpan(child, kForColumns);
   auto& contexts_map = is_row_axis_context ? row_axis_alignment_context_
                                            : col_axis_alignment_context_;
   auto add_result = contexts_map.insert(span.StartLine(), nullptr);
 
   // Looking for a compatible baseline-sharing group.
-  ItemPosition align = is_column_axis_baseline
-                           ? AlignSelfForChild(child).GetPosition()
-                           : JustifySelfForChild(child).GetPosition();
+  ItemPosition align =
+      SelfAlignmentForChild(baseline_axis, child).GetPosition();
   if (add_result.is_new_entry) {
     add_result.stored_value->value =
         WTF::MakeUnique<BaselineContext>(child, align, ascent, descent);
   } else {
     auto* context = add_result.stored_value->value.get();
     context->UpdateSharedGroup(child, align, ascent, descent);
   }
 }
 
 LayoutUnit LayoutGrid::ColumnAxisBaselineOffsetForChild(
@@ skipping 451 matching lines @@
   if (direction == kForRows)
     return grid.NumTracks(kForRows);
 
   return grid.NumTracks(kForRows)
              ? grid.NumTracks(kForColumns)
              : GridPositionsResolver::ExplicitGridColumnCount(
                    StyleRef(), grid.AutoRepeatTracks(kForColumns));
 }
 
 }  // namespace blink