Make EBorderStyle an enum class.

third_party/WebKit/Source/core/paint/ObjectPainter.cpp

 // Copyright 2014 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/paint/ObjectPainter.h"
 
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
@@ skipping 349 matching lines @@
     thickness = x2 - x1;
     length = y2 - y1;
   }
 
   // We would like this check to be an ASSERT as we don't want to draw empty
   // borders. However nothing guarantees that the following recursive calls to
   // drawLineForBoxSide will have positive thickness and length.
   if (length <= 0 || thickness <= 0)
     return;
 
-  if (style == kBorderStyleDouble && thickness < 3)
-    style = kBorderStyleSolid;
+  if (style == EBorderStyle::kDouble && thickness < 3)
+    style = EBorderStyle::kSolid;
 
   switch (style) {
-    case kBorderStyleNone:
-    case kBorderStyleHidden:
+    case EBorderStyle::kNone:
+    case EBorderStyle::kHidden:
       return;
-    case kBorderStyleDotted:
-    case kBorderStyleDashed:
+    case EBorderStyle::kDotted:
+    case EBorderStyle::kDashed:
       DrawDashedOrDottedBoxSide(graphics_context, x1, y1, x2, y2, side, color,
                                 thickness, style, antialias);
       break;
-    case kBorderStyleDouble:
+    case EBorderStyle::kDouble:
       DrawDoubleBoxSide(graphics_context, x1, y1, x2, y2, length, side, color,
                         thickness, adjacent_width1, adjacent_width2, antialias);
       break;
-    case kBorderStyleRidge:
-    case kBorderStyleGroove:
+    case EBorderStyle::kRidge:
+    case EBorderStyle::kGroove:
       DrawRidgeOrGrooveBoxSide(graphics_context, x1, y1, x2, y2, side, color,
                                style, adjacent_width1, adjacent_width2,
                                antialias);
       break;
-    case kBorderStyleInset:
+    case EBorderStyle::kInset:
       // FIXME: Maybe we should lighten the colors on one side like Firefox.
       // https://bugs.webkit.org/show_bug.cgi?id=58608
       if (side == kBSTop || side == kBSLeft)
         color = color.Dark();
     // fall through
-    case kBorderStyleOutset:
-      if (style == kBorderStyleOutset &&
+    case EBorderStyle::kOutset:
+      if (style == EBorderStyle::kOutset &&
           (side == kBSBottom || side == kBSRight))
         color = color.Dark();
     // fall through
-    case kBorderStyleSolid:
+    case EBorderStyle::kSolid:
       DrawSolidBoxSide(graphics_context, x1, y1, x2, y2, side, color,
                        adjacent_width1, adjacent_width2, antialias);
       break;
   }
 }
 
 void ObjectPainter::DrawDashedOrDottedBoxSide(GraphicsContext& graphics_context,
                                               int x1,
                                               int y1,
                                               int x2,
                                               int y2,
                                               BoxSide side,
                                               Color color,
                                               int thickness,
                                               EBorderStyle style,
                                               bool antialias) {
   DCHECK_GT(thickness, 0);
 
   GraphicsContextStateSaver state_saver(graphics_context);
   graphics_context.SetShouldAntialias(antialias);
   graphics_context.SetStrokeColor(color);
   graphics_context.SetStrokeThickness(thickness);
-  graphics_context.SetStrokeStyle(style == kBorderStyleDashed ? kDashedStroke
-                                                              : kDottedStroke);
+  graphics_context.SetStrokeStyle(
+      style == EBorderStyle::kDashed ? kDashedStroke : kDottedStroke);
 
   switch (side) {
     case kBSBottom:
     case kBSTop: {
       int mid_y = y1 + thickness / 2;
       graphics_context.DrawLine(IntPoint(x1, mid_y), IntPoint(x2, mid_y));
       break;
     }
     case kBSRight:
     case kBSLeft: {
@@ skipping 50 matching lines @@
   int adjacent1_big_third =
       ((adjacent_width1 > 0) ? adjacent_width1 + 1 : adjacent_width1 - 1) / 3;
   int adjacent2_big_third =
       ((adjacent_width2 > 0) ? adjacent_width2 + 1 : adjacent_width2 - 1) / 3;
 
   switch (side) {
     case kBSTop:
       DrawLineForBoxSide(
           graphics_context, x1 + std::max((-adjacent_width1 * 2 + 1) / 3, 0),
           y1, x2 - std::max((-adjacent_width2 * 2 + 1) / 3, 0),
-          y1 + third_of_thickness, side, color, kBorderStyleSolid,
+          y1 + third_of_thickness, side, color, EBorderStyle::kSolid,
           adjacent1_big_third, adjacent2_big_third, antialias);
       DrawLineForBoxSide(graphics_context,
                          x1 + std::max((adjacent_width1 * 2 + 1) / 3, 0),
                          y2 - third_of_thickness,
                          x2 - std::max((adjacent_width2 * 2 + 1) / 3, 0), y2,
-                         side, color, kBorderStyleSolid, adjacent1_big_third,
+                         side, color, EBorderStyle::kSolid, adjacent1_big_third,
                          adjacent2_big_third, antialias);
       break;
     case kBSLeft:
       DrawLineForBoxSide(graphics_context, x1,
                          y1 + std::max((-adjacent_width1 * 2 + 1) / 3, 0),
                          x1 + third_of_thickness,
                          y2 - std::max((-adjacent_width2 * 2 + 1) / 3, 0), side,
-                         color, kBorderStyleSolid, adjacent1_big_third,
+                         color, EBorderStyle::kSolid, adjacent1_big_third,
                          adjacent2_big_third, antialias);
       DrawLineForBoxSide(graphics_context, x2 - third_of_thickness,
                          y1 + std::max((adjacent_width1 * 2 + 1) / 3, 0), x2,
                          y2 - std::max((adjacent_width2 * 2 + 1) / 3, 0), side,
-                         color, kBorderStyleSolid, adjacent1_big_third,
+                         color, EBorderStyle::kSolid, adjacent1_big_third,
                          adjacent2_big_third, antialias);
       break;
     case kBSBottom:
       DrawLineForBoxSide(
           graphics_context, x1 + std::max((adjacent_width1 * 2 + 1) / 3, 0), y1,
           x2 - std::max((adjacent_width2 * 2 + 1) / 3, 0),
-          y1 + third_of_thickness, side, color, kBorderStyleSolid,
+          y1 + third_of_thickness, side, color, EBorderStyle::kSolid,
           adjacent1_big_third, adjacent2_big_third, antialias);
       DrawLineForBoxSide(graphics_context,
                          x1 + std::max((-adjacent_width1 * 2 + 1) / 3, 0),
                          y2 - third_of_thickness,
                          x2 - std::max((-adjacent_width2 * 2 + 1) / 3, 0), y2,
-                         side, color, kBorderStyleSolid, adjacent1_big_third,
+                         side, color, EBorderStyle::kSolid, adjacent1_big_third,
                          adjacent2_big_third, antialias);
       break;
     case kBSRight:
       DrawLineForBoxSide(graphics_context, x1,
                          y1 + std::max((adjacent_width1 * 2 + 1) / 3, 0),
                          x1 + third_of_thickness,
                          y2 - std::max((adjacent_width2 * 2 + 1) / 3, 0), side,
-                         color, kBorderStyleSolid, adjacent1_big_third,
+                         color, EBorderStyle::kSolid, adjacent1_big_third,
                          adjacent2_big_third, antialias);
       DrawLineForBoxSide(graphics_context, x2 - third_of_thickness,
                          y1 + std::max((-adjacent_width1 * 2 + 1) / 3, 0), x2,
                          y2 - std::max((-adjacent_width2 * 2 + 1) / 3, 0), side,
-                         color, kBorderStyleSolid, adjacent1_big_third,
+                         color, EBorderStyle::kSolid, adjacent1_big_third,
                          adjacent2_big_third, antialias);
       break;
     default:
       break;
   }
 }
 
 void ObjectPainter::DrawRidgeOrGrooveBoxSide(GraphicsContext& graphics_context,
                                              int x1,
                                              int y1,
                                              int x2,
                                              int y2,
                                              BoxSide side,
                                              Color color,
                                              EBorderStyle style,
                                              int adjacent_width1,
                                              int adjacent_width2,
                                              bool antialias) {
   EBorderStyle s1;
   EBorderStyle s2;
-  if (style == kBorderStyleGroove) {
-    s1 = kBorderStyleInset;
-    s2 = kBorderStyleOutset;
+  if (style == EBorderStyle::kGroove) {
+    s1 = EBorderStyle::kInset;
+    s2 = EBorderStyle::kOutset;
   } else {
-    s1 = kBorderStyleOutset;
-    s2 = kBorderStyleInset;
+    s1 = EBorderStyle::kOutset;
+    s2 = EBorderStyle::kInset;
   }
 
   int adjacent1_big_half =
       ((adjacent_width1 > 0) ? adjacent_width1 + 1 : adjacent_width1 - 1) / 2;
   int adjacent2_big_half =
       ((adjacent_width2 > 0) ? adjacent_width2 + 1 : adjacent_width2 - 1) / 2;
 
   switch (side) {
     case kBSTop:
       DrawLineForBoxSide(
@@ skipping 136 matching lines @@
     adjusted_paint_offset += ToLayoutBox(layout_object_).Location();
   DCHECK(layout_object_.PaintOffset() == adjusted_paint_offset)
       << " Paint offset mismatch: " << layout_object_.DebugName()
       << " from PaintPropertyTreeBuilder: "
       << layout_object_.PaintOffset().ToString()
       << " from painter: " << adjusted_paint_offset.ToString();
 }
 #endif
 
 }  // namespace blink