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

third_party/WebKit/Source/core/layout/ng/ng_length_utils_test.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/layout/ng/ng_fragment_builder.h"
@@ skipping 10 matching lines @@
 namespace {
 
 class NGLengthUtilsTest : public ::testing::Test {
  protected:
   void SetUp() override { style_ = ComputedStyle::create(); }
 
   static NGConstraintSpace* ConstructConstraintSpace(int inline_size,
                                                      int block_size,
                                                      bool fixed_inline = false,
                                                      bool fixed_block = false) {
-    NGConstraintSpaceBuilder builder(HorizontalTopBottom);
+    NGConstraintSpaceBuilder builder(kHorizontalTopBottom);
     builder
         .SetAvailableSize(
             NGLogicalSize(LayoutUnit(inline_size), LayoutUnit(block_size)))
         .SetPercentageResolutionSize(
             NGLogicalSize(LayoutUnit(inline_size), LayoutUnit(block_size)))
         .SetIsFixedSizeInline(fixed_inline)
         .SetIsFixedSizeBlock(fixed_block);
 
-    return new NGConstraintSpace(HorizontalTopBottom, LTR,
+    return new NGConstraintSpace(kHorizontalTopBottom, LTR,
                                  builder.ToConstraintSpace());
   }
 
   LayoutUnit ResolveInlineLength(
       const Length& length,
-      LengthResolveType type = LengthResolveType::ContentSize,
+      LengthResolveType type = LengthResolveType::kContentSize,
       const WTF::Optional<MinAndMaxContentSizes>& sizes = WTF::nullopt) {
     NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200, 300);
     return ::blink::ResolveInlineLength(*constraintSpace, *style_, sizes,
                                         length, type);
   }
 
   LayoutUnit ResolveBlockLength(
       const Length& length,
-      LengthResolveType type = LengthResolveType::ContentSize,
+      LengthResolveType type = LengthResolveType::kContentSize,
       LayoutUnit contentSize = LayoutUnit()) {
     NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200, 300);
     return ::blink::ResolveBlockLength(*constraintSpace, *style_, length,
                                        contentSize, type);
   }
 
   LayoutUnit ComputeInlineSizeForFragment(
       const NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200,
                                                                           300),
       const MinAndMaxContentSizes& sizes = MinAndMaxContentSizes()) {
     return ::blink::ComputeInlineSizeForFragment(*constraintSpace, *style_,
                                                  sizes);
   }
 
   LayoutUnit ComputeBlockSizeForFragment(
       const NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200,
                                                                           300),
       LayoutUnit contentSize = LayoutUnit()) {
     return ::blink::ComputeBlockSizeForFragment(*constraintSpace, *style_,
                                                 contentSize);
   }
 
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGLengthUtilsTest, testResolveInlineLength) {
   EXPECT_EQ(LayoutUnit(60), ResolveInlineLength(Length(30, Percent)));
   EXPECT_EQ(LayoutUnit(150), ResolveInlineLength(Length(150, Fixed)));
   EXPECT_EQ(LayoutUnit(0),
-            ResolveInlineLength(Length(Auto), LengthResolveType::MinSize));
+            ResolveInlineLength(Length(Auto), LengthResolveType::kMinSize));
   EXPECT_EQ(LayoutUnit(200), ResolveInlineLength(Length(Auto)));
   EXPECT_EQ(LayoutUnit(200), ResolveInlineLength(Length(FillAvailable)));
 
   EXPECT_EQ(LayoutUnit(200),
-            ResolveInlineLength(Length(Auto), LengthResolveType::MaxSize));
+            ResolveInlineLength(Length(Auto), LengthResolveType::kMaxSize));
   EXPECT_EQ(LayoutUnit(200), ResolveInlineLength(Length(FillAvailable),
-                                                 LengthResolveType::MaxSize));
+                                                 LengthResolveType::kMaxSize));
   MinAndMaxContentSizes sizes;
   sizes.min_content = LayoutUnit(30);
   sizes.max_content = LayoutUnit(40);
   EXPECT_EQ(LayoutUnit(30),
             ResolveInlineLength(Length(MinContent),
-                                LengthResolveType::ContentSize, sizes));
+                                LengthResolveType::kContentSize, sizes));
   EXPECT_EQ(LayoutUnit(40),
             ResolveInlineLength(Length(MaxContent),
-                                LengthResolveType::ContentSize, sizes));
+                                LengthResolveType::kContentSize, sizes));
   EXPECT_EQ(LayoutUnit(40),
             ResolveInlineLength(Length(FitContent),
-                                LengthResolveType::ContentSize, sizes));
+                                LengthResolveType::kContentSize, sizes));
   sizes.max_content = LayoutUnit(800);
   EXPECT_EQ(LayoutUnit(200),
             ResolveInlineLength(Length(FitContent),
-                                LengthResolveType::ContentSize, sizes));
+                                LengthResolveType::kContentSize, sizes));
 #ifndef NDEBUG
   // This should fail a DCHECK.
   EXPECT_DEATH(ResolveInlineLength(Length(FitContent)), "Check failed");
 #endif
 }
 
 TEST_F(NGLengthUtilsTest, testResolveBlockLength) {
   EXPECT_EQ(LayoutUnit(90), ResolveBlockLength(Length(30, Percent)));
   EXPECT_EQ(LayoutUnit(150), ResolveBlockLength(Length(150, Fixed)));
   EXPECT_EQ(LayoutUnit(0), ResolveBlockLength(Length(Auto)));
   EXPECT_EQ(LayoutUnit(300), ResolveBlockLength(Length(FillAvailable)));
 
   EXPECT_EQ(LayoutUnit(0),
-            ResolveBlockLength(Length(Auto), LengthResolveType::ContentSize));
+            ResolveBlockLength(Length(Auto), LengthResolveType::kContentSize));
   EXPECT_EQ(LayoutUnit(300),
             ResolveBlockLength(Length(FillAvailable),
-                               LengthResolveType::ContentSize));
+                               LengthResolveType::kContentSize));
 }
 
 TEST_F(NGLengthUtilsTest, testComputeInlineSizeForFragment) {
   MinAndMaxContentSizes sizes;
   sizes.min_content = LayoutUnit(30);
   sizes.max_content = LayoutUnit(40);
 
   style_->setLogicalWidth(Length(30, Percent));
   EXPECT_EQ(LayoutUnit(60), ComputeInlineSizeForFragment());
 
@@ skipping 134 matching lines @@
 
 TEST_F(NGLengthUtilsTest, testMargins) {
   style_->setMarginTop(Length(10, Percent));
   style_->setMarginRight(Length(52, Fixed));
   style_->setMarginBottom(Length(Auto));
   style_->setMarginLeft(Length(11, Percent));
 
   NGConstraintSpace* constraintSpace(ConstructConstraintSpace(200, 300));
 
   NGBoxStrut margins =
-      ComputeMargins(*constraintSpace, *style_, HorizontalTopBottom, LTR);
+      ComputeMargins(*constraintSpace, *style_, kHorizontalTopBottom, LTR);
 
   EXPECT_EQ(LayoutUnit(20), margins.block_start);
   EXPECT_EQ(LayoutUnit(52), margins.inline_end);
   EXPECT_EQ(LayoutUnit(), margins.block_end);
   EXPECT_EQ(LayoutUnit(22), margins.inline_start);
 }
 
 TEST_F(NGLengthUtilsTest, testBorders) {
   style_->setBorderTopWidth(1);
   style_->setBorderRightWidth(2);
@@ skipping 27 matching lines @@
   EXPECT_EQ(LayoutUnit(52), padding.block_start);
   EXPECT_EQ(LayoutUnit(), padding.inline_end);
   EXPECT_EQ(LayoutUnit(22), padding.block_end);
   EXPECT_EQ(LayoutUnit(20), padding.inline_start);
 }
 
 TEST_F(NGLengthUtilsTest, testAutoMargins) {
   style_->setMarginRight(Length(Auto));
   style_->setMarginLeft(Length(Auto));
 
-  NGFragmentBuilder builder(NGPhysicalFragmentBase::FragmentBox);
+  NGFragmentBuilder builder(NGPhysicalFragmentBase::kFragmentBox);
   builder.SetInlineSize(LayoutUnit(150));
   NGPhysicalFragment* physical_fragment = builder.ToFragment();
   NGFragment* fragment =
-      new NGFragment(HorizontalTopBottom, LTR, physical_fragment);
+      new NGFragment(kHorizontalTopBottom, LTR, physical_fragment);
 
   NGConstraintSpace* constraint_space(ConstructConstraintSpace(200, 300));
 
   NGBoxStrut margins;
   ApplyAutoMargins(*constraint_space, *style_, *fragment, &margins);
 
   EXPECT_EQ(LayoutUnit(), margins.block_start);
   EXPECT_EQ(LayoutUnit(), margins.block_end);
   EXPECT_EQ(LayoutUnit(25), margins.inline_start);
   EXPECT_EQ(LayoutUnit(25), margins.inline_end);
@@ skipping 82 matching lines @@
   EXPECT_EQ(125, GetUsedColumnWidth(4, 100, 10, 530));
   EXPECT_EQ(4, GetUsedColumnCount(4, 100, 10, 530));
   EXPECT_EQ(100, GetUsedColumnWidth(6, 100, 10, 540));
   EXPECT_EQ(5, GetUsedColumnCount(6, 100, 10, 540));
   EXPECT_EQ(100, GetUsedColumnWidth(0, 100, 10, 540));
   EXPECT_EQ(5, GetUsedColumnCount(0, 100, 10, 540));
 }
 
 }  // namespace
 }  // namespace blink