[LayoutNG] Allow block-flow layout to be fragmented using new approach.

third_party/WebKit/Source/core/layout/ng/ng_length_utils.cc

 // Copyright 2016 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/ng/ng_length_utils.h"
 
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/style/ComputedStyle.h"
@@ skipping 38 matching lines @@
   if (type == LengthResolveType::kMinSize && length.isAuto())
     return LayoutUnit();
 
   if (type == LengthResolveType::kMarginBorderPaddingSize && length.isAuto())
     return LayoutUnit();
 
   // We don't need this when we're resolving margin/border/padding; skip
   // computing it as an optimization and to simplify the code below.
   NGBoxStrut border_and_padding;
   if (type != LengthResolveType::kMarginBorderPaddingSize) {
-    border_and_padding =
-        ComputeBorders(style) + ComputePadding(constraint_space, style);
+    border_and_padding = ComputeBorders(constraint_space, style) +
+                         ComputePadding(constraint_space, style);
   }
   switch (length.type()) {
     case Auto:
     case FillAvailable: {
       LayoutUnit content_size = constraint_space.AvailableSize().inline_size;
       NGBoxStrut margins = ComputeMargins(
           constraint_space, style,
           FromPlatformWritingMode(style.getWritingMode()), style.direction());
       return std::max(border_and_padding.InlineSum(),
                       content_size - margins.InlineSum());
@@ skipping 60 matching lines @@
   // a random negative number.
   if (length.isPercentOrCalc() &&
       constraint_space.PercentageResolutionSize().block_size ==
           NGSizeIndefinite)
     return content_size;
 
   // We don't need this when we're resolving margin/border/padding; skip
   // computing it as an optimization and to simplify the code below.
   NGBoxStrut border_and_padding;
   if (type != LengthResolveType::kMarginBorderPaddingSize) {
-    border_and_padding =
-        ComputeBorders(style) + ComputePadding(constraint_space, style);
+    border_and_padding = ComputeBorders(constraint_space, style) +
+                         ComputePadding(constraint_space, style);
   }
   switch (length.type()) {
     case FillAvailable: {
       LayoutUnit content_size = constraint_space.AvailableSize().block_size;
       NGBoxStrut margins = ComputeMargins(
           constraint_space, style,
           FromPlatformWritingMode(style.getWritingMode()), style.direction());
       return std::max(border_and_padding.BlockSum(),
                       content_size - margins.BlockSum());
     }
@@ skipping 39 matching lines @@
   NGConstraintSpaceBuilder builder(writing_mode);
   builder.SetInitialContainingBlockSize(
       NGPhysicalSize{LayoutUnit(), LayoutUnit()});
   NGConstraintSpace* space = builder.ToConstraintSpace(writing_mode);
 
   MinAndMaxContentSizes computed_sizes;
   Length inline_size = style.logicalWidth();
   if (inline_size.isAuto()) {
     CHECK(min_and_max.has_value());
     NGBoxStrut border_and_padding =
-        ComputeBorders(style) + ComputePadding(*space, style);
+        ComputeBorders(*space, style) + ComputePadding(*space, style);
     computed_sizes.min_content =
         min_and_max->min_content + border_and_padding.InlineSum();
     computed_sizes.max_content =
         min_and_max->max_content + border_and_padding.InlineSum();
   } else {
     computed_sizes.min_content = computed_sizes.max_content =
         ResolveInlineLength(*space, style, min_and_max, inline_size,
                             LengthResolveType::kContentSize);
   }
 
@@ skipping 134 matching lines @@
       LengthResolveType::kMarginBorderPaddingSize);
   physical_dim.top = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginTop(),
       LengthResolveType::kMarginBorderPaddingSize);
   physical_dim.bottom = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginBottom(),
       LengthResolveType::kMarginBorderPaddingSize);
   return physical_dim.ConvertToLogical(writing_mode, direction);
 }
 
-NGBoxStrut ComputeBorders(const ComputedStyle& style) {
+NGBoxStrut ComputeBorders(const NGConstraintSpace& constraint_space,
+                          const ComputedStyle& style) {
+  // If we are producing an anonymous fragment (e.g. a column) we shouldn't
+  // have any borders.
+  if (constraint_space.IsAnonymous())
+    return NGBoxStrut();
+
   NGBoxStrut borders;
   borders.inline_start = LayoutUnit(style.borderStartWidth());
   borders.inline_end = LayoutUnit(style.borderEndWidth());
   borders.block_start = LayoutUnit(style.borderBeforeWidth());
   borders.block_end = LayoutUnit(style.borderAfterWidth());
   return borders;
 }
 
 NGBoxStrut ComputePadding(const NGConstraintSpace& constraint_space,
                           const ComputedStyle& style) {
+  // If we are producing an anonymous fragment (e.g. a column) we shouldn't
+  // have any padding.
+  if (constraint_space.IsAnonymous())
+    return NGBoxStrut();
+
   // We don't need these for padding computations
   MinAndMaxContentSizes empty_sizes;
   // Padding always gets computed relative to the inline size:
   // https://www.w3.org/TR/CSS2/box.html#value-def-padding-width
   NGBoxStrut padding;
   padding.inline_start = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.paddingStart(),
       LengthResolveType::kMarginBorderPaddingSize);
   padding.inline_end = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.paddingEnd(),
@@ skipping 31 matching lines @@
                              Optional<LayoutUnit> min,
                              Optional<LayoutUnit> max) {
   if (max && length > max.value())
     length = max.value();
   if (min && length < min.value())
     length = min.value();
   return length;
 }
 
 }  // namespace blink