[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 167 matching lines @@
   track_sizing_algorithm_.Run();
 
 #if DCHECK_IS_ON()
   DCHECK(track_sizing_algorithm_.TracksAreWiderThanMinTrackBreadth());
 #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();
-
   // 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)
+  if (!track_sizing_algorithm_.GetGrid().HasAnyOrthogonalGridItem())

[svillar, 2017/05/11 07:15:04]

This method is executed only as part of the layout process so you can directly
use the grid stored in LayoutGrid.

     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) {
-    SetLogicalHeight(ComputeTrackBasedLogicalHeight() +
-                     BorderAndPaddingLogicalHeight() +
-                     ScrollbarLogicalHeight());
-  }
 }
 
 void LayoutGrid::UpdateBlockLayout(bool relayout_children) {
   DCHECK(NeedsLayout());
 
   // We cannot perform a simplifiedLayout() on a dirty grid that
   // has positioned items to be laid out.
   if (!relayout_children &&
       (!grid_.NeedsItemsPlacement() || !PosChildNeedsLayout()) &&
       SimplifiedLayout())
@@ skipping 19 matching lines @@
          child = child->NextInFlowSiblingBox())
       child->ClearOverrideSize();
 
     UpdateLogicalWidth();
 
     TextAutosizer::LayoutScope text_autosizer_layout_scope(this, &layout_scope);
 
     LayoutUnit available_space_for_columns = AvailableLogicalWidth();
     PlaceItemsOnGrid(grid_, available_space_for_columns);
 
+    // TODO (lajava): Items with relative size may have problems to synthesize
+    // a baseline, since we neeed to resolve the size but we haven't defined yet
+    // their corresponding grid area. This may lead to an incorrect baseline
+    // computation, either because relative sizes are resolved as 0 (undefined
+    // container's size) or they are based on the grid container's size instead
+    // of the grid area.
+    ComputeBaselineAlignmentContext();
+
     // 1- First, the track sizing algorithm is used to resolve the sizes of the
     // grid columns.
     // At this point the logical width is always definite as the above call to
     // updateLogicalWidth() properly resolves intrinsic sizes. We cannot do the
     // same for heights though because many code paths inside
     // updateLogicalHeight() require a previous call to setLogicalHeight() to
     // resolve heights properly (like for positioned items for example).
     ComputeTrackSizesForDefiniteSize(kForColumns, available_space_for_columns);
 
     // We take the chance to store the intrinsic sizes as they are just an
@@ skipping 30 matching lines @@
     LayoutUnit old_client_after_edge = ClientLogicalBottom();
     UpdateLogicalHeight();
 
     // Once grid's indefinite height is resolved, we can compute the
     // available free space for Content Alignment.
     if (!CachedHasDefiniteLogicalHeight()) {
       track_sizing_algorithm_.SetFreeSpace(
           kForRows, LogicalHeight() - track_based_logical_height);
     }
 
-    // TODO (lajava): We need to compute baselines after step 2 so
-    // items with a relative size (percentages) can resolve it before
-    // determining its baseline. However, we only set item's grid area
-    // (via override sizes) as part of the content-sized tracks sizing
-    // logic. Hence, items located at fixed or flexible tracks can't
-    // resolve correctly their size at this stage, which may lead to
-    // an incorrect computation of their shared context's baseline.
-    ComputeBaselineAlignmentContext();
-
     // 3- If the min-content contribution of any grid items have changed based
     // on the row sizes calculated in step 2, steps 1 and 2 are repeated with
     // the new min-content contribution (once only).
     RepeatTracksSizingIfNeeded(available_space_for_columns,
                                ContentLogicalHeight());
 
     // Grid container should have the minimum height of a line if it's editable.
     // That doesn't affect track sizing though.
     if (HasLineIfEmpty())
       SetLogicalHeight(
@@ skipping 1520 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_) {
-    for (const auto& group : context.value->SharedGroups()) {
-      if (group.size() > 1)
-        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(
     LayoutBox& child,
@@ skipping 492 matching lines @@
   if (direction == kForRows)
     return grid.NumTracks(kForRows);
 
   return grid.NumTracks(kForRows)
              ? grid.NumTracks(kForColumns)
              : GridPositionsResolver::ExplicitGridColumnCount(
                    StyleRef(), grid.AutoRepeatTracks(kForColumns));
 }
 
 }  // namespace blink