[LayoutNG] Split apart storage for AvailableSize and PercentageSize.

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_fragment.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LayoutUnit.h"
@@ skipping 44 matching lines @@
 }
 
 }  // namespace
 
 LayoutUnit ResolveInlineLength(const NGConstraintSpace& constraintSpace,
                                const ComputedStyle& style,
                                const Length& length,
                                LengthResolveType type) {
   // TODO(layout-ng): Handle min/max/fit-content
   DCHECK(!length.isMaxSizeNone());
-  DCHECK_GE(constraintSpace.ContainerSize().inline_size, LayoutUnit());
+  DCHECK_GE(constraintSpace.AvailableSize().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: {
+      LayoutUnit content_size = constraintSpace.AvailableSize().inline_size;
       NGBoxStrut margins =
           ComputeMargins(constraintSpace, style,
                          FromPlatformWritingMode(style.getWritingMode()),
                          FromPlatformDirection(style.direction()));
       return std::max(border_and_padding.InlineSum(),
-                      container_size - margins.InlineSum());
+                      content_size - margins.InlineSum());
     }
     case Percent:
     case Fixed:
     case Calculated: {
-      LayoutUnit value = valueForLength(length, container_size);
+      LayoutUnit percentage_resolution_size =
+          constraintSpace.PercentageResolutionSize().inline_size;
+      LayoutUnit value = valueForLength(length, percentage_resolution_size);
       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:
@@ skipping 17 matching lines @@
                               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)
+      constraintSpace.PercentageResolutionSize().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: {
+      LayoutUnit content_size = constraintSpace.AvailableSize().block_size;
       NGBoxStrut margins =
           ComputeMargins(constraintSpace, style,
                          FromPlatformWritingMode(style.getWritingMode()),
                          FromPlatformDirection(style.direction()));
       return std::max(border_and_padding.BlockSum(),
-                      container_size - margins.BlockSum());
+                      content_size - margins.BlockSum());
     }
     case Percent:
     case Fixed:
     case Calculated: {
-      LayoutUnit value = valueForLength(length, container_size);
+      LayoutUnit percentage_resolution_size =
+          constraintSpace.PercentageResolutionSize().block_size;
+      LayoutUnit value = valueForLength(length, percentage_resolution_size);
       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:
@@ skipping 11 matching lines @@
     default:
       NOTREACHED();
       return border_and_padding.BlockSum();
   }
 }
 
 LayoutUnit ComputeInlineSizeForFragment(
     const NGConstraintSpace& constraintSpace,
     const ComputedStyle& style) {
   if (constraintSpace.FixedInlineSize())
-    return constraintSpace.ContainerSize().inline_size;
+    return constraintSpace.AvailableSize().inline_size;
 
   LayoutUnit extent =
       ResolveInlineLength(constraintSpace, style, style.logicalWidth(),
                           LengthResolveType::ContentSize);
 
   Length maxLength = style.logicalMaxWidth();
   if (!maxLength.isMaxSizeNone()) {
     LayoutUnit max = ResolveInlineLength(constraintSpace, style, maxLength,
                                          LengthResolveType::MaxSize);
     extent = std::min(extent, max);
   }
 
   LayoutUnit min =
       ResolveInlineLength(constraintSpace, style, style.logicalMinWidth(),
                           LengthResolveType::MinSize);
   extent = std::max(extent, min);
   return extent;
 }
 
 LayoutUnit ComputeBlockSizeForFragment(const NGConstraintSpace& constraintSpace,
                                        const ComputedStyle& style,
                                        LayoutUnit contentSize) {
   if (constraintSpace.FixedBlockSize())
-    return constraintSpace.ContainerSize().block_size;
+    return constraintSpace.AvailableSize().block_size;
 
   LayoutUnit extent =
       ResolveBlockLength(constraintSpace, style, style.logicalHeight(),
                          contentSize, LengthResolveType::ContentSize);
   if (extent == NGSizeIndefinite) {
     DCHECK_EQ(contentSize, NGSizeIndefinite);
     return extent;
   }
 
   Length maxLength = style.logicalMaxHeight();
@@ skipping 62 matching lines @@
   return padding;
 }
 
 void ApplyAutoMargins(const NGConstraintSpace& constraint_space,
                       const ComputedStyle& style,
                       const NGFragment& fragment,
                       NGBoxStrut* margins) {
   DCHECK(margins) << "Margins cannot be NULL here";
   const LayoutUnit used_space = fragment.InlineSize() + margins->InlineSum();
   const LayoutUnit available_space =
-      constraint_space.ContainerSize().inline_size - used_space;
+      constraint_space.AvailableSize().inline_size - used_space;
   if (available_space < LayoutUnit())
     return;
   if (style.marginStart().isAuto() && style.marginEnd().isAuto()) {
     margins->inline_start = available_space / 2;
     margins->inline_end = available_space - margins->inline_start;
   } else if (style.marginStart().isAuto()) {
     margins->inline_start = available_space;
   } else if (style.marginEnd().isAuto()) {
     margins->inline_end = available_space;
   }
 }
 
 }  // namespace blink