Utility routines for ng_units

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"
 #include "platform/Length.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 // TODO(layout-ng):
 // - positioned and/or replaced calculations
 // - Take scrollbars into account
 
-namespace {
-
-// Converts physical dimensions to logical ones per
-// https://drafts.csswg.org/css-writing-modes-3/#logical-to-physical
-// For now it's only used to calculate abstract values for margins.
-NGBoxStrut ToLogicalDimensions(const NGPhysicalBoxStrut& physical_dim,
-                               const NGWritingMode writing_mode,
-                               const TextDirection direction) {
-  bool is_ltr = direction == LTR;
-  NGBoxStrut logical_dim;
-  switch (writing_mode) {
-    case VerticalRightLeft:
-    case SidewaysRightLeft:
-      logical_dim = {is_ltr ? physical_dim.top : physical_dim.bottom,
-                     is_ltr ? physical_dim.bottom : physical_dim.top,
-                     physical_dim.right, physical_dim.left};
-      break;
-    case VerticalLeftRight:
-      logical_dim = {is_ltr ? physical_dim.top : physical_dim.bottom,
-                     is_ltr ? physical_dim.bottom : physical_dim.top,
-                     physical_dim.left, physical_dim.right};
-      break;
-    case SidewaysLeftRight:
-      logical_dim = {is_ltr ? physical_dim.bottom : physical_dim.top,
-                     is_ltr ? physical_dim.top : physical_dim.bottom,
-                     physical_dim.left, physical_dim.right};
-      break;
-    default:
-      NOTREACHED();
-    /* FALLTHROUGH */
-    case HorizontalTopBottom:
-      logical_dim = {is_ltr ? physical_dim.left : physical_dim.right,
-                     is_ltr ? physical_dim.right : physical_dim.left,
-                     physical_dim.top, physical_dim.bottom};
-      break;
-  }
-  return logical_dim;
-}
-
-}  // namespace
-
 bool NeedMinAndMaxContentSizes(const ComputedStyle& style) {
   // TODO(layout-ng): In the future we may pass a shrink-to-fit flag through the
   // constraint space; if so, this function needs to take a constraint space
   // as well to take that into account.
   // This check is technically too broad (fill-available does not need intrinsic
   // size computation) but that's a rare case and only affects performance, not
   // correctness.
   return style.logicalWidth().isIntrinsic() ||
          style.logicalMinWidth().isIntrinsic() ||
          style.logicalMaxWidth().isIntrinsic();
@@ skipping 57 matching lines @@
         // If the available space is infinite, fit-content resolves to
         // max-content. See css-sizing section 2.1.
         value = min_and_max->max_content;
       } else {
         NGBoxStrut margins = ComputeMargins(
             constraintSpace, style,
             FromPlatformWritingMode(style.getWritingMode()), style.direction());
         LayoutUnit fill_available =
             std::max(LayoutUnit(), available_size - margins.InlineSum() -
                                        border_and_padding.InlineSum());
-        value = std::min(min_and_max->max_content,
-                         std::max(min_and_max->min_content, fill_available));
+        value = min_and_max->ShrinkToFit(fill_available);
       }
       return value + border_and_padding.InlineSum();
     }
     case DeviceWidth:
     case DeviceHeight:
     case ExtendToZoom:
       NOTREACHED() << "These should only be used for viewport definitions";
     case MaxSizeNone:
     default:
       NOTREACHED();
@@ skipping 135 matching lines @@
       LengthResolveType::MarginBorderPaddingSize);
   physical_dim.right = ResolveInlineLength(
       constraintSpace, style, empty_sizes, style.marginRight(),
       LengthResolveType::MarginBorderPaddingSize);
   physical_dim.top = ResolveInlineLength(
       constraintSpace, style, empty_sizes, style.marginTop(),
       LengthResolveType::MarginBorderPaddingSize);
   physical_dim.bottom = ResolveInlineLength(
       constraintSpace, style, empty_sizes, style.marginBottom(),
       LengthResolveType::MarginBorderPaddingSize);
-  return ToLogicalDimensions(physical_dim, writing_mode, direction);
+  return physical_dim.ConvertToLogical(writing_mode, direction);
 }
 
 NGBoxStrut ComputeBorders(const ComputedStyle& style) {
   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;
 }
@@ skipping 34 matching lines @@
     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