Change computed style enums to be prefixed with 'k'.

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_layout_coordinator.h"
@@ skipping 37 matching lines @@
     while (!coordinator.Tick(&fragment))
       ;
 
     return toNGPhysicalBoxFragment(fragment);
   }
 
   MinAndMaxContentSizes RunComputeMinAndMax(NGBlockNode* first_child) {
     // The constraint space is not used for min/max computation, but we need
     // it to create the algorithm.
     NGConstraintSpace* space =
-        ConstructConstraintSpace(kHorizontalTopBottom, TextDirection::Ltr,
+        ConstructConstraintSpace(kHorizontalTopBottom, TextDirection::kLtr,
                                  NGLogicalSize(LayoutUnit(), LayoutUnit()));
     NGBlockLayoutAlgorithm algorithm(style_.get(), first_child, space);
     MinAndMaxContentSizes sizes;
     NGLayoutAlgorithm::MinAndMaxState state;
     while ((state = algorithm.ComputeMinAndMaxContentSizes(&sizes)) !=
            NGLayoutAlgorithm::kSuccess) {
       EXPECT_NE(NGLayoutAlgorithm::kNotImplemented, state);
       // shouldn't happen but let's avoid an infinite loop
       if (state == NGLayoutAlgorithm::kNotImplemented)
         break;
     }
     return sizes;
   }
 
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGBlockLayoutAlgorithmTest, FixedSize) {
   style_->setWidth(Length(30, Fixed));
   style_->setHeight(Length(40, Fixed));
 
   auto* space = ConstructConstraintSpace(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* 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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(kWidth), frag->Width());
   EXPECT_EQ(LayoutUnit(kHeight1 + kHeight2 + kMarginTop), frag->Height());
   EXPECT_EQ(NGPhysicalFragment::kFragmentBox, frag->Type());
   ASSERT_EQ(frag->Children().size(), 2UL);
 
   const NGPhysicalFragment* child = frag->Children()[0];
   EXPECT_EQ(kHeight1, child->Height());
@@ skipping 12 matching lines @@
 //   <div style="width:50px;
 //       height: 50px; margin-left: 100px;
 //       writing-mode: horizontal-tb;"></div>
 // </div>
 TEST_F(NGBlockLayoutAlgorithmTest, LayoutBlockChildrenWithWritingMode) {
   const int kWidth = 50;
   const int kHeight = 50;
   const int kMarginLeft = 100;
 
   RefPtr<ComputedStyle> div1_style = ComputedStyle::create();
-  div1_style->setWritingMode(WritingMode::VerticalLr);
+  div1_style->setWritingMode(WritingMode::kVerticalLr);
   NGBlockNode* div1 = new NGBlockNode(div1_style.get());
 
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setHeight(Length(kHeight, Fixed));
   div2_style->setWidth(Length(kWidth, Fixed));
-  div1_style->setWritingMode(WritingMode::HorizontalTb);
+  div1_style->setWritingMode(WritingMode::kHorizontalTb);
   div2_style->setMarginLeft(Length(kMarginLeft, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
-      ConstructConstraintSpace(kHorizontalTopBottom, TextDirection::Ltr,
+      ConstructConstraintSpace(kHorizontalTopBottom, TextDirection::kLtr,
                                NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   const NGPhysicalFragment* child = frag->Children()[0];
   // DIV2
   child = static_cast<const NGPhysicalBoxFragment*>(child)->Children()[0];
 
   EXPECT_EQ(kHeight, child->Height());
   EXPECT_EQ(0, child->TopOffset());
   EXPECT_EQ(kMarginLeft, child->LeftOffset());
@@ skipping 27 matching lines @@
   div2_style->setMarginTop(Length(kDiv2MarginTop, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
       NGConstraintSpaceBuilder(kHorizontalTopBottom)
           .SetAvailableSize(NGLogicalSize(LayoutUnit(100), NGSizeIndefinite))
           .SetPercentageResolutionSize(
               NGLogicalSize(LayoutUnit(100), NGSizeIndefinite))
-          .SetTextDirection(TextDirection::Ltr)
+          .SetTextDirection(TextDirection::kLtr)
           .SetIsNewFormattingContext(true)
           .ToConstraintSpace();
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   EXPECT_TRUE(frag->MarginStrut().IsEmpty());
   ASSERT_EQ(frag->Children().size(), 1UL);
   const NGPhysicalBoxFragment* div2_fragment =
       static_cast<const NGPhysicalBoxFragment*>(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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   ASSERT_EQ(frag->Children().size(), 3UL);
 
   // DIV1
   const NGPhysicalFragment* 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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalBoxFragment* 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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalBoxFragment* 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 18 matching lines @@
 //       horizontal
 //     </div>
 //   </div>
 TEST_F(NGBlockLayoutAlgorithmTest, CollapsingMarginsCase5) {
   const int kVerticalDivMarginRight = 60;
   const int kVerticalDivWidth = 50;
   const int kHorizontalDivMarginLeft = 100;
 
   style_->setWidth(Length(500, Fixed));
   style_->setHeight(Length(500, Fixed));
-  style_->setWritingMode(WritingMode::VerticalLr);
+  style_->setWritingMode(WritingMode::kVerticalLr);
 
   // Vertical DIV
   RefPtr<ComputedStyle> vertical_style = ComputedStyle::create();
   vertical_style->setMarginRight(Length(kVerticalDivMarginRight, Fixed));
   vertical_style->setWidth(Length(kVerticalDivWidth, Fixed));
   NGBlockNode* vertical_div = new NGBlockNode(vertical_style.get());
 
   // Horizontal DIV
   RefPtr<ComputedStyle> horizontal_style = ComputedStyle::create();
   horizontal_style->setMarginLeft(Length(kHorizontalDivMarginLeft, Fixed));
-  horizontal_style->setWritingMode(WritingMode::HorizontalTb);
+  horizontal_style->setWritingMode(WritingMode::kHorizontalTb);
   NGBlockNode* horizontal_div = new NGBlockNode(horizontal_style.get());
 
   vertical_div->SetNextSibling(horizontal_div);
 
   auto* space =
-      ConstructConstraintSpace(kVerticalLeftRight, TextDirection::Ltr,
+      ConstructConstraintSpace(kVerticalLeftRight, TextDirection::kLtr,
                                NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, vertical_div);
 
   ASSERT_EQ(frag->Children().size(), 2UL);
   const NGPhysicalFragment* child = frag->Children()[1];
   // Horizontal div
   EXPECT_EQ(0, child->TopOffset());
   EXPECT_EQ(kVerticalDivWidth + kHorizontalDivMarginLeft, child->LeftOffset());
 }
 
@@ skipping 17 matching lines @@
   const int kMarginLeft = -20;
   const int kMarginTop = 40;
 
   style_->setWidth(Length(500, Fixed));
   style_->setHeight(Length(500, Fixed));
 
   // DIV1
   RefPtr<ComputedStyle> div1_style = ComputedStyle::create();
   div1_style->setWidth(Length(kWidth, Fixed));
   div1_style->setHeight(Length(kHeight, Fixed));
-  div1_style->setWritingMode(WritingMode::VerticalRl);
+  div1_style->setWritingMode(WritingMode::kVerticalRl);
   div1_style->setMarginBottom(Length(kMarginBottom, Fixed));
   NGBlockNode* div1 = new NGBlockNode(div1_style.get());
 
   // DIV2
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setWidth(Length(kWidth, Fixed));
   div2_style->setMarginLeft(Length(kMarginLeft, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   // 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(kHorizontalTopBottom, TextDirection::Ltr,
+      ConstructConstraintSpace(kHorizontalTopBottom, TextDirection::kLtr,
                                NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   ASSERT_EQ(frag->Children().size(), 2UL);
 
   const NGPhysicalFragment* child1 = frag->Children()[0];
   EXPECT_EQ(0, child1->TopOffset());
   EXPECT_EQ(kHeight, child1->Height());
 
   const NGPhysicalFragment* 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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(1000), NGSizeIndefinite));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   // div1
   const NGPhysicalFragment* child = frag->Children()[0];
   EXPECT_EQ(kBorderLeft + kPaddingLeft + kWidth + kPaddingRight + kBorderRight,
             child->Width());
   EXPECT_EQ(kBorderTop + kPaddingTop + kHeight + kPaddingBottom + kBorderBottom,
@@ skipping 13 matching lines @@
   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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->Width());
   EXPECT_EQ(NGPhysicalFragment::kFragmentBox, frag->Type());
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   const NGPhysicalFragment* 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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->Width());
   EXPECT_EQ(NGPhysicalFragment::kFragmentBox, frag->Type());
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->WidthOverflow());
   ASSERT_EQ(1UL, frag->Children().size());
 
   const NGPhysicalFragment* child = frag->Children()[0];
   EXPECT_EQ(LayoutUnit(kChildWidth), child->Width());
@@ skipping 30 matching lines @@
   const int kDiv4LeftMargin = kDiv1Size;
 
   style_->setHeight(Length(kParentSize, Fixed));
   style_->setWidth(Length(kParentSize, Fixed));
   style_->setPaddingLeft(Length(kParentLeftPadding, Fixed));
 
   // DIV1
   RefPtr<ComputedStyle> div1_style = ComputedStyle::create();
   div1_style->setWidth(Length(kDiv1Size, Fixed));
   div1_style->setHeight(Length(kDiv1Size, Fixed));
-  div1_style->setFloating(EFloat::Left);
+  div1_style->setFloating(EFloat::kLeft);
   div1_style->setMarginTop(Length(kDiv1TopMargin, Fixed));
   NGBlockNode* div1 = new NGBlockNode(div1_style.get());
 
   // DIV2
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setWidth(Length(kDiv2Size, Fixed));
   div2_style->setHeight(Length(kDiv2Size, Fixed));
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   // DIV3
   RefPtr<ComputedStyle> div3_style = ComputedStyle::create();
   div3_style->setWidth(Length(kDiv3Size, Fixed));
   div3_style->setHeight(Length(kDiv3Size, Fixed));
-  div3_style->setFloating(EFloat::Right);
+  div3_style->setFloating(EFloat::kRight);
   NGBlockNode* div3 = new NGBlockNode(div3_style.get());
 
   // DIV4
   RefPtr<ComputedStyle> div4_style = ComputedStyle::create();
   div4_style->setWidth(Length(kDiv4Size, Fixed));
   div4_style->setHeight(Length(kDiv4Size, Fixed));
   div4_style->setMarginLeft(Length(kDiv4LeftMargin, Fixed));
-  div4_style->setFloating(EFloat::Left);
+  div4_style->setFloating(EFloat::kLeft);
   NGBlockNode* div4 = new NGBlockNode(div4_style.get());
 
   div1->SetNextSibling(div2);
   div2->SetNextSibling(div3);
   div3->SetNextSibling(div4);
 
   auto* space = ConstructConstraintSpace(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, div1);
   ASSERT_EQ(frag->Children().size(), 4UL);
 
   // DIV1
   const NGPhysicalFragment* child1 = frag->Children()[0];
   EXPECT_EQ(kDiv1TopMargin, child1->TopOffset());
   EXPECT_EQ(kParentLeftPadding, child1->LeftOffset());
 
   // DIV2
@@ skipping 33 matching lines @@
   const int kDiv2Size = 40;
   const int kDiv3Size = 50;
 
   style_->setHeight(Length(kParentSize, Fixed));
   style_->setWidth(Length(kParentSize, Fixed));
 
   // DIV1
   RefPtr<ComputedStyle> div1_style = ComputedStyle::create();
   div1_style->setWidth(Length(kDiv1Size, Fixed));
   div1_style->setHeight(Length(kDiv1Size, Fixed));
-  div1_style->setFloating(EFloat::Left);
+  div1_style->setFloating(EFloat::kLeft);
   NGBlockNode* div1 = new NGBlockNode(div1_style.get());
 
   // DIV2
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setWidth(Length(kDiv2Size, Fixed));
   div2_style->setHeight(Length(kDiv2Size, Fixed));
   div2_style->setClear(EClear::ClearLeft);
-  div2_style->setFloating(EFloat::Right);
+  div2_style->setFloating(EFloat::kRight);
   NGBlockNode* div2 = new NGBlockNode(div2_style.get());
 
   // DIV3
   RefPtr<ComputedStyle> div3_style = ComputedStyle::create();
   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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   NGPhysicalBoxFragment* frag = RunBlockLayoutAlgorithm(space, div1);
   const NGPhysicalFragment* child3 = frag->Children()[2];
   EXPECT_EQ(kDiv1Size, child3->TopOffset());
 
   // clear: right;
   div3_style->setClear(EClear::ClearRight);
   space = ConstructConstraintSpace(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       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(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   frag = RunBlockLayoutAlgorithm(space, div1);
   space = ConstructConstraintSpace(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   child3 = frag->Children()[2];
   EXPECT_EQ(kDiv1Size + kDiv2Size, child3->TopOffset());
 }
 
 // Verifies that we compute the right min and max-content size.
 TEST_F(NGBlockLayoutAlgorithmTest, ComputeMinMaxContent) {
   const int kWidth = 50;
   const int kWidthChild1 = 20;
   const int kWidthChild2 = 30;
@@ skipping 25 matching lines @@
   first_style->setWidth(Length(kWidthChild1, Fixed));
   NGBlockNode* first_child = new NGBlockNode(first_style.get());
 
   RefPtr<ComputedStyle> second_style = ComputedStyle::create();
   second_style->setWidth(Length(kWidthChild2, Fixed));
   NGBlockNode* second_child = new NGBlockNode(second_style.get());
 
   first_child->SetNextSibling(second_child);
 
   auto* space = ConstructConstraintSpace(
-      kHorizontalTopBottom, TextDirection::Ltr,
+      kHorizontalTopBottom, TextDirection::kLtr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite), true);
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(30), frag->Width());
 }
 
 }  // namespace
 }  // namespace blink