[LayoutNG] Capitalize functions in ng_length_utils.h

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 38 matching lines @@
       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
 
-LayoutUnit resolveInlineLength(const NGConstraintSpace& constraintSpace,
+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());
 
   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);
+        ComputeBorders(style) + ComputePadding(constraintSpace, style);
   }
   LayoutUnit container_size = constraintSpace.ContainerSize().inline_size;
   switch (length.type()) {
     case Auto:
     case FillAvailable: {
       NGBoxStrut margins =
-          computeMargins(constraintSpace, style,
+          ComputeMargins(constraintSpace, style,
                          FromPlatformWritingMode(style.getWritingMode()),
                          FromPlatformDirection(style.direction()));
       return std::max(border_and_padding.InlineSum(),
                       container_size - margins.InlineSum());
     }
     case Percent:
     case Fixed:
     case Calculated: {
       LayoutUnit value = valueForLength(length, container_size);
       if (style.boxSizing() == BoxSizingContentBox) {
@@ skipping 12 matching lines @@
     case DeviceHeight:
     case ExtendToZoom:
       NOTREACHED() << "These should only be used for viewport definitions";
     case MaxSizeNone:
     default:
       NOTREACHED();
       return border_and_padding.InlineSum();
   }
 }
 
-LayoutUnit resolveBlockLength(const NGConstraintSpace& constraintSpace,
+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);
+        ComputeBorders(style) + ComputePadding(constraintSpace, style);
   }
   LayoutUnit container_size = constraintSpace.ContainerSize().block_size;
   switch (length.type()) {
     case FillAvailable: {
       NGBoxStrut margins =
-          computeMargins(constraintSpace, style,
+          ComputeMargins(constraintSpace, style,
                          FromPlatformWritingMode(style.getWritingMode()),
                          FromPlatformDirection(style.direction()));
       return std::max(border_and_padding.BlockSum(),
                       container_size - margins.BlockSum());
     }
     case Percent:
     case Fixed:
     case Calculated: {
       LayoutUnit value = valueForLength(length, container_size);
       if (style.boxSizing() == BoxSizingContentBox) {
@@ skipping 16 matching lines @@
     case DeviceHeight:
     case ExtendToZoom:
       NOTREACHED() << "These should only be used for viewport definitions";
     case MaxSizeNone:
     default:
       NOTREACHED();
       return border_and_padding.BlockSum();
   }
 }
 
-LayoutUnit computeInlineSizeForFragment(
+LayoutUnit ComputeInlineSizeForFragment(
     const NGConstraintSpace& constraintSpace,
     const ComputedStyle& style) {
   if (constraintSpace.FixedInlineSize())
     return constraintSpace.ContainerSize().inline_size;
 
   LayoutUnit extent =
-      resolveInlineLength(constraintSpace, style, style.logicalWidth(),
+      ResolveInlineLength(constraintSpace, style, style.logicalWidth(),
                           LengthResolveType::ContentSize);
 
   Length maxLength = style.logicalMaxWidth();
   if (!maxLength.isMaxSizeNone()) {
-    LayoutUnit max = resolveInlineLength(constraintSpace, style, maxLength,
+    LayoutUnit max = ResolveInlineLength(constraintSpace, style, maxLength,
                                          LengthResolveType::MaxSize);
     extent = std::min(extent, max);
   }
 
   LayoutUnit min =
-      resolveInlineLength(constraintSpace, style, style.logicalMinWidth(),
+      ResolveInlineLength(constraintSpace, style, style.logicalMinWidth(),
                           LengthResolveType::MinSize);
   extent = std::max(extent, min);
   return extent;
 }
 
-LayoutUnit computeBlockSizeForFragment(const NGConstraintSpace& constraintSpace,
+LayoutUnit ComputeBlockSizeForFragment(const NGConstraintSpace& constraintSpace,
                                        const ComputedStyle& style,
                                        LayoutUnit contentSize) {
   if (constraintSpace.FixedBlockSize())
     return constraintSpace.ContainerSize().block_size;
 
   LayoutUnit extent =
-      resolveBlockLength(constraintSpace, style, style.logicalHeight(),
+      ResolveBlockLength(constraintSpace, style, style.logicalHeight(),
                          contentSize, LengthResolveType::ContentSize);
   if (extent == NGSizeIndefinite) {
     DCHECK_EQ(contentSize, NGSizeIndefinite);
     return extent;
   }
 
   Length maxLength = style.logicalMaxHeight();
   if (!maxLength.isMaxSizeNone()) {
     LayoutUnit max =
-        resolveBlockLength(constraintSpace, style, maxLength, contentSize,
+        ResolveBlockLength(constraintSpace, style, maxLength, contentSize,
                            LengthResolveType::MaxSize);
     extent = std::min(extent, max);
   }
 
   LayoutUnit min =
-      resolveBlockLength(constraintSpace, style, style.logicalMinHeight(),
+      ResolveBlockLength(constraintSpace, style, style.logicalMinHeight(),
                          contentSize, LengthResolveType::MinSize);
   extent = std::max(extent, min);
   return extent;
 }
 
-NGBoxStrut computeMargins(const NGConstraintSpace& constraintSpace,
+NGBoxStrut ComputeMargins(const NGConstraintSpace& constraintSpace,
                           const ComputedStyle& style,
                           const NGWritingMode writing_mode,
                           const NGDirection direction) {
   // Margins always get computed relative to the inline size:
   // https://www.w3.org/TR/CSS2/box.html#value-def-margin-width
   NGPhysicalDimensions physical_dim;
   physical_dim.left =
-      resolveInlineLength(constraintSpace, style, style.marginLeft(),
+      ResolveInlineLength(constraintSpace, style, style.marginLeft(),
                           LengthResolveType::MarginBorderPaddingSize);
   physical_dim.right =
-      resolveInlineLength(constraintSpace, style, style.marginRight(),
+      ResolveInlineLength(constraintSpace, style, style.marginRight(),
                           LengthResolveType::MarginBorderPaddingSize);
   physical_dim.top =
-      resolveInlineLength(constraintSpace, style, style.marginTop(),
+      ResolveInlineLength(constraintSpace, style, style.marginTop(),
                           LengthResolveType::MarginBorderPaddingSize);
   physical_dim.bottom =
-      resolveInlineLength(constraintSpace, style, style.marginBottom(),
+      ResolveInlineLength(constraintSpace, style, style.marginBottom(),
                           LengthResolveType::MarginBorderPaddingSize);
   return ToLogicalDimensions(physical_dim, writing_mode, direction);
 }
 
-NGBoxStrut computeBorders(const ComputedStyle& style) {
+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;
 }
 
-NGBoxStrut computePadding(const NGConstraintSpace& constraintSpace,
+NGBoxStrut ComputePadding(const NGConstraintSpace& constraintSpace,
                           const ComputedStyle& style) {
   // Padding always gets computed relative to the inline size:
   // https://www.w3.org/TR/CSS2/box.html#value-def-padding-width
   NGBoxStrut padding;
   padding.inline_start =
-      resolveInlineLength(constraintSpace, style, style.paddingStart(),
+      ResolveInlineLength(constraintSpace, style, style.paddingStart(),
                           LengthResolveType::MarginBorderPaddingSize);
   padding.inline_end =
-      resolveInlineLength(constraintSpace, style, style.paddingEnd(),
+      ResolveInlineLength(constraintSpace, style, style.paddingEnd(),
                           LengthResolveType::MarginBorderPaddingSize);
   padding.block_start =
-      resolveInlineLength(constraintSpace, style, style.paddingBefore(),
+      ResolveInlineLength(constraintSpace, style, style.paddingBefore(),
                           LengthResolveType::MarginBorderPaddingSize);
   padding.block_end =
-      resolveInlineLength(constraintSpace, style, style.paddingAfter(),
+      ResolveInlineLength(constraintSpace, style, style.paddingAfter(),
                           LengthResolveType::MarginBorderPaddingSize);
   return padding;
 }
 
 void ApplyAutoMargins(const NGConstraintSpace& constraint_space,
                       const ComputedStyle& style,
                       const NGFragment& fragment,
                       NGBoxStrut& margins) {
   const LayoutUnit used_space = fragment.InlineSize() + margins.InlineSum();
   const LayoutUnit available_space =
       constraint_space.ContainerSize().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