[css-grid] Refactor the extent for baseline alignment computation

third_party/WebKit/Source/core/layout/GridTrackSizingAlgorithm.cpp

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/GridTrackSizingAlgorithm.h"
 
 #include "core/layout/Grid.h"
 #include "core/layout/LayoutGrid.h"
 #include "platform/LengthFunctions.h"
 
@@ skipping 269 matching lines @@
                                                   LayoutUnit(-1));
     child.SetNeedsLayout(LayoutInvalidationReason::kGridChanged, kMarkOnlyThis);
   }
 
   // We need to clear the stretched height to properly compute logical height
   // during layout.
   if (child.NeedsLayout())
     child.ClearOverrideLogicalContentHeight();
 
   child.LayoutIfNeeded();
-  GridAxis baseline_axis = GetLayoutGrid()->IsOrthogonalChild(child)
-                               ? kGridRowAxis
-                               : kGridColumnAxis;
-  if (GetLayoutGrid()->IsBaselineAlignmentForChild(child, baseline_axis) &&
-      GetLayoutGrid()->IsBaselineContextComputed(baseline_axis)) {
-    auto& group =
-        GetLayoutGrid()->GetBaselineGroupForChild(child, baseline_axis);
-    return group.MaxAscent() + group.MaxDescent();
-  }
+
+  if (auto baseline_extent = ExtentForBaselineAlignment(child))
+    return baseline_extent.value();
+
   return child.LogicalHeight() + child.MarginLogicalHeight();
 }
 
 DISABLE_CFI_PERF
 LayoutUnit GridTrackSizingAlgorithmStrategy::MinContentForChild(
     LayoutBox& child) const {
   GridTrackSizingDirection child_inline_direction =
       FlowAwareDirectionForChild(GetLayoutGrid(), child, kForColumns);
   if (Direction() == child_inline_direction) {
     // If |child| has a relative logical width, we shouldn't let it override its
@@ skipping 10 matching lines @@
     // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
     LayoutUnit margin_logical_width =
         child.NeedsLayout() ? ComputeMarginLogicalSizeForChild(
                                   kInlineDirection, GetLayoutGrid(), child)
                             : child.MarginLogicalWidth();
     return child.MinPreferredLogicalWidth() + margin_logical_width;
   }
 
   if (Direction() == kForColumns && !AvailableSpace()) {
     DCHECK(GetLayoutGrid()->IsOrthogonalChild(child));
-    if (GetLayoutGrid()->IsBaselineAlignmentForChild(child, kGridRowAxis) &&
-        GetLayoutGrid()->IsBaselineContextComputed(kGridRowAxis)) {
-      auto& group =
-          GetLayoutGrid()->GetBaselineGroupForChild(child, kGridRowAxis);
-      return group.MaxAscent() + group.MaxDescent();
-    }
+    if (auto baseline_extent = ExtentForBaselineAlignment(child))
+      return baseline_extent.value();
   }
 
   if (UpdateOverrideContainingBlockContentSizeForChild(child,
                                                        child_inline_direction))
     child.SetNeedsLayout(LayoutInvalidationReason::kGridChanged, kMarkOnlyThis);
   return LogicalHeightForChild(child);
 }
 
 DISABLE_CFI_PERF
 LayoutUnit GridTrackSizingAlgorithmStrategy::MaxContentForChild(
@@ skipping 78 matching lines @@
   return algorithm_.FindFrUnitSize(tracks_span, left_over_space);
 }
 
 void GridTrackSizingAlgorithmStrategy::DistributeSpaceToTracks(
     Vector<GridTrack*>& tracks,
     LayoutUnit& available_logical_space) const {
   algorithm_.DistributeSpaceToTracks<kMaximizeTracks>(tracks, nullptr,
                                                       available_logical_space);
 }
 
+Optional<LayoutUnit>
+GridTrackSizingAlgorithmStrategy::ExtentForBaselineAlignment(
+    LayoutBox& child) const {
+  auto grid = algorithm_.layout_grid_;
+  GridAxis baseline_axis =
+      grid->IsOrthogonalChild(child) ? kGridRowAxis : kGridColumnAxis;
+  if (!grid->IsBaselineAlignmentForChild(child, baseline_axis) ||
+      !grid->IsBaselineContextComputed(baseline_axis))
+    return WTF::kNullopt;
+
+  auto& group = grid->GetBaselineGroupForChild(child, baseline_axis);
+  return group.MaxAscent() + group.MaxDescent();
+}
+
 LayoutUnit DefiniteSizeStrategy::MinLogicalWidthForChild(
     LayoutBox& child,
     Length child_min_size,
     GridTrackSizingDirection child_inline_direction) const {
   LayoutUnit margin_logical_width = ComputeMarginLogicalSizeForChild(
       kInlineDirection, GetLayoutGrid(), child);
   return child.ComputeLogicalWidthUsing(
              kMinSize, child_min_size,
              OverrideContainingBlockContentSizeForChild(child,
                                                         child_inline_direction),
@@ skipping 1050 matching lines @@
   DCHECK(algorithm_.IsValidTransition());
   DCHECK(!algorithm_.needs_setup_);
 }
 
 GridTrackSizingAlgorithm::StateMachine::~StateMachine() {
   algorithm_.AdvanceNextState();
   algorithm_.needs_setup_ = true;
 }
 
 }  // namespace blink