[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 1483 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)
+    ContentPosition content_position,
+    ContentDistributionType content_distribution,
+    unsigned number_of_items) {
+  if (content_position == kContentPositionFlexEnd)
     return available_free_space;
-  if (justify_content == kContentPositionCenter)
+  if (content_position == 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 (content_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(
+    bool is_align_content,

[jfernandez, 2017/04/21 20:43:21]

I don't like too much the bool argument to change the behavior of the function.
Also, I don't understand why this function should be dependent on the specific
property it handles. 

It's not that justify-content has a different behavior for 'stretch', but it's
an invalid value for that property. We can simply define the behavior of
'stretch' here and let the caller pass the appropriated value. If
justify-content can't have 'stretch' we shouldn't need this conditional clause.

     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;
+    ContentDistributionType content_distribution,
+    unsigned number_of_items) {
+  if (available_free_space > 0 && number_of_items > 1) {
+    if (content_distribution == kContentDistributionSpaceBetween)
+      return available_free_space / (number_of_items - 1);
+    if (content_distribution == kContentDistributionSpaceAround ||
+        (is_align_content &&

[jfernandez, 2017/04/21 20:43:21]

ditto.

+         content_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 52 matching lines @@
   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);
+      InitialContentPositionOffset(available_space, position, distribution, 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 161 matching lines @@
   ContentPosition position = StyleRef().ResolvedJustifyContentPosition(
       ContentAlignmentNormalBehavior());
   ContentDistributionType distribution =
       StyleRef().ResolvedJustifyContentDistribution(
           ContentAlignmentNormalBehavior());
 
   LayoutUnit auto_margin_offset =
       AutoMarginOffsetInMainAxis(children, available_free_space);
   LayoutUnit main_axis_offset =
       FlowAwareBorderStart() + FlowAwarePaddingStart();
-  main_axis_offset += InitialJustifyContentOffset(
+  main_axis_offset += InitialContentPositionOffset(
       available_free_space, position, distribution, 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();
@@ skipping 77 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(
+          false, available_free_space, distribution, children.size());

[jfernandez, 2017/04/21 20:43:21]

Ditto.

     }
 
     if (is_paginated)
       UpdateFragmentationInfoForChild(*child);
   }
 
   if (IsColumnFlow())
     SetLogicalHeight(std::max(
         LogicalHeight(), main_axis_offset + FlowAwareBorderEnd() +
                              FlowAwarePaddingEnd() + ScrollbarLogicalHeight()));
@@ skipping 21 matching lines @@
       ContentAlignmentNormalBehavior());
   ContentDistributionType distribution =
       StyleRef().ResolvedJustifyContentDistribution(
           ContentAlignmentNormalBehavior());
 
   // 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(
+  main_axis_offset -= InitialContentPositionOffset(
       available_free_space, position, distribution, 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(
+        false, available_free_space, distribution, children.size());

[jfernandez, 2017/04/21 20:43:21]

Ditto.

   }
 }
 
-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());
 
   // 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)
     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, position,
+                                     distribution, 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 &&
         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(
+        true, available_cross_axis_space, distribution, line_contexts.size());

[jfernandez, 2017/04/21 20:43:21]

Ditto.

   }
 }
 
 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