[layoutng] Correctly resolve indefinite percentages

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_margin_strut.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LayoutUnit.h"
 #include "platform/Length.h"
 
 namespace blink {
 // TODO(layout-ng):
 // - Handle border-box correctly
 // - positioned and/or replaced calculations
 // - Handle margins for fill-available and width: auto
 
 LayoutUnit resolveInlineLength(const NGConstraintSpace& constraintSpace,
                                const Length& length,
                                LengthResolveType type) {
   // TODO(layout-ng): Handle min/max/fit-content
   DCHECK(!length.isMaxSizeNone());
+  DCHECK_NE(constraintSpace.ContainerSize().inlineSize, LayoutUnit(-1));

[eae, 2016/08/23 16:50:56]

Can the length ever go negative? If not change this check if it's is more than
or equal to zero.

If it can then we cannot use -1 as infinite and instead need to use
LayoutUnit::max

[cbiesinger, 2016/08/23 19:37:18]

Done. I don't think size can ever go negative.

 
   if (type == LengthResolveType::MinSize && length.isAuto())
     return LayoutUnit();
 
   if (type == LengthResolveType::MarginSize && length.isAuto())
     return LayoutUnit();
 
   return valueForLength(length, constraintSpace.ContainerSize().inlineSize);
 }
 
 LayoutUnit resolveBlockLength(const NGConstraintSpace& constraintSpace,
                               const Length& length,
                               LayoutUnit contentSize,
                               LengthResolveType type) {
   DCHECK(!length.isMaxSizeNone());
   DCHECK(type != LengthResolveType::MarginSize);
 
   if (type == LengthResolveType::MinSize && length.isAuto())
     return LayoutUnit();
 
   if (length.isAuto())
     return contentSize;
 
   if (length.isMinContent() || length.isMaxContent() || length.isFitContent())
     return contentSize;
 
+  // Make sure that indefinite percentages resolve to -1, not to a random
+  // negative number.
+  if (length.hasPercent() &&
+      constraintSpace.ContainerSize().blockSize == LayoutUnit(-1))

[eae, 2016/08/23 16:50:57]

We might want to use a constant for infinite to improve readability/

[cbiesinger, 2016/08/23 19:37:18]

OK. Adding NGSizeIndefinite. Using a #define to avoid static initializers.

+    return contentSize;
+
   return valueForLength(length, constraintSpace.ContainerSize().blockSize);
 }
 
 LayoutUnit computeInlineSizeForFragment(
     const NGConstraintSpace& constraintSpace,
     const ComputedStyle& style) {
   if (constraintSpace.fixedInlineSize())
     return constraintSpace.ContainerSize().inlineSize;
 
   LayoutUnit extent = resolveInlineLength(constraintSpace, style.logicalWidth(),
@@ skipping 19 matching lines @@
 
 LayoutUnit computeBlockSizeForFragment(const NGConstraintSpace& constraintSpace,
                                        const ComputedStyle& style,
                                        LayoutUnit contentSize) {
   if (constraintSpace.fixedBlockSize())
     return constraintSpace.ContainerSize().blockSize;
 
   LayoutUnit extent =
       resolveBlockLength(constraintSpace, style.logicalHeight(), contentSize,
                          LengthResolveType::ContentSize);
+  if (extent == LayoutUnit(-1)) {
+    DCHECK_EQ(contentSize, LayoutUnit(-1));
+    return extent;
+  }
+
   Length maxLength = style.logicalMaxHeight();
-
   if (!maxLength.isMaxSizeNone()) {
     LayoutUnit max = resolveBlockLength(constraintSpace, maxLength, contentSize,
                                         LengthResolveType::MaxSize);
     extent = std::min(extent, max);
   }
 
   LayoutUnit min = resolveBlockLength(constraintSpace, style.logicalMinHeight(),
                                       contentSize, LengthResolveType::MinSize);
   extent = std::max(extent, min);
 
@@ skipping 14 matching lines @@
   margins.inlineEnd = resolveInlineLength(constraintSpace, style.marginEnd(),
                                           LengthResolveType::MarginSize);
   margins.blockStart = resolveInlineLength(
       constraintSpace, style.marginBefore(), LengthResolveType::MarginSize);
   margins.blockEnd = resolveInlineLength(constraintSpace, style.marginAfter(),
                                          LengthResolveType::MarginSize);
   return margins;
 }
 
 }  // namespace blink