Constrain width/height to minmax values

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 224 matching lines @@
   if (space.IsFixedSizeInline())
     return space.AvailableSize().inline_size;
 
   Length logicalWidth = style.logicalWidth();
   if (logicalWidth.isAuto() && space.IsShrinkToFit())
     logicalWidth = Length(FitContent);
 
   LayoutUnit extent = ResolveInlineLength(
       space, style, min_and_max, logicalWidth, LengthResolveType::kContentSize);
 
-  Length max_length = style.logicalMaxWidth();
-  if (!max_length.isMaxSizeNone()) {
-    LayoutUnit max = ResolveInlineLength(space, style, min_and_max, max_length,
-                                         LengthResolveType::kMaxSize);
-    extent = std::min(extent, max);
+  Optional<LayoutUnit> max_length;
+  if (!style.logicalMaxWidth().isMaxSizeNone()) {
+    max_length =
+        ResolveInlineLength(space, style, min_and_max, style.logicalMaxWidth(),
+                            LengthResolveType::kMaxSize);
   }
-
-  LayoutUnit min =
+  Optional<LayoutUnit> min_length =
       ResolveInlineLength(space, style, min_and_max, style.logicalMinWidth(),
                           LengthResolveType::kMinSize);
-  extent = std::max(extent, min);
-  return extent;
+  return ConstrainByMinMax(extent, min_length, max_length);
 }
 
 LayoutUnit ComputeBlockSizeForFragment(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     LayoutUnit content_size) {
   if (constraint_space.IsFixedSizeBlock())
     return constraint_space.AvailableSize().block_size;
 
   LayoutUnit extent =
       ResolveBlockLength(constraint_space, style, style.logicalHeight(),
                          content_size, LengthResolveType::kContentSize);
   if (extent == NGSizeIndefinite) {
     DCHECK_EQ(content_size, NGSizeIndefinite);
     return extent;
   }
-
-  Length max_length = style.logicalMaxHeight();
-  if (!max_length.isMaxSizeNone()) {
-    LayoutUnit max =
-        ResolveBlockLength(constraint_space, style, max_length, content_size,
-                           LengthResolveType::kMaxSize);
-    extent = std::min(extent, max);
+  Optional<LayoutUnit> max_length;
+  if (!style.logicalMaxHeight().isMaxSizeNone()) {
+    max_length =
+        ResolveBlockLength(constraint_space, style, style.logicalMaxHeight(),
+                           content_size, LengthResolveType::kMaxSize);
   }
-
-  LayoutUnit min =
+  Optional<LayoutUnit> min_length =
       ResolveBlockLength(constraint_space, style, style.logicalMinHeight(),
                          content_size, LengthResolveType::kMinSize);
-  extent = std::max(extent, min);
-  return extent;
+  return ConstrainByMinMax(extent, min_length, max_length);
 }
 
 int ResolveUsedColumnCount(int computed_count,
                            LayoutUnit computed_size,
                            LayoutUnit used_gap,
                            LayoutUnit available_size) {
   if (computed_size == NGSizeIndefinite) {
     DCHECK(computed_count);
     return computed_count;
   }
@@ skipping 104 matching lines @@
   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;
   }
 }
 
+LayoutUnit ConstrainByMinMax(LayoutUnit length,
+                             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