Make EFlexWrap 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 410 matching lines @@
 
 void LayoutFlexibleBox::RepositionLogicalHeightDependentFlexItems(
     Vector<LineContext>& line_contexts) {
   LayoutUnit cross_axis_start_edge = line_contexts.IsEmpty()
                                          ? LayoutUnit()
                                          : line_contexts[0].cross_axis_offset;
   AlignFlexLines(line_contexts);
 
   AlignChildren(line_contexts);
 
-  if (Style()->FlexWrap() == kFlexWrapReverse)
+  if (Style()->FlexWrap() == EFlexWrap::kWrapReverse)
     FlipForWrapReverse(line_contexts, cross_axis_start_edge);
 
   // direction:rtl + flex-direction:column means the cross-axis direction is
   // flipped.
   FlipForRightToLeftColumn(line_contexts);
 }
 
 DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::ClientLogicalBottomAfterRepositioning() {
   LayoutUnit max_child_logical_bottom;
@@ skipping 28 matching lines @@
 bool LayoutFlexibleBox::IsLeftToRightFlow() const {
   if (IsColumnFlow()) {
     return blink::IsHorizontalWritingMode(Style()->GetWritingMode()) ||
            IsFlippedLinesWritingMode(Style()->GetWritingMode());
   }
   return Style()->IsLeftToRightDirection() ^
          (Style()->FlexDirection() == EFlexDirection::kRowReverse);
 }
 
 bool LayoutFlexibleBox::IsMultiline() const {
-  return Style()->FlexWrap() != kFlexNoWrap;
+  return Style()->FlexWrap() != EFlexWrap::kNowrap;
 }
 
 Length LayoutFlexibleBox::FlexBasisForChild(const LayoutBox& child) const {
   Length flex_length = child.Style()->FlexBasis();
   if (flex_length.IsAuto())
     flex_length =
         IsHorizontalFlow() ? child.Style()->Width() : child.Style()->Height();
   return flex_length;
 }
 
@@ skipping 1145 matching lines @@
     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(),
-                         StyleRef().FlexWrap() == kFlexWrapReverse);
+                         StyleRef().FlexWrap() == EFlexWrap::kWrapReverse);
 }
 
 LayoutUnit LayoutFlexibleBox::StaticInlinePositionForPositionedChild(
     const LayoutBox& child) {
   return StartOffsetForContent() +
          (IsColumnFlow() ? StaticCrossAxisPositionForPositionedChild(child)
                          : StaticMainAxisPositionForPositionedChild(child));
 }
 
 LayoutUnit LayoutFlexibleBox::StaticBlockPositionForPositionedChild(
@@ skipping 53 matching lines @@
   ItemPosition align =
       child.StyleRef()
           .ResolvedAlignSelf(SelfAlignmentNormalBehavior(), Style())
           .GetPosition();
   DCHECK_NE(align, kItemPositionAuto);
   DCHECK_NE(align, kItemPositionNormal);
 
   if (align == kItemPositionBaseline && HasOrthogonalFlow(child))
     align = kItemPositionFlexStart;
 
-  if (Style()->FlexWrap() == kFlexWrapReverse) {
+  if (Style()->FlexWrap() == EFlexWrap::kWrapReverse) {
     if (align == kItemPositionFlexStart)
       align = kItemPositionFlexEnd;
     else if (align == kItemPositionFlexEnd)
       align = kItemPositionFlexStart;
   }
 
   return align;
 }
 
 void LayoutFlexibleBox::ResetAutoMarginsAndLogicalTopInCrossAxis(
@@ skipping 317 matching lines @@
                                                        *flex_item.box))))
         continue;
 
       ItemPosition position = AlignmentForChild(*flex_item.box);
       if (position == kItemPositionStretch)
         ApplyStretchAlignmentToChild(*flex_item.box, line_cross_axis_extent);
       LayoutUnit available_space = AvailableAlignmentSpaceForChild(
           line_cross_axis_extent, *flex_item.box);
       LayoutUnit offset = AlignmentOffset(
           available_space, position, MarginBoxAscentForChild(*flex_item.box),
-          max_ascent, StyleRef().FlexWrap() == kFlexWrapReverse);
+          max_ascent, StyleRef().FlexWrap() == EFlexWrap::kWrapReverse);
       AdjustAlignmentForChild(*flex_item.box, offset);
       if (position == kItemPositionBaseline &&
-          StyleRef().FlexWrap() == kFlexWrapReverse) {
+          StyleRef().FlexWrap() == EFlexWrap::kWrapReverse) {
         min_margin_after_baseline =
             std::min(min_margin_after_baseline,
                      AvailableAlignmentSpaceForChild(line_cross_axis_extent,
                                                      *flex_item.box) -
                          offset);
       }
     }
     min_margin_after_baselines.push_back(min_margin_after_baseline);
   }
 
-  if (Style()->FlexWrap() != kFlexWrapReverse)
+  if (Style()->FlexWrap() != EFlexWrap::kWrapReverse)
     return;
 
   // wrap-reverse flips the cross axis start and end. For baseline alignment,
   // this means we need to align the after edge of baseline elements with the
   // after edge of the flex line.
   for (size_t line_number = 0; line_number < line_contexts.size();
        ++line_number) {
     const LineContext& line_context = line_contexts[line_number];
     LayoutUnit min_margin_after_baseline =
         min_margin_after_baselines[line_number];
@@ skipping 105 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