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

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.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_break_token.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment_base.h"
@@ skipping 203 matching lines @@
       LayoutUnit adjusted_block_size(block_size);
       // Our calculated block-axis size may be indefinite at this point.
       // If so, just leave the size as NGSizeIndefinite instead of subtracting
       // borders and padding.
       if (adjusted_block_size != NGSizeIndefinite)
         adjusted_block_size -= border_and_padding_.BlockSum();
 
       space_builder_ =
           new NGConstraintSpaceBuilder(constraint_space_->WritingMode());
       if (Style().specifiesColumns()) {
-        space_builder_->SetFragmentationType(FragmentColumn);
+        space_builder_->SetFragmentationType(kFragmentColumn);
         adjusted_inline_size =
             ResolveUsedColumnInlineSize(adjusted_inline_size, Style());
       }
       space_builder_->SetAvailableSize(
           NGLogicalSize(adjusted_inline_size, adjusted_block_size));
       space_builder_->SetPercentageResolutionSize(
           NGLogicalSize(adjusted_inline_size, adjusted_block_size));
 
       content_size_ = border_and_padding_.block_start;
 
-      builder_ = new NGFragmentBuilder(NGPhysicalFragmentBase::FragmentBox);
+      builder_ = new NGFragmentBuilder(NGPhysicalFragmentBase::kFragmentBox);
       builder_->SetDirection(constraint_space_->Direction());
       builder_->SetWritingMode(constraint_space_->WritingMode());
       builder_->SetInlineSize(inline_size).SetBlockSize(block_size);
       current_child_ = first_child_;
       if (current_child_)
         space_for_current_child_ = CreateConstraintSpaceForCurrentChild();
 
       state_ = kStateChildLayout;
-      return NotFinished;
+      return kNotFinished;
     }
     case kStateChildLayout: {
       if (current_child_) {
         if (!LayoutCurrentChild())
-          return NotFinished;
+          return kNotFinished;
         current_child_ = current_child_->NextSibling();
         if (current_child_) {
           space_for_current_child_ = CreateConstraintSpaceForCurrentChild();
-          return NotFinished;
+          return kNotFinished;
         }
       }
       state_ = kStateFinalize;
-      return NotFinished;
+      return kNotFinished;
     }
     case kStateFinalize: {
       content_size_ += border_and_padding_.block_end;
 
       // Recompute the block-axis size now that we know our content size.
       LayoutUnit block_size = ComputeBlockSizeForFragment(
           ConstraintSpace(), Style(), content_size_);
 
       builder_->SetBlockSize(block_size)
           .SetInlineOverflow(max_inline_size_)
           .SetBlockOverflow(content_size_);
       *fragment_out = builder_->ToFragment();
       state_ = kStateInit;
-      return NewFragment;
+      return kNewFragment;
     }
   };
   NOTREACHED();
   *fragment_out = nullptr;
-  return NewFragment;
+  return kNewFragment;
 }
 
 bool NGBlockLayoutAlgorithm::LayoutCurrentChild() {
   NGFragmentBase* fragment;
   if (!current_child_->Layout(space_for_current_child_, &fragment))
     return false;
 
   NGBoxStrut child_margins = ComputeMargins(
       *space_for_current_child_, CurrentChildStyle(),
       constraint_space_->WritingMode(), constraint_space_->Direction());
@@ skipping 104 matching lines @@
   // Update offset if there is a clearance.
   NGLogicalOffset offset = space_for_current_child_->Offset();
   AdjustToClearance(ConstraintSpace(), CurrentChildStyle(),
                     &offset.block_offset);
   space_for_current_child_->SetOffset(offset);
 
   const NGLayoutOpportunity opportunity = FindLayoutOpportunityForFragment(
       space_for_current_child_, fragment, margins);
   DCHECK(!opportunity.IsEmpty()) << "Opportunity is empty but it shouldn't be";
 
-  NGExclusion::Type exclusion_type = NGExclusion::NG_FLOAT_LEFT;
+  NGExclusion::Type exclusion_type = NGExclusion::kFloatLeft;
   // Calculate the float offset if needed.
   LayoutUnit float_offset;
   if (CurrentChildStyle().floating() == EFloat::Right) {
     float_offset = opportunity.size.inline_size - fragment.InlineSize();
-    exclusion_type = NGExclusion::NG_FLOAT_RIGHT;
+    exclusion_type = NGExclusion::kFloatRight;
   }
 
   // Add the float as an exclusion.
   const NGExclusion exclusion = CreateExclusion(
       fragment, opportunity, float_offset, margins, exclusion_type);
   constraint_space_->AddExclusion(exclusion);
 
   return CalculateLogicalOffsetForOpportunity(opportunity, float_offset,
                                               margins);
 }
@@ skipping 33 matching lines @@
   visitor->trace(first_child_);
   visitor->trace(constraint_space_);
   visitor->trace(break_token_);
   visitor->trace(builder_);
   visitor->trace(space_builder_);
   visitor->trace(space_for_current_child_);
   visitor->trace(current_child_);
 }
 
 }  // namespace blink