[css-flexbox] Merge align-content and justify-content handling

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

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 621 matching lines @@
     case WritingMode::kVerticalLr:
     case WritingMode::kVerticalRl:
       return Style()->IsLeftToRightDirection()
                  ? TransformedWritingMode::kTopToBottomWritingMode
                  : TransformedWritingMode::kBottomToTopWritingMode;
   }
   NOTREACHED();
   return TransformedWritingMode::kTopToBottomWritingMode;
 }
 
+StyleContentAlignmentData LayoutFlexibleBox::ResolvedJustifyContent() const {
+  ContentPosition position = StyleRef().ResolvedJustifyContentPosition(
+      ContentAlignmentNormalBehavior());
+  ContentDistributionType distribution =
+      StyleRef().ResolvedJustifyContentDistribution(
+          ContentAlignmentNormalBehavior());
+  OverflowAlignment overflow = StyleRef().JustifyContentOverflowAlignment();
+  // For flex, justify-content: stretch behaves as flex-start:
+  // https://drafts.csswg.org/css-align/#distribution-flex
+  if (distribution == kContentDistributionStretch) {
+    position = kContentPositionFlexStart;
+    distribution = kContentDistributionDefault;
+  }
+  return StyleContentAlignmentData(position, distribution, overflow);
+}
+
+StyleContentAlignmentData LayoutFlexibleBox::ResolvedAlignContent() const {
+  ContentPosition position =
+      StyleRef().ResolvedAlignContentPosition(ContentAlignmentNormalBehavior());
+  ContentDistributionType distribution =
+      StyleRef().ResolvedAlignContentDistribution(
+          ContentAlignmentNormalBehavior());
+  OverflowAlignment overflow = StyleRef().AlignContentOverflowAlignment();
+  return StyleContentAlignmentData(position, distribution, overflow);
+}
+
 LayoutUnit LayoutFlexibleBox::FlowAwareBorderStart() const {
   if (IsHorizontalFlow())
     return IsLeftToRightFlow() ? BorderLeft() : BorderRight();
   return IsLeftToRightFlow() ? BorderTop() : BorderBottom();
 }
 
 LayoutUnit LayoutFlexibleBox::FlowAwareBorderEnd() const {
   if (IsHorizontalFlow())
     return IsLeftToRightFlow() ? BorderRight() : BorderLeft();
   return IsLeftToRightFlow() ? BorderBottom() : BorderTop();
@@ skipping 842 matching lines @@
   if (total_violation)
     FreezeViolations(total_violation < 0 ? max_violations : min_violations,
                      remaining_free_space, total_flex_grow, total_flex_shrink,
                      total_weighted_flex_shrink);
   else
     remaining_free_space -= used_free_space;
 
   return !total_violation;
 }
 
-static LayoutUnit InitialJustifyContentOffset(
+static LayoutUnit InitialContentPositionOffset(
     LayoutUnit available_free_space,
-    ContentPosition justify_content,
-    ContentDistributionType justify_content_distribution,
-    unsigned number_of_children) {
-  if (justify_content == kContentPositionFlexEnd)
+    const StyleContentAlignmentData& data,
+    unsigned number_of_items) {
+  if (data.GetPosition() == kContentPositionFlexEnd)
     return available_free_space;
-  if (justify_content == kContentPositionCenter)
+  if (data.GetPosition() == kContentPositionCenter)
     return available_free_space / 2;
-  if (justify_content_distribution == kContentDistributionSpaceAround) {
-    if (available_free_space > 0 && number_of_children)
-      return available_free_space / (2 * number_of_children);
+  if (data.Distribution() == kContentDistributionSpaceAround) {
+    if (available_free_space > 0 && number_of_items)
+      return available_free_space / (2 * number_of_items);
 
     return available_free_space / 2;
   }
   return LayoutUnit();
 }
 
-static LayoutUnit JustifyContentSpaceBetweenChildren(
+static LayoutUnit ContentDistributionSpaceBetweenChildren(
     LayoutUnit available_free_space,
-    ContentDistributionType justify_content_distribution,
-    unsigned number_of_children) {
-  if (available_free_space > 0 && number_of_children > 1) {
-    if (justify_content_distribution == kContentDistributionSpaceBetween)
-      return available_free_space / (number_of_children - 1);
-    if (justify_content_distribution == kContentDistributionSpaceAround)
-      return available_free_space / number_of_children;
+    const StyleContentAlignmentData& data,
+    unsigned number_of_items) {
+  if (available_free_space > 0 && number_of_items > 1) {
+    if (data.Distribution() == kContentDistributionSpaceBetween)
+      return available_free_space / (number_of_items - 1);
+    if (data.Distribution() == kContentDistributionSpaceAround ||
+        data.Distribution() == kContentDistributionStretch)
+      return available_free_space / number_of_items;
   }
   return LayoutUnit();
 }
 
 static LayoutUnit AlignmentOffset(LayoutUnit available_free_space,
                                   ItemPosition position,
                                   LayoutUnit ascent,
                                   LayoutUnit max_ascent,
                                   bool is_wrap_reverse) {
   switch (position) {
@@ skipping 46 matching lines @@
   else
     child.SetOverrideLogicalContentWidth(child_preferred_size);
 }
 
 LayoutUnit LayoutFlexibleBox::StaticMainAxisPositionForPositionedChild(
     const LayoutBox& child) {
   const LayoutUnit available_space =
       MainAxisContentExtent(ContentLogicalHeight()) -
       MainAxisExtentForChild(child);
 
-  ContentPosition position = StyleRef().ResolvedJustifyContentPosition(
-      ContentAlignmentNormalBehavior());
-  ContentDistributionType distribution =
-      StyleRef().ResolvedJustifyContentDistribution(
-          ContentAlignmentNormalBehavior());
-  LayoutUnit offset =
-      InitialJustifyContentOffset(available_space, position, distribution, 1);
+  LayoutUnit offset = InitialContentPositionOffset(available_space,
+                                                   ResolvedJustifyContent(), 1);
   if (StyleRef().FlexDirection() == kFlowRowReverse ||
       StyleRef().FlexDirection() == kFlowColumnReverse)
     offset = available_space - offset;
   return offset;
 }
 
 LayoutUnit LayoutFlexibleBox::StaticCrossAxisPositionForPositionedChild(
     const LayoutBox& child) {
   LayoutUnit available_space =
       CrossAxisContentExtent() - CrossAxisExtentForChild(child);
@@ skipping 151 matching lines @@
 }
 
 DISABLE_CFI_PERF
 void LayoutFlexibleBox::LayoutAndPlaceChildren(
     LayoutUnit& cross_axis_offset,
     Vector<FlexItem>& children,
     LayoutUnit available_free_space,
     bool relayout_children,
     SubtreeLayoutScope& layout_scope,
     Vector<LineContext>& line_contexts) {
-  ContentPosition position = StyleRef().ResolvedJustifyContentPosition(
-      ContentAlignmentNormalBehavior());
-  ContentDistributionType distribution =
-      StyleRef().ResolvedJustifyContentDistribution(
-          ContentAlignmentNormalBehavior());
+  const StyleContentAlignmentData justify_content = ResolvedJustifyContent();
 
   LayoutUnit auto_margin_offset =
       AutoMarginOffsetInMainAxis(children, available_free_space);
   LayoutUnit main_axis_offset =
       FlowAwareBorderStart() + FlowAwarePaddingStart();
-  main_axis_offset += InitialJustifyContentOffset(
-      available_free_space, position, distribution, children.size());
+  main_axis_offset += InitialContentPositionOffset(
+      available_free_space, justify_content, children.size());
   if (Style()->FlexDirection() == kFlowRowReverse &&
       ShouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     main_axis_offset += IsHorizontalFlow() ? VerticalScrollbarWidth()
                                            : HorizontalScrollbarHeight();
 
   LayoutUnit total_main_extent = MainAxisExtent();
   if (!ShouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     total_main_extent -= IsHorizontalFlow() ? VerticalScrollbarWidth()
                                             : HorizontalScrollbarHeight();
   LayoutUnit max_ascent, max_descent;  // Used when align-items: baseline.
@@ skipping 76 matching lines @@
     LayoutPoint child_location(
         should_flip_main_axis
             ? total_main_extent - main_axis_offset - child_main_extent
             : main_axis_offset,
         cross_axis_offset + FlowAwareMarginBeforeForChild(*child));
     SetFlowAwareLocationForChild(*child, child_location);
     main_axis_offset += child_main_extent + FlowAwareMarginEndForChild(*child);
 
     if (i != children.size() - 1) {
       // The last item does not get extra space added.
-      main_axis_offset += JustifyContentSpaceBetweenChildren(
-          available_free_space, distribution, children.size());
+      main_axis_offset += ContentDistributionSpaceBetweenChildren(
+          available_free_space, justify_content, children.size());
     }
 
     if (is_paginated)
       UpdateFragmentationInfoForChild(*child);
   }
 
   if (IsColumnFlow())
     SetLogicalHeight(std::max(
         LogicalHeight(), main_axis_offset + FlowAwareBorderEnd() +
                              FlowAwarePaddingEnd() + ScrollbarLogicalHeight()));
@@ skipping 10 matching lines @@
     number_of_in_flow_children_on_first_line_ = children.size();
   line_contexts.push_back(LineContext(cross_axis_offset,
                                       max_child_cross_axis_extent, max_ascent,
                                       std::move(children)));
   cross_axis_offset += max_child_cross_axis_extent;
 }
 
 void LayoutFlexibleBox::LayoutColumnReverse(const Vector<FlexItem>& children,
                                             LayoutUnit cross_axis_offset,
                                             LayoutUnit available_free_space) {
-  ContentPosition position = StyleRef().ResolvedJustifyContentPosition(
-      ContentAlignmentNormalBehavior());
-  ContentDistributionType distribution =
-      StyleRef().ResolvedJustifyContentDistribution(
-          ContentAlignmentNormalBehavior());
+  const StyleContentAlignmentData justify_content = ResolvedJustifyContent();
 
   // This is similar to the logic in layoutAndPlaceChildren, except we place
   // the children starting from the end of the flexbox. We also don't need to
   // layout anything since we're just moving the children to a new position.
   LayoutUnit main_axis_offset =
       LogicalHeight() - FlowAwareBorderEnd() - FlowAwarePaddingEnd();
-  main_axis_offset -= InitialJustifyContentOffset(
-      available_free_space, position, distribution, children.size());
+  main_axis_offset -= InitialContentPositionOffset(
+      available_free_space, justify_content, children.size());
   main_axis_offset -= IsHorizontalFlow() ? VerticalScrollbarWidth()
                                          : HorizontalScrollbarHeight();
 
   for (size_t i = 0; i < children.size(); ++i) {
     LayoutBox* child = children[i].box;
 
     DCHECK(!child->IsOutOfFlowPositioned());
 
     main_axis_offset -=
         MainAxisExtentForChild(*child) + FlowAwareMarginEndForChild(*child);
 
     SetFlowAwareLocationForChild(
         *child,
         LayoutPoint(main_axis_offset,
                     cross_axis_offset + FlowAwareMarginBeforeForChild(*child)));
 
     main_axis_offset -= FlowAwareMarginStartForChild(*child);
 
-    main_axis_offset -= JustifyContentSpaceBetweenChildren(
-        available_free_space, distribution, children.size());
+    main_axis_offset -= ContentDistributionSpaceBetweenChildren(
+        available_free_space, justify_content, children.size());
   }
 }
 
-static LayoutUnit InitialAlignContentOffset(
-    LayoutUnit available_free_space,
-    ContentPosition align_content,
-    ContentDistributionType align_content_distribution,
-    unsigned number_of_lines) {
-  if (number_of_lines <= 1)
-    return LayoutUnit();
-  if (align_content == kContentPositionFlexEnd)
-    return available_free_space;
-  if (align_content == kContentPositionCenter)
-    return available_free_space / 2;
-  if (align_content_distribution == kContentDistributionSpaceAround) {
-    if (available_free_space > 0 && number_of_lines)
-      return available_free_space / (2 * number_of_lines);
-    if (available_free_space < 0)
-      return available_free_space / 2;
-  }
-  return LayoutUnit();
-}
-
-static LayoutUnit AlignContentSpaceBetweenChildren(
-    LayoutUnit available_free_space,
-    ContentDistributionType align_content_distribution,
-    unsigned number_of_lines) {
-  if (available_free_space > 0 && number_of_lines > 1) {
-    if (align_content_distribution == kContentDistributionSpaceBetween)
-      return available_free_space / (number_of_lines - 1);
-    if (align_content_distribution == kContentDistributionSpaceAround ||
-        align_content_distribution == kContentDistributionStretch)
-      return available_free_space / number_of_lines;
-  }
-  return LayoutUnit();
-}
-
 void LayoutFlexibleBox::AlignFlexLines(Vector<LineContext>& line_contexts) {
-  ContentPosition position =
-      StyleRef().ResolvedAlignContentPosition(ContentAlignmentNormalBehavior());
-  ContentDistributionType distribution =
-      StyleRef().ResolvedAlignContentDistribution(
-          ContentAlignmentNormalBehavior());
+  const StyleContentAlignmentData align_content = ResolvedAlignContent();
 
   // If we have a single line flexbox or a multiline line flexbox with only one
   // flex line, the line height is all the available space. For
   // flex-direction: row, this means we need to use the height, so we do this
   // after calling updateLogicalHeight.
   if (line_contexts.size() == 1) {
     line_contexts[0].cross_axis_extent = CrossAxisContentExtent();
     return;
   }
 
-  if (position == kContentPositionFlexStart)
+  if (align_content.GetPosition() == kContentPositionFlexStart)
     return;
 
   LayoutUnit available_cross_axis_space = CrossAxisContentExtent();
   for (size_t i = 0; i < line_contexts.size(); ++i)
     available_cross_axis_space -= line_contexts[i].cross_axis_extent;
 
-  LayoutUnit line_offset = InitialAlignContentOffset(
-      available_cross_axis_space, position, distribution, line_contexts.size());
+  LayoutUnit line_offset;
+  if (line_contexts.size() > 1) {
+    line_offset = InitialContentPositionOffset(
+        available_cross_axis_space, align_content, line_contexts.size());
+  }
   for (unsigned line_number = 0; line_number < line_contexts.size();
        ++line_number) {
     LineContext& line_context = line_contexts[line_number];
     line_context.cross_axis_offset += line_offset;
     for (size_t child_number = 0; child_number < line_context.flex_items.size();
          ++child_number) {
       FlexItem& flex_item = line_context.flex_items[child_number];
       AdjustAlignmentForChild(*flex_item.box, line_offset);
     }
 
-    if (distribution == kContentDistributionStretch &&
+    if (align_content.Distribution() == kContentDistributionStretch &&
         available_cross_axis_space > 0)
       line_contexts[line_number].cross_axis_extent +=
           available_cross_axis_space /
           static_cast<unsigned>(line_contexts.size());
 
-    line_offset += AlignContentSpaceBetweenChildren(
-        available_cross_axis_space, distribution, line_contexts.size());
+    line_offset += ContentDistributionSpaceBetweenChildren(
+        available_cross_axis_space, align_content, line_contexts.size());
   }
 }
 
 void LayoutFlexibleBox::AdjustAlignmentForChild(LayoutBox& child,
                                                 LayoutUnit delta) {
   DCHECK(!child.IsOutOfFlowPositioned());
 
   SetFlowAwareLocationForChild(child, FlowAwareLocationForChild(child) +
                                           LayoutSize(LayoutUnit(), delta));
 }
@@ skipping 164 matching lines @@
       LayoutUnit original_offset =
           line_contexts[line_number].cross_axis_offset - cross_axis_start_edge;
       LayoutUnit new_offset =
           content_extent - original_offset - line_cross_axis_extent;
       AdjustAlignmentForChild(*flex_item.box, new_offset - original_offset);
     }
   }
 }
 
 }  // namespace blink