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

third_party/WebKit/Source/core/layout/ng/ng_units.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_units.h"
 
 #include "core/layout/ng/ng_writing_mode.h"
 
 namespace blink {
 
 LayoutUnit MinAndMaxContentSizes::ShrinkToFit(LayoutUnit available_size) const {
   DCHECK_GE(max_content, min_content);
   return std::min(max_content, std::max(min_content, available_size));
 }
 
 NGPhysicalSize NGLogicalSize::ConvertToPhysical(NGWritingMode mode) const {
-  return mode == HorizontalTopBottom ? NGPhysicalSize(inline_size, block_size)
-                                     : NGPhysicalSize(block_size, inline_size);
+  return mode == kHorizontalTopBottom ? NGPhysicalSize(inline_size, block_size)
+                                      : NGPhysicalSize(block_size, inline_size);
 }
 
 bool NGLogicalSize::operator==(const NGLogicalSize& other) const {
   return std::tie(other.inline_size, other.block_size) ==
          std::tie(inline_size, block_size);
 }
 
 NGLogicalSize NGPhysicalSize::ConvertToLogical(NGWritingMode mode) const {
-  return mode == HorizontalTopBottom ? NGLogicalSize(width, height)
-                                     : NGLogicalSize(height, width);
+  return mode == kHorizontalTopBottom ? NGLogicalSize(width, height)
+                                      : NGLogicalSize(height, width);
 }
 
 bool NGLogicalRect::IsEmpty() const {
   // TODO(layout-dev): equality check shouldn't allocate an object each time.
   return *this == NGLogicalRect();
 }
 
 bool NGLogicalRect::IsContained(const NGLogicalRect& other) const {
   return !(InlineEndOffset() <= other.InlineStartOffset() ||
            BlockEndOffset() <= other.BlockStartOffset() ||
@@ skipping 12 matching lines @@
                         size.inline_size.toString().ascii().data(),
                         size.block_size.toString().ascii().data());
 }
 
 NGPhysicalOffset NGLogicalOffset::ConvertToPhysical(
     NGWritingMode mode,
     TextDirection direction,
     NGPhysicalSize outer_size,
     NGPhysicalSize inner_size) const {
   switch (mode) {
-    case HorizontalTopBottom:
+    case kHorizontalTopBottom:
       if (direction == LTR)
         return NGPhysicalOffset(inline_offset, block_offset);
       else
         return NGPhysicalOffset(
             outer_size.width - inline_offset - inner_size.width, block_offset);
-    case VerticalRightLeft:
-    case SidewaysRightLeft:
+    case kVerticalRightLeft:
+    case kSidewaysRightLeft:
       if (direction == LTR)
         return NGPhysicalOffset(
             outer_size.width - block_offset - inner_size.width, inline_offset);
       else
         return NGPhysicalOffset(
             outer_size.width - block_offset - inner_size.width,
             outer_size.height - inline_offset - inner_size.height);
-    case VerticalLeftRight:
+    case kVerticalLeftRight:
       if (direction == LTR)
         return NGPhysicalOffset(block_offset, inline_offset);
       else
         return NGPhysicalOffset(
             block_offset,
             outer_size.height - inline_offset - inner_size.height);
-    case SidewaysLeftRight:
+    case kSidewaysLeftRight:
       if (direction == LTR)
         return NGPhysicalOffset(
             block_offset,
             outer_size.height - inline_offset - inner_size.height);
       else
         return NGPhysicalOffset(block_offset, inline_offset);
     default:
       ASSERT_NOT_REACHED();
       return NGPhysicalOffset();
   }
@@ skipping 49 matching lines @@
                   other.block_end) ==
          std::tie(inline_start, inline_end, block_start, block_end);
 }
 
 // Converts physical dimensions to logical ones per
 // https://drafts.csswg.org/css-writing-modes-3/#logical-to-physical
 NGBoxStrut NGPhysicalBoxStrut::ConvertToLogical(NGWritingMode writing_mode,
                                                 TextDirection direction) const {
   NGBoxStrut strut;
   switch (writing_mode) {
-    case HorizontalTopBottom:
+    case kHorizontalTopBottom:
       strut = {left, right, top, bottom};
       break;
-    case VerticalRightLeft:
-    case SidewaysRightLeft:
+    case kVerticalRightLeft:
+    case kSidewaysRightLeft:
       strut = {top, bottom, right, left};
       break;
-    case VerticalLeftRight:
+    case kVerticalLeftRight:
       strut = {top, bottom, left, right};
       break;
-    case SidewaysLeftRight:
+    case kSidewaysLeftRight:
       strut = {bottom, top, left, right};
       break;
   }
   if (direction == RTL)
     std::swap(strut.inline_start, strut.inline_end);
   return strut;
 }
 
 LayoutUnit NGMarginStrut::BlockEndSum() const {
   return margin_block_end + negative_margin_block_end;
@@ skipping 46 matching lines @@
 
 bool NGMarginStrut::operator==(const NGMarginStrut& other) const {
   return std::tie(other.margin_block_start, other.margin_block_end,
                   other.negative_margin_block_start,
                   other.negative_margin_block_end) ==
          std::tie(margin_block_start, margin_block_end,
                   negative_margin_block_start, negative_margin_block_end);
 }
 
 }  // namespace blink