[css-grid] Check if baseline alignment affects grid areas sizing

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 171 matching lines @@
 #endif
 }
 
 void LayoutGrid::RepeatTracksSizingIfNeeded(
     LayoutUnit available_space_for_columns,
     LayoutUnit available_space_for_rows) {
   // Baseline alignment may change item's intrinsic size, hence changing its
   // min-content contribution.
   // https://drafts.csswg.org/css-align-3/#baseline-align-content
   // https://drafts.csswg.org/css-align-3/#baseline-align-self
-  bool baseline_affect_intrinsic_width = BaselineMayAffectIntrinsicWidth();
-  bool baseline_affect_intrinsic_height = BaselineMayAffectIntrinsicHeight();
+  bool baseline_affect_intrinsic_width =
+      BaselineMayAffectIntrinsicSize(kForColumns);
+  bool baseline_affect_intrinsic_height =
+      BaselineMayAffectIntrinsicSize(kForRows);
 
   // 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.
   bool has_any_orthogonal =
       track_sizing_algorithm_.GetGrid().HasAnyOrthogonalGridItem();
 
   // TODO (lajava): these are just some 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 (!baseline_affect_intrinsic_width && !baseline_affect_intrinsic_height &&
       !has_any_orthogonal)
     return;
 
   // TODO (lajava): Whenever the min-content contribution of a grid item changes
   // we may need to update the grid container's intrinsic width. The new
   // intrinsic width may also affect the extra Track Sizing algorithm cycles we
   // are about to execute.
   // https://crbug.com/704713
   // https://github.com/w3c/csswg-drafts/issues/1039
 
   // Hence we need to repeat computeUsedBreadthOfGridTracks for both, columns
   // and rows, to determine the final values.
   ComputeTrackSizesForDefiniteSize(kForColumns, available_space_for_columns);
   ComputeTrackSizesForDefiniteSize(kForRows, available_space_for_rows);
 
-  if (baseline_affect_intrinsic_height) {
+  if (baseline_affect_intrinsic_height &&
+      StyleRef().LogicalHeight().IsIntrinsicOrAuto()) {
     SetLogicalHeight(ComputeTrackBasedLogicalHeight() +
                      BorderAndPaddingLogicalHeight() +
                      ScrollbarLogicalHeight());
   }
 }
 
 void LayoutGrid::UpdateBlockLayout(bool relayout_children) {
   DCHECK(NeedsLayout());
 
   // We cannot perform a simplifiedLayout() on a dirty grid that
@@ skipping 1622 matching lines @@
     return child.MarginLogicalHeight() + child.LogicalHeight() - ascent;
   return child.MarginLogicalWidth() + child.LogicalWidth() - ascent;
 }
 
 bool LayoutGrid::IsBaselineContextComputed(GridAxis baseline_axis) const {
   return baseline_axis == kGridColumnAxis
              ? !row_axis_alignment_context_.IsEmpty()
              : !col_axis_alignment_context_.IsEmpty();
 }
 
-bool LayoutGrid::BaselineMayAffectIntrinsicWidth() const {
-  if (!StyleRef().LogicalWidth().IsIntrinsicOrAuto())
-    return false;
-  for (const auto& context : col_axis_alignment_context_) {
+bool LayoutGrid::BaselineMayAffectIntrinsicSize(
+    GridTrackSizingDirection direction) const {
+  const auto& contexts_map = direction == kForColumns
+                                 ? col_axis_alignment_context_
+                                 : row_axis_alignment_context_;
+  for (const auto& context : contexts_map) {
+    auto track_size =
+        track_sizing_algorithm_.GetGridTrackSize(direction, context.key);
+    // TODO(lajava): Should we consider flexible tracks as well ?
+    if (!track_size.IsContentSized())
+      continue;
     for (const auto& group : context.value->SharedGroups()) {
-      if (group.size() > 1)
+      auto grid_area_size =
+          track_sizing_algorithm_.Tracks(direction)[context.key].BaseSize();
+      if ((group.size() > 1) &&
+          (group.MaxAscent() + group.MaxDescent() > grid_area_size))

[svillar, 2017/07/04 09:46:57]

We don't really need to get the area size if group.size() <= 1. I'd do something
like

if (groups.size() <= 1)
   continue;

auto grid_area_size =
track_sizing_algorithm_.Tracks(direction)[context.key].BaseSize();
if ((group.MaxAscent() + group.MaxDescent() > grid_area_size))
    return true;

         return true;
     }
   }
   return false;
 }
 
-bool LayoutGrid::BaselineMayAffectIntrinsicHeight() const {
-  if (!StyleRef().LogicalHeight().IsIntrinsicOrAuto())
-    return false;
-  for (const auto& context : row_axis_alignment_context_) {
-    for (const auto& group : context.value->SharedGroups()) {
-      if (group.size() > 1)
-        return true;
-    }
-  }
-  return false;
-}
 
 void LayoutGrid::ComputeBaselineAlignmentContext() {
   for (auto* child = FirstInFlowChildBox(); child;
        child = child->NextInFlowSiblingBox()) {
     UpdateBaselineAlignmentContextIfNeeded(*child, kGridRowAxis);
     UpdateBaselineAlignmentContextIfNeeded(*child, kGridColumnAxis);
   }
 }
 
 void LayoutGrid::UpdateBaselineAlignmentContextIfNeeded(
@@ skipping 493 matching lines @@
   if (direction == kForRows)
     return grid.NumTracks(kForRows);
 
   return grid.NumTracks(kForRows)
              ? grid.NumTracks(kForColumns)
              : GridPositionsResolver::ExplicitGridColumnCount(
                    StyleRef(), grid.AutoRepeatTracks(kForColumns));
 }
 
 }  // namespace blink