[LayoutNG] Fix enum values to conform to kEnumName in style guide.

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 20 matching lines @@
 LayoutUnit ResolveInlineLength(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     const WTF::Optional<MinAndMaxContentSizes>& min_and_max,
     const Length& length,
     LengthResolveType type) {
   // TODO(layout-ng): Handle min/max/fit-content
   DCHECK(!length.isMaxSizeNone());
   DCHECK_GE(constraint_space.AvailableSize().inline_size, LayoutUnit());
 
-  if (type == LengthResolveType::MinSize && length.isAuto())
+  if (type == LengthResolveType::kMinSize && length.isAuto())
     return LayoutUnit();
 
-  if (type == LengthResolveType::MarginBorderPaddingSize && length.isAuto())
+  if (type == LengthResolveType::kMarginBorderPaddingSize && 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) {
+  if (type != LengthResolveType::kMarginBorderPaddingSize) {
     border_and_padding =
         ComputeBorders(style) + ComputePadding(constraint_space, style);
   }
   switch (length.type()) {
     case Auto:
     case FillAvailable: {
       LayoutUnit content_size = constraint_space.AvailableSize().inline_size;
       NGBoxStrut margins = ComputeMargins(
           constraint_space, style,
           FromPlatformWritingMode(style.getWritingMode()), style.direction());
@@ skipping 46 matching lines @@
       return border_and_padding.InlineSum();
   }
 }
 
 LayoutUnit ResolveBlockLength(const NGConstraintSpace& constraint_space,
                               const ComputedStyle& style,
                               const Length& length,
                               LayoutUnit content_size,
                               LengthResolveType type) {
   DCHECK(!length.isMaxSizeNone());
-  DCHECK(type != LengthResolveType::MarginBorderPaddingSize);
+  DCHECK(type != LengthResolveType::kMarginBorderPaddingSize);
 
-  if (type == LengthResolveType::MinSize && length.isAuto())
+  if (type == LengthResolveType::kMinSize && length.isAuto())
     return LayoutUnit();
 
   // Make sure that indefinite percentages resolve to NGSizeIndefinite, not to
   // a random negative number.
   if (length.isPercentOrCalc() &&
       constraint_space.PercentageResolutionSize().block_size ==
           NGSizeIndefinite)
     return content_size;
 
   // 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) {
+  if (type != LengthResolveType::kMarginBorderPaddingSize) {
     border_and_padding =
         ComputeBorders(style) + ComputePadding(constraint_space, style);
   }
   switch (length.type()) {
     case FillAvailable: {
       LayoutUnit content_size = constraint_space.AvailableSize().block_size;
       NGBoxStrut margins = ComputeMargins(
           constraint_space, style,
           FromPlatformWritingMode(style.getWritingMode()), style.direction());
       return std::max(border_and_padding.BlockSum(),
@@ skipping 32 matching lines @@
   }
 }
 
 LayoutUnit ComputeInlineSizeForFragment(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     const WTF::Optional<MinAndMaxContentSizes>& min_and_max) {
   if (constraint_space.FixedInlineSize())
     return constraint_space.AvailableSize().inline_size;
 
-  LayoutUnit extent =
-      ResolveInlineLength(constraint_space, style, min_and_max,
-                          style.logicalWidth(), LengthResolveType::ContentSize);
+  LayoutUnit extent = ResolveInlineLength(constraint_space, style, min_and_max,
+                                          style.logicalWidth(),
+                                          LengthResolveType::kContentSize);
 
   Length max_length = style.logicalMaxWidth();
   if (!max_length.isMaxSizeNone()) {
     LayoutUnit max =
         ResolveInlineLength(constraint_space, style, min_and_max, max_length,
-                            LengthResolveType::MaxSize);
+                            LengthResolveType::kMaxSize);
     extent = std::min(extent, max);
   }
 
   LayoutUnit min =
       ResolveInlineLength(constraint_space, style, min_and_max,
-                          style.logicalMinWidth(), LengthResolveType::MinSize);
+                          style.logicalMinWidth(), LengthResolveType::kMinSize);
   extent = std::max(extent, min);
   return extent;
 }
 
 LayoutUnit ComputeBlockSizeForFragment(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     LayoutUnit content_size) {
   if (constraint_space.FixedBlockSize())
     return constraint_space.AvailableSize().block_size;
 
   LayoutUnit extent =
       ResolveBlockLength(constraint_space, style, style.logicalHeight(),
-                         content_size, LengthResolveType::ContentSize);
+                         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::MaxSize);
+                           LengthResolveType::kMaxSize);
     extent = std::min(extent, max);
   }
 
   LayoutUnit min =
       ResolveBlockLength(constraint_space, style, style.logicalMinHeight(),
-                         content_size, LengthResolveType::MinSize);
+                         content_size, LengthResolveType::kMinSize);
   extent = std::max(extent, min);
   return extent;
 }
 
 int ResolveUsedColumnCount(int computed_count,
                            LayoutUnit computed_size,
                            LayoutUnit used_gap,
                            LayoutUnit available_size) {
   if (computed_size == NGSizeIndefinite) {
     DCHECK(computed_count);
@@ skipping 42 matching lines @@
                           const ComputedStyle& style,
                           const NGWritingMode writing_mode,
                           const TextDirection direction) {
   // We don't need these for margin computations
   MinAndMaxContentSizes empty_sizes;
   // Margins always get computed relative to the inline size:
   // https://www.w3.org/TR/CSS2/box.html#value-def-margin-width
   NGPhysicalBoxStrut physical_dim;
   physical_dim.left = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginLeft(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   physical_dim.right = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginRight(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   physical_dim.top = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginTop(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   physical_dim.bottom = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginBottom(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   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;
 }
 
 NGBoxStrut ComputePadding(const NGConstraintSpace& constraint_space,
                           const ComputedStyle& style) {
   // We don't need these for padding computations
   MinAndMaxContentSizes empty_sizes;
   // 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(
       constraint_space, style, empty_sizes, style.paddingStart(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   padding.inline_end = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.paddingEnd(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   padding.block_start = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.paddingBefore(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   padding.block_end = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.paddingAfter(),
-      LengthResolveType::MarginBorderPaddingSize);
+      LengthResolveType::kMarginBorderPaddingSize);
   return padding;
 }
 
 void ApplyAutoMargins(const NGConstraintSpace& constraint_space,
                       const ComputedStyle& style,
                       const NGFragmentBase& fragment,
                       NGBoxStrut* margins) {
   DCHECK(margins) << "Margins cannot be NULL here";
   const LayoutUnit used_space = fragment.InlineSize() + margins->InlineSum();
   const LayoutUnit available_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