[layoutng] Create correct constraint spaces for children

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/style/ComputedStyle.h"
 #include "platform/LayoutUnit.h"
 #include "platform/Length.h"
@@ skipping 51 matching lines @@
   // TODO(layout-ng): Handle min/max/fit-content
   DCHECK(!length.isMaxSizeNone());
   DCHECK_GE(constraintSpace.ContainerSize().inline_size, LayoutUnit());
 
   if (type == LengthResolveType::MinSize && length.isAuto())
     return LayoutUnit();
 
   if (type == LengthResolveType::MarginBorderPaddingSize && 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::MarginBorderPaddingSize) {
+    border_and_padding =
+        computeBorders(style) + computePadding(constraintSpace, style);
+  }
   LayoutUnit container_size = constraintSpace.ContainerSize().inline_size;
   switch (length.type()) {
     case Auto:
     case FillAvailable: {
       NGBoxStrut margins =
           computeMargins(constraintSpace, style,
                          FromPlatformWritingMode(style.getWritingMode()),
                          FromPlatformDirection(style.direction()));
-      return container_size - margins.InlineSum();
+      return std::max(border_and_padding.InlineSum(),
+                      container_size - margins.InlineSum());
     }
     case Percent:
     case Fixed:
     case Calculated: {
-      // TODO(layout-ng): adjust for border-box
       LayoutUnit value = valueForLength(length, container_size);
-      if (style.boxSizing() == BoxSizingContentBox &&
-          type != LengthResolveType::MarginBorderPaddingSize) {
-        NGBoxStrut border_and_padding =
-            computeBorders(style) + computePadding(constraintSpace, style);
+      if (style.boxSizing() == BoxSizingContentBox) {
         value += border_and_padding.InlineSum();
+      } else {
+        value = std::max(border_and_padding.InlineSum(), value);
       }
       return value;
     }
     case MinContent:
     case MaxContent:
     case FitContent:
       // TODO(layout-ng): implement
-      return LayoutUnit();
+      return border_and_padding.InlineSum();
     case DeviceWidth:
     case DeviceHeight:
     case ExtendToZoom:
       NOTREACHED() << "These should only be used for viewport definitions";
     case MaxSizeNone:
     default:
       NOTREACHED();
-      return LayoutUnit();
+      return border_and_padding.InlineSum();
   }
 }
 
 LayoutUnit resolveBlockLength(const NGConstraintSpace& constraintSpace,
                               const ComputedStyle& style,
                               const Length& length,
                               LayoutUnit contentSize,
                               LengthResolveType type) {
   DCHECK(!length.isMaxSizeNone());
   DCHECK(type != LengthResolveType::MarginBorderPaddingSize);
 
   if (type == LengthResolveType::MinSize && length.isAuto())
     return LayoutUnit();
 
   // Make sure that indefinite percentages resolve to NGSizeIndefinite, not to
   // a random negative number.
   if (length.isPercentOrCalc() &&
       constraintSpace.ContainerSize().block_size == NGSizeIndefinite)
     return contentSize;
 
+  // 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::MarginBorderPaddingSize) {
+    border_and_padding =
+        computeBorders(style) + computePadding(constraintSpace, style);
+  }
   LayoutUnit container_size = constraintSpace.ContainerSize().block_size;
   switch (length.type()) {
     case FillAvailable: {
       NGBoxStrut margins =
           computeMargins(constraintSpace, style,
                          FromPlatformWritingMode(style.getWritingMode()),
                          FromPlatformDirection(style.direction()));
-      return container_size - margins.BlockSum();
+      return std::max(border_and_padding.BlockSum(),
+                      container_size - margins.BlockSum());
     }
     case Percent:
     case Fixed:
     case Calculated: {
-      // TODO(layout-ng): adjust for border-box
       LayoutUnit value = valueForLength(length, container_size);
-      if (style.boxSizing() == BoxSizingContentBox &&
-          type != LengthResolveType::MarginBorderPaddingSize) {
-        NGBoxStrut border_and_padding =
-            computeBorders(style) + computePadding(constraintSpace, style);
+      if (style.boxSizing() == BoxSizingContentBox) {
         value += border_and_padding.BlockSum();
+      } else {
+        value = std::max(border_and_padding.BlockSum(), value);
       }
       return value;
     }
     case Auto:
     case MinContent:
     case MaxContent:
     case FitContent:
+      // Due to how contentSize is calculated, it should always include border
+      // and padding.
+      if (contentSize != LayoutUnit(-1))
+        DCHECK_GE(contentSize, border_and_padding.BlockSum());
       return contentSize;
     case DeviceWidth:
     case DeviceHeight:
     case ExtendToZoom:
       NOTREACHED() << "These should only be used for viewport definitions";
     case MaxSizeNone:
     default:
       NOTREACHED();
-      return LayoutUnit();
+      return border_and_padding.BlockSum();
   }
 }
 
 LayoutUnit computeInlineSizeForFragment(
     const NGConstraintSpace& constraintSpace,
     const ComputedStyle& style) {
   if (constraintSpace.FixedInlineSize())
     return constraintSpace.ContainerSize().inline_size;
 
   LayoutUnit extent =
@@ skipping 88 matching lines @@
   padding.block_start =
       resolveInlineLength(constraintSpace, style, style.paddingBefore(),
                           LengthResolveType::MarginBorderPaddingSize);
   padding.block_end =
       resolveInlineLength(constraintSpace, style, style.paddingAfter(),
                           LengthResolveType::MarginBorderPaddingSize);
   return padding;
 }
 
 }  // namespace blink