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

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm_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_block_layout_algorithm.h"
 
 #include "core/layout/ng/ng_block_node.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_physical_fragment_base.h"
@@ skipping 30 matching lines @@
   }
 
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGBlockLayoutAlgorithmTest, FixedSize) {
   style_->setWidth(Length(30, Fixed));
   style_->setHeight(Length(40, Fixed));
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragmentBase* frag = RunBlockLayoutAlgorithm(space, nullptr);
 
   EXPECT_EQ(LayoutUnit(30), frag->Width());
   EXPECT_EQ(LayoutUnit(40), frag->Height());
 }
 
 // Verifies that two children are laid out with the correct size and position.
 TEST_F(NGBlockLayoutAlgorithmTest, LayoutBlockChildren) {
   const int kWidth = 30;
   const int kHeight1 = 20;
   const int kHeight2 = 30;
   const int kMarginTop = 5;
   const int kMarginBottom = 20;
   style_->setWidth(Length(kWidth, Fixed));
 
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
   first_style->setHeight(Length(kHeight1, Fixed));
   NGBlockNode* first_child = new NGBlockNode(first_style.get());
 
   RefPtr<ComputedStyle> second_style = ComputedStyle::create();
   second_style->setHeight(Length(kHeight2, Fixed));
   second_style->setMarginTop(Length(kMarginTop, Fixed));
   second_style->setMarginBottom(Length(kMarginBottom, Fixed));
   NGBlockNode* second_child = new NGBlockNode(second_style.get());
 
   first_child->SetNextSibling(second_child);
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(kWidth), frag->Width());
   EXPECT_EQ(LayoutUnit(kHeight1 + kHeight2 + kMarginTop), frag->Height());
-  EXPECT_EQ(NGPhysicalFragmentBase::FragmentBox, frag->Type());
+  EXPECT_EQ(NGPhysicalFragmentBase::kFragmentBox, frag->Type());
   ASSERT_EQ(frag->Children().size(), 2UL);
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(kHeight1, child->Height());
   EXPECT_EQ(0, child->TopOffset());
 
   child = frag->Children()[1];
   EXPECT_EQ(kHeight2, child->Height());
   EXPECT_EQ(kHeight1 + kMarginTop, child->TopOffset());
 }
@@ skipping 19 matching lines @@
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setHeight(Length(kHeight, Fixed));
   div2_style->setWidth(Length(kWidth, Fixed));
   div1_style->setWritingMode(TopToBottomWritingMode);
   div2_style->setMarginLeft(Length(kMarginLeft, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
-      ConstructConstraintSpace(HorizontalTopBottom, LTR,
+      ConstructConstraintSpace(kHorizontalTopBottom, LTR,
                                NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   // DIV2
   child = static_cast<const NGPhysicalFragment*>(child)->Children()[0];
 
   EXPECT_EQ(kHeight, child->Height());
   EXPECT_EQ(0, child->TopOffset());
   EXPECT_EQ(kMarginLeft, child->LeftOffset());
@@ skipping 23 matching lines @@
   NGBlockNode* div1 = new NGBlockNode(div1_style.get());
 
   // DIV2
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setMarginTop(Length(kDiv2MarginTop, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   NGLogicalSize size(LayoutUnit(100), NGSizeIndefinite);
-  NGConstraintSpaceBuilder builder(HorizontalTopBottom);
+  NGConstraintSpaceBuilder builder(kHorizontalTopBottom);
   builder.SetAvailableSize(size)
       .SetPercentageResolutionSize(size)
       .SetIsNewFormattingContext(true);
-  auto* space = new NGConstraintSpace(HorizontalTopBottom, LTR,
+  auto* space = new NGConstraintSpace(kHorizontalTopBottom, LTR,
                                       builder.ToConstraintSpace());
 
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   EXPECT_TRUE(frag->MarginStrut().IsEmpty());
   ASSERT_EQ(frag->Children().size(), 1UL);
   const NGPhysicalFragment* div2_fragment =
       static_cast<const NGPhysicalFragment*>(frag->Children()[0].get());
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv2MarginTop)}),
             div2_fragment->MarginStrut());
@@ skipping 54 matching lines @@
   NGBlockNode* div7 = new NGBlockNode(div7_style.get());
 
   div1->SetFirstChild(div2);
   div2->SetNextSibling(div3);
   div1->SetNextSibling(div4);
   div4->SetNextSibling(div5);
   div5->SetFirstChild(div6);
   div6->SetNextSibling(div7);
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   ASSERT_EQ(frag->Children().size(), 3UL);
 
   // DIV1
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(kHeight, child->Height());
   EXPECT_EQ(0, child->TopOffset());
 
@@ skipping 28 matching lines @@
 
   // DIV2
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setHeight(Length(kHeight, Fixed));
   div2_style->setMarginBottom(Length(kDiv2MarginBottom, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   // Verify that margins are collapsed.
   EXPECT_EQ(NGMarginStrut({LayoutUnit(0), LayoutUnit(kDiv2MarginBottom)}),
             frag->MarginStrut());
 
   // Verify that margins are NOT collapsed.
   div1_style->setHeight(Length(kHeight, Fixed));
   frag = RunBlockLayoutAlgorithm(space, div1);
@@ skipping 28 matching lines @@
   // DIV2
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setHeight(Length(kHeight, Fixed));
   div2_style->setMarginTop(Length(kDiv2Margin, Fixed));
   div2_style->setMarginBottom(Length(kDiv2Margin, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   // Verify that margins do NOT collapse.
   frag = RunBlockLayoutAlgorithm(space, div1);
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv1Margin), LayoutUnit(kDiv1Margin)}),
             frag->MarginStrut());
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv2Margin), LayoutUnit(kDiv2Margin)}),
@@ skipping 35 matching lines @@
 
   // Horizontal DIV
   RefPtr<ComputedStyle> horizontal_style = ComputedStyle::create();
   horizontal_style->setMarginLeft(Length(kHorizontalDivMarginLeft, Fixed));
   horizontal_style->setWritingMode(TopToBottomWritingMode);
   NGBlockNode* horizontal_div = new NGBlockNode(horizontal_style.get());
 
   vertical_div->SetNextSibling(horizontal_div);
 
   auto* space = ConstructConstraintSpace(
-      VerticalLeftRight, LTR, NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
+      kVerticalLeftRight, LTR, NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, vertical_div);
 
   ASSERT_EQ(frag->Children().size(), 2UL);
   const NGPhysicalFragmentBase* child = frag->Children()[1];
   // Horizontal div
   EXPECT_EQ(0, child->TopOffset());
   EXPECT_EQ(kVerticalDivWidth + kHorizontalDivMarginLeft, child->LeftOffset());
 }
 
 // Verifies that the margin strut of a child with a different writing mode does
@@ skipping 36 matching lines @@
   // DIV3
   RefPtr<ComputedStyle> div3_style = ComputedStyle::create();
   div3_style->setHeight(Length(kHeight, Fixed));
   div3_style->setMarginTop(Length(kMarginTop, Fixed));
   NGBlockNode* div3 = new NGBlockNode(div3_style.get());
 
   div1->SetFirstChild(div2);
   div1->SetNextSibling(div3);
 
   auto* space =
-      ConstructConstraintSpace(HorizontalTopBottom, LTR,
+      ConstructConstraintSpace(kHorizontalTopBottom, LTR,
                                NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   ASSERT_EQ(frag->Children().size(), 2UL);
 
   const NGPhysicalFragmentBase* child1 = frag->Children()[0];
   EXPECT_EQ(0, child1->TopOffset());
   EXPECT_EQ(kHeight, child1->Height());
 
   const NGPhysicalFragmentBase* child2 = frag->Children()[1];
@@ skipping 42 matching lines @@
   div1_style->setPaddingBottom(Length(kPaddingBottom, Fixed));
   div1_style->setPaddingLeft(Length(kPaddingLeft, Fixed));
   NGBlockNode* div1 = new NGBlockNode(div1_style.get());
 
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(1000), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   // div1
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(kBorderLeft + kPaddingLeft + kWidth + kPaddingRight + kBorderRight,
             child->Width());
   EXPECT_EQ(kBorderTop + kPaddingTop + kHeight + kPaddingBottom + kBorderBottom,
             child->Height());
 
-  ASSERT_TRUE(child->Type() == NGPhysicalFragmentBase::FragmentBox);
+  ASSERT_TRUE(child->Type() == NGPhysicalFragmentBase::kFragmentBox);
   ASSERT_EQ(static_cast<const NGPhysicalFragment*>(child)->Children().size(),
             1UL);
 
   // div2
   child = static_cast<const NGPhysicalFragment*>(child)->Children()[0];
   EXPECT_EQ(kBorderTop + kPaddingTop, child->TopOffset());
   EXPECT_EQ(kBorderLeft + kPaddingLeft, child->LeftOffset());
 }
 
 TEST_F(NGBlockLayoutAlgorithmTest, PercentageResolutionSize) {
   const int kPaddingLeft = 10;
   const int kWidth = 30;
   style_->setWidth(Length(kWidth, Fixed));
   style_->setPaddingLeft(Length(kPaddingLeft, Fixed));
 
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
   first_style->setWidth(Length(40, Percent));
   NGBlockNode* first_child = new NGBlockNode(first_style.get());
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->Width());
-  EXPECT_EQ(NGPhysicalFragmentBase::FragmentBox, frag->Type());
+  EXPECT_EQ(NGPhysicalFragmentBase::kFragmentBox, frag->Type());
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(LayoutUnit(12), child->Width());
 }
 
 // A very simple auto margin case. We rely on the tests in ng_length_utils_test
 // for the more complex cases; just make sure we handle auto at all here.
 TEST_F(NGBlockLayoutAlgorithmTest, AutoMargin) {
   const int kPaddingLeft = 10;
   const int kWidth = 30;
   style_->setWidth(Length(kWidth, Fixed));
   style_->setPaddingLeft(Length(kPaddingLeft, Fixed));
 
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
   const int kChildWidth = 10;
   first_style->setWidth(Length(kChildWidth, Fixed));
   first_style->setMarginLeft(Length(Auto));
   first_style->setMarginRight(Length(Auto));
   NGBlockNode* first_child = new NGBlockNode(first_style.get());
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->Width());
-  EXPECT_EQ(NGPhysicalFragmentBase::FragmentBox, frag->Type());
+  EXPECT_EQ(NGPhysicalFragmentBase::kFragmentBox, frag->Type());
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->WidthOverflow());
   ASSERT_EQ(1UL, frag->Children().size());
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(LayoutUnit(kChildWidth), child->Width());
   EXPECT_EQ(LayoutUnit(kPaddingLeft + 10), child->LeftOffset());
   EXPECT_EQ(LayoutUnit(0), child->TopOffset());
 }
 
 // Verifies that 3 Left/Right float fragments and one regular block fragment
@@ skipping 55 matching lines @@
   div4_style->setHeight(Length(kDiv4Size, Fixed));
   div4_style->setMarginLeft(Length(kDiv4LeftMargin, Fixed));
   div4_style->setFloating(EFloat::Left);
   NGBlockNode* div4 = new NGBlockNode(div4_style.get());
 
   div1->SetNextSibling(div2);
   div2->SetNextSibling(div3);
   div3->SetNextSibling(div4);
 
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
   ASSERT_EQ(frag->Children().size(), 4UL);
 
   // DIV1
   const NGPhysicalFragmentBase* child1 = frag->Children()[0];
   EXPECT_EQ(kDiv1TopMargin, child1->TopOffset());
   EXPECT_EQ(kParentLeftPadding, child1->LeftOffset());
 
   // DIV2
@@ skipping 56 matching lines @@
   div3_style->setWidth(Length(kDiv3Size, Fixed));
   div3_style->setHeight(Length(kDiv3Size, Fixed));
   NGBlockNode* div3 = new NGBlockNode(div3_style.get());
 
   div1->SetNextSibling(div2);
   div2->SetNextSibling(div3);
 
   // clear: left;
   div3_style->setClear(EClear::ClearLeft);
   auto* space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
   const NGPhysicalFragmentBase* child3 = frag->Children()[2];
   EXPECT_EQ(kDiv1Size, child3->TopOffset());
 
   // clear: right;
   div3_style->setClear(EClear::ClearRight);
   space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   frag = RunBlockLayoutAlgorithm(space, div1);
   child3 = frag->Children()[2];
   EXPECT_EQ(kDiv1Size + kDiv2Size, child3->TopOffset());
 
   // clear: both;
   div3_style->setClear(EClear::ClearBoth);
   space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   frag = RunBlockLayoutAlgorithm(space, div1);
   space = ConstructConstraintSpace(
-      HorizontalTopBottom, LTR,
+      kHorizontalTopBottom, LTR,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   child3 = frag->Children()[2];
   EXPECT_EQ(kDiv1Size + kDiv2Size, child3->TopOffset());
 }
 
 }  // namespace
 }  // namespace blink