Make EFlexDirection an enum class.

third_party/WebKit/Source/core/layout/LayoutFlexibleBox.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 257 matching lines @@
   IntSize size;
   int adjustment_width = VerticalScrollbarWidth();
   int adjustment_height = HorizontalScrollbarHeight();
   if (!adjustment_width && !adjustment_height)
     return size;
 
   EFlexDirection flex_direction = Style()->FlexDirection();
   TextDirection text_direction = Style()->Direction();
   WritingMode writing_mode = Style()->GetWritingMode();
 
-  if (flex_direction == kFlowRow) {
+  if (flex_direction == EFlexDirection::kRow) {
     if (text_direction == TextDirection::kRtl) {
       if (blink::IsHorizontalWritingMode(writing_mode))
         size.Expand(adjustment_width, 0);
       else
         size.Expand(0, adjustment_height);
     }
     if (IsFlippedBlocksWritingMode(writing_mode))
       size.Expand(adjustment_width, 0);
-  } else if (flex_direction == kFlowRowReverse) {
+  } else if (flex_direction == EFlexDirection::kRowReverse) {
     if (text_direction == TextDirection::kLtr) {
       if (blink::IsHorizontalWritingMode(writing_mode))
         size.Expand(adjustment_width, 0);
       else
         size.Expand(0, adjustment_height);
     }
     if (IsFlippedBlocksWritingMode(writing_mode))
       size.Expand(adjustment_width, 0);
-  } else if (flex_direction == kFlowColumn) {
+  } else if (flex_direction == EFlexDirection::kColumn) {
     if (IsFlippedBlocksWritingMode(writing_mode))
       size.Expand(adjustment_width, 0);
   } else {
     if (blink::IsHorizontalWritingMode(writing_mode))
       size.Expand(0, adjustment_height);
     else if (IsFlippedLinesWritingMode(writing_mode))
       size.Expand(adjustment_width, 0);
   }
   return size;
 }
 
 bool LayoutFlexibleBox::HasTopOverflow() const {
   EFlexDirection flex_direction = Style()->FlexDirection();
   if (IsHorizontalWritingMode())
-    return flex_direction == kFlowColumnReverse;
-  return flex_direction ==
-         (Style()->IsLeftToRightDirection() ? kFlowRowReverse : kFlowRow);
+    return flex_direction == EFlexDirection::kColumnReverse;
+  return flex_direction == (Style()->IsLeftToRightDirection()
+                                ? EFlexDirection::kRowReverse
+                                : EFlexDirection::kRow);
 }
 
 bool LayoutFlexibleBox::HasLeftOverflow() const {
   EFlexDirection flex_direction = Style()->FlexDirection();
-  if (IsHorizontalWritingMode())
-    return flex_direction ==
-           (Style()->IsLeftToRightDirection() ? kFlowRowReverse : kFlowRow);
-  return flex_direction == kFlowColumnReverse;
+  if (IsHorizontalWritingMode()) {
+    return flex_direction == (Style()->IsLeftToRightDirection()
+                                  ? EFlexDirection::kRowReverse
+                                  : EFlexDirection::kRow);
+  }
+  return flex_direction == EFlexDirection::kColumnReverse;
 }
 
 void LayoutFlexibleBox::RemoveChild(LayoutObject* child) {
   LayoutBlock::RemoveChild(child);
   intrinsic_size_along_main_axis_.erase(child);
 }
 
 void LayoutFlexibleBox::StyleDidChange(StyleDifference diff,
                                        const ComputedStyle* old_style) {
   LayoutBlock::StyleDidChange(diff, old_style);
@@ skipping 131 matching lines @@
     return !IsColumnFlow();
   return IsColumnFlow();
 }
 
 bool LayoutFlexibleBox::IsLeftToRightFlow() const {
   if (IsColumnFlow()) {
     return blink::IsHorizontalWritingMode(Style()->GetWritingMode()) ||
            IsFlippedLinesWritingMode(Style()->GetWritingMode());
   }
   return Style()->IsLeftToRightDirection() ^
-         (Style()->FlexDirection() == kFlowRowReverse);
+         (Style()->FlexDirection() == EFlexDirection::kRowReverse);
 }
 
 bool LayoutFlexibleBox::IsMultiline() const {
   return Style()->FlexWrap() != kFlexNoWrap;
 }
 
 Length LayoutFlexibleBox::FlexBasisForChild(const LayoutBox& child) const {
   Length flex_length = child.Style()->FlexBasis();
   if (flex_length.IsAuto())
     flex_length =
@@ skipping 1137 matching lines @@
 }
 
 LayoutUnit LayoutFlexibleBox::StaticMainAxisPositionForPositionedChild(
     const LayoutBox& child) {
   const LayoutUnit available_space =
       MainAxisContentExtent(ContentLogicalHeight()) -
       MainAxisExtentForChild(child);
 
   LayoutUnit offset = InitialContentPositionOffset(available_space,
                                                    ResolvedJustifyContent(), 1);
-  if (StyleRef().FlexDirection() == kFlowRowReverse ||
-      StyleRef().FlexDirection() == kFlowColumnReverse)
+  if (StyleRef().FlexDirection() == EFlexDirection::kRowReverse ||
+      StyleRef().FlexDirection() == EFlexDirection::kColumnReverse)
     offset = available_space - offset;
   return offset;
 }
 
 LayoutUnit LayoutFlexibleBox::StaticCrossAxisPositionForPositionedChild(
     const LayoutBox& child) {
   LayoutUnit available_space =
       CrossAxisContentExtent() - CrossAxisExtentForChild(child);
   return AlignmentOffset(available_space, AlignmentForChild(child),
                          LayoutUnit(), LayoutUnit(),
@@ skipping 156 matching lines @@
     SubtreeLayoutScope& layout_scope,
     Vector<LineContext>& line_contexts) {
   const StyleContentAlignmentData justify_content = ResolvedJustifyContent();
 
   LayoutUnit auto_margin_offset =
       AutoMarginOffsetInMainAxis(children, available_free_space);
   LayoutUnit main_axis_offset =
       FlowAwareBorderStart() + FlowAwarePaddingStart();
   main_axis_offset += InitialContentPositionOffset(
       available_free_space, justify_content, children.size());
-  if (Style()->FlexDirection() == kFlowRowReverse &&
+  if (Style()->FlexDirection() == EFlexDirection::kRowReverse &&
       ShouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     main_axis_offset += IsHorizontalFlow() ? VerticalScrollbarWidth()
                                            : HorizontalScrollbarHeight();
 
   LayoutUnit total_main_extent = MainAxisExtent();
   if (!ShouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     total_main_extent -= IsHorizontalFlow() ? VerticalScrollbarWidth()
                                             : HorizontalScrollbarHeight();
   LayoutUnit max_ascent, max_descent;  // Used when align-items: baseline.
   LayoutUnit max_child_cross_axis_extent;
@@ skipping 88 matching lines @@
 
     if (is_paginated)
       UpdateFragmentationInfoForChild(*child);
   }
 
   if (IsColumnFlow())
     SetLogicalHeight(std::max(
         LogicalHeight(), main_axis_offset + FlowAwareBorderEnd() +
                              FlowAwarePaddingEnd() + ScrollbarLogicalHeight()));
 
-  if (Style()->FlexDirection() == kFlowColumnReverse) {
+  if (Style()->FlexDirection() == EFlexDirection::kColumnReverse) {
     // We have to do an extra pass for column-reverse to reposition the flex
     // items since the start depends on the height of the flexbox, which we
     // only know after we've positioned all the flex items.
     UpdateLogicalHeight();
     LayoutColumnReverse(children, cross_axis_offset, available_free_space);
   }
 
   if (number_of_in_flow_children_on_first_line_ == -1)
     number_of_in_flow_children_on_first_line_ = children.size();
   line_contexts.push_back(LineContext(cross_axis_offset,
@@ skipping 256 matching lines @@
       LayoutUnit original_offset =
           line_contexts[line_number].cross_axis_offset - cross_axis_start_edge;
       LayoutUnit new_offset =
           content_extent - original_offset - line_cross_axis_extent;
       AdjustAlignmentForChild(*flex_item.box, new_offset - original_offset);
     }
   }
 }
 
 }  // namespace blink