Make EBorderStyle an enum class.

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

 // Copyright 2015 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/BoxBorderPainter.h"
 
 #include <algorithm>
 #include "core/paint/BoxPainter.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/paint/PaintInfo.h"
@@ skipping 27 matching lines @@
 
 inline bool IncludesAdjacentEdges(BorderEdgeFlags flags) {
   // The set includes adjacent edges iff it contains at least one horizontal and
   // one vertical edge.
   return (flags & (kTopBorderEdge | kBottomBorderEdge)) &&
          (flags & (kLeftBorderEdge | kRightBorderEdge));
 }
 
 inline bool StyleRequiresClipPolygon(EBorderStyle style) {
   // These are drawn with a stroke, so we have to clip to get corner miters.
-  return style == kBorderStyleDotted || style == kBorderStyleDashed;
+  return style == EBorderStyle::kDotted || style == EBorderStyle::kDashed;
 }
 
 inline bool BorderStyleFillsBorderArea(EBorderStyle style) {
-  return !(style == kBorderStyleDotted || style == kBorderStyleDashed ||
-           style == kBorderStyleDouble);
+  return !(style == EBorderStyle::kDotted || style == EBorderStyle::kDashed ||
+           style == EBorderStyle::kDouble);
 }
 
 inline bool BorderStyleHasInnerDetail(EBorderStyle style) {
-  return style == kBorderStyleGroove || style == kBorderStyleRidge ||
-         style == kBorderStyleDouble;
+  return style == EBorderStyle::kGroove || style == EBorderStyle::kRidge ||
+         style == EBorderStyle::kDouble;
 }
 
 inline bool BorderStyleIsDottedOrDashed(EBorderStyle style) {
-  return style == kBorderStyleDotted || style == kBorderStyleDashed;
+  return style == EBorderStyle::kDotted || style == EBorderStyle::kDashed;
 }
 
 // BorderStyleOutset darkens the bottom and right (and maybe lightens the top
 // and left) BorderStyleInset darkens the top and left (and maybe lightens the
 // bottom and right).
 inline bool BorderStyleHasUnmatchedColorsAtCorner(EBorderStyle style,
                                                   BoxSide side,
                                                   BoxSide adjacent_side) {
   // These styles match at the top/left and bottom/right.
-  if (style == kBorderStyleInset || style == kBorderStyleGroove ||
-      style == kBorderStyleRidge || style == kBorderStyleOutset) {
+  if (style == EBorderStyle::kInset || style == EBorderStyle::kGroove ||
+      style == EBorderStyle::kRidge || style == EBorderStyle::kOutset) {
     const BorderEdgeFlags top_right_flags =
         EdgeFlagForSide(kBSTop) | EdgeFlagForSide(kBSRight);
     const BorderEdgeFlags bottom_left_flags =
         EdgeFlagForSide(kBSBottom) | EdgeFlagForSide(kBSLeft);
 
     BorderEdgeFlags flags =
         EdgeFlagForSide(side) | EdgeFlagForSide(adjacent_side);
     return flags == top_right_flags || flags == bottom_left_flags;
   }
   return false;
@@ skipping 27 matching lines @@
 
   // The side is still to be drawn. It overdraws the current edge iff it has a
   // solid fill style.
   return BorderStyleFillsBorderArea(style);
 }
 
 inline bool BorderStylesRequireMiter(BoxSide side,
                                      BoxSide adjacent_side,
                                      EBorderStyle style,
                                      EBorderStyle adjacent_style) {
-  if (style == kBorderStyleDouble || adjacent_style == kBorderStyleDouble ||
-      adjacent_style == kBorderStyleGroove ||
-      adjacent_style == kBorderStyleRidge)
+  if (style == EBorderStyle::kDouble ||
+      adjacent_style == EBorderStyle::kDouble ||
+      adjacent_style == EBorderStyle::kGroove ||
+      adjacent_style == EBorderStyle::kRidge)
     return true;
 
   if (BorderStyleIsDottedOrDashed(style) !=
       BorderStyleIsDottedOrDashed(adjacent_style))
     return true;
 
   if (style != adjacent_style)
     return true;
 
   return BorderStyleHasUnmatchedColorsAtCorner(style, side, adjacent_side);
@@ skipping 194 matching lines @@
         break;
       }
     // fall through
     default:
       context.FillDRRect(outer, inner, color);
       break;
   }
 }
 
 // The LUTs below assume specific enum values.
-static_assert(kBorderStyleNone == 0, "unexpected EBorderStyle value");
-static_assert(kBorderStyleHidden == 1, "unexpected EBorderStyle value");
-static_assert(kBorderStyleInset == 2, "unexpected EBorderStyle value");
-static_assert(kBorderStyleGroove == 3, "unexpected EBorderStyle value");
-static_assert(kBorderStyleOutset == 4, "unexpected EBorderStyle value");
-static_assert(kBorderStyleRidge == 5, "unexpected EBorderStyle value");
-static_assert(kBorderStyleDotted == 6, "unexpected EBorderStyle value");
-static_assert(kBorderStyleDashed == 7, "unexpected EBorderStyle value");
-static_assert(kBorderStyleSolid == 8, "unexpected EBorderStyle value");
-static_assert(kBorderStyleDouble == 9, "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kNone == static_cast<EBorderStyle>(0),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kHidden == static_cast<EBorderStyle>(1),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kInset == static_cast<EBorderStyle>(2),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kGroove == static_cast<EBorderStyle>(3),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kOutset == static_cast<EBorderStyle>(4),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kRidge == static_cast<EBorderStyle>(5),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kDotted == static_cast<EBorderStyle>(6),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kDashed == static_cast<EBorderStyle>(7),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kSolid == static_cast<EBorderStyle>(8),
+              "unexpected EBorderStyle value");
+static_assert(EBorderStyle::kDouble == static_cast<EBorderStyle>(9),
+              "unexpected EBorderStyle value");
 
 static_assert(kBSTop == 0, "unexpected BoxSide value");
 static_assert(kBSRight == 1, "unexpected BoxSide value");
 static_assert(kBSBottom == 2, "unexpected BoxSide value");
 static_assert(kBSLeft == 3, "unexpected BoxSide value");
 
 // Style-based paint order: non-solid edges (dashed/dotted/double) are painted
 // before solid edges (inset/outset/groove/ridge/solid) to maximize overdraw
 // opportunities.
 const unsigned kStylePriority[] = {
@@ skipping 58 matching lines @@
               [&border_painter](BoxSide a, BoxSide b) -> bool {
                 const BorderEdge& edge_a = border_painter.edges_[a];
                 const BorderEdge& edge_b = border_painter.edges_[b];
 
                 const unsigned alpha_a = edge_a.color.Alpha();
                 const unsigned alpha_b = edge_b.color.Alpha();
                 if (alpha_a != alpha_b)
                   return alpha_a < alpha_b;
 
                 const unsigned style_priority_a =
-                    kStylePriority[edge_a.BorderStyle()];
+                    kStylePriority[static_cast<unsigned>(edge_a.BorderStyle())];
                 const unsigned style_priority_b =
-                    kStylePriority[edge_b.BorderStyle()];
+                    kStylePriority[static_cast<unsigned>(edge_b.BorderStyle())];
                 if (style_priority_a != style_priority_b)
                   return style_priority_a < style_priority_b;
 
                 return kSidePriority[a] < kSidePriority[b];
               });
 
     // Finally, build the opacity group structures.
     BuildOpacityGroups(border_painter, sorted_sides);
 
     if (border_painter.is_rounded_)
@@ skipping 29 matching lines @@
     }
 
     DCHECK(!opacity_groups.IsEmpty());
   }
 };
 
 void BoxBorderPainter::DrawDoubleBorder(GraphicsContext& context,
                                         const LayoutRect& border_rect) const {
   DCHECK(is_uniform_color_);
   DCHECK(is_uniform_style_);
-  DCHECK(FirstEdge().BorderStyle() == kBorderStyleDouble);
+  DCHECK(FirstEdge().BorderStyle() == EBorderStyle::kDouble);
   DCHECK(visible_edge_set_ == kAllBorderEdges);
 
   const Color color = FirstEdge().color;
 
   // outer stripe
   const LayoutRectOutsets outer_third_insets =
       DoubleStripeInsets(edges_, BorderEdge::kDoubleBorderStripeOuter);
   const FloatRoundedRect outer_third_rect = style_.GetRoundedInnerBorderFor(
       border_rect, outer_third_insets, include_logical_left_edge_,
       include_logical_right_edge_);
   DrawBleedAdjustedDRRect(context, bleed_avoidance_, outer_, outer_third_rect,
                           color);
 
   // inner stripe
   const LayoutRectOutsets inner_third_insets =
       DoubleStripeInsets(edges_, BorderEdge::kDoubleBorderStripeInner);
   const FloatRoundedRect inner_third_rect = style_.GetRoundedInnerBorderFor(
       border_rect, inner_third_insets, include_logical_left_edge_,
       include_logical_right_edge_);
   context.FillDRRect(inner_third_rect, inner_, color);
 }
 
 bool BoxBorderPainter::PaintBorderFastPath(
     GraphicsContext& context,
     const LayoutRect& border_rect) const {
   if (!is_uniform_color_ || !is_uniform_style_ || !inner_.IsRenderable())
     return false;
 
-  if (FirstEdge().BorderStyle() != kBorderStyleSolid &&
-      FirstEdge().BorderStyle() != kBorderStyleDouble)
+  if (FirstEdge().BorderStyle() != EBorderStyle::kSolid &&
+      FirstEdge().BorderStyle() != EBorderStyle::kDouble)
     return false;
 
   if (visible_edge_set_ == kAllBorderEdges) {
-    if (FirstEdge().BorderStyle() == kBorderStyleSolid) {
+    if (FirstEdge().BorderStyle() == EBorderStyle::kSolid) {
       if (is_uniform_width_ && !outer_.IsRounded()) {
         // 4-side, solid, uniform-width, rectangular border => one drawRect()
         DrawSolidBorderRect(context, outer_.Rect(), FirstEdge().Width(),
                             FirstEdge().color);
       } else {
         // 4-side, solid border => one drawDRRect()
         DrawBleedAdjustedDRRect(context, bleed_avoidance_, outer_, inner_,
                                 FirstEdge().color);
       }
     } else {
       // 4-side, double border => 2x drawDRRect()
-      DCHECK(FirstEdge().BorderStyle() == kBorderStyleDouble);
+      DCHECK(FirstEdge().BorderStyle() == EBorderStyle::kDouble);
       DrawDoubleBorder(context, border_rect);
     }
 
     return true;
   }
 
   // This is faster than the normal complex border path only if it avoids
   // creating transparency layers (when the border is translucent).
-  if (FirstEdge().BorderStyle() == kBorderStyleSolid && !outer_.IsRounded() &&
-      has_alpha_) {
+  if (FirstEdge().BorderStyle() == EBorderStyle::kSolid &&
+      !outer_.IsRounded() && has_alpha_) {
     DCHECK(visible_edge_set_ != kAllBorderEdges);
     // solid, rectangular border => one drawPath()
     Path path;
     path.SetWindRule(RULE_NONZERO);
 
     for (int i = kBSTop; i <= kBSLeft; ++i) {
       const BorderEdge& curr_edge = edges_[i];
       if (curr_edge.ShouldRender())
         path.AddRect(CalculateSideRect(outer_, curr_edge, i));
     }
@@ skipping 413 matching lines @@
                                            const LayoutRect& border_rect,
                                            const Path& border_path,
                                            float thickness,
                                            float draw_thickness,
                                            BoxSide side,
                                            Color color,
                                            EBorderStyle border_style) const {
   if (thickness <= 0)
     return;
 
-  if (border_style == kBorderStyleDouble && thickness < 3)
-    border_style = kBorderStyleSolid;
+  if (border_style == EBorderStyle::kDouble && thickness < 3)
+    border_style = EBorderStyle::kSolid;
 
   switch (border_style) {
-    case kBorderStyleNone:
-    case kBorderStyleHidden:
+    case EBorderStyle::kNone:
+    case EBorderStyle::kHidden:
       return;
-    case kBorderStyleDotted:
-    case kBorderStyleDashed: {
+    case EBorderStyle::kDotted:
+    case EBorderStyle::kDashed: {
       DrawDashedDottedBoxSideFromPath(graphics_context, border_rect, thickness,
                                       draw_thickness, color, border_style);
       return;
     }
-    case kBorderStyleDouble: {
+    case EBorderStyle::kDouble: {
       DrawDoubleBoxSideFromPath(graphics_context, border_rect, border_path,
                                 thickness, draw_thickness, side, color);
       return;
     }
-    case kBorderStyleRidge:
-    case kBorderStyleGroove: {
+    case EBorderStyle::kRidge:
+    case EBorderStyle::kGroove: {
       DrawRidgeGrooveBoxSideFromPath(graphics_context, border_rect, border_path,
                                      thickness, draw_thickness, side, color,
                                      border_style);
       return;
     }
-    case kBorderStyleInset:
+    case EBorderStyle::kInset:
       if (side == kBSTop || side == kBSLeft)
         color = color.Dark();
       break;
-    case kBorderStyleOutset:
+    case EBorderStyle::kOutset:
       if (side == kBSBottom || side == kBSRight)
         color = color.Dark();
       break;
     default:
       break;
   }
 
   graphics_context.SetStrokeStyle(kNoStroke);
   graphics_context.SetFillColor(color);
   graphics_context.DrawRect(PixelSnappedIntRect(border_rect));
@@ skipping 10 matching lines @@
   const LayoutRectOutsets center_offsets(
       -edges_[kBSTop].UsedWidth() * 0.5, -edges_[kBSRight].UsedWidth() * 0.5,
       -edges_[kBSBottom].UsedWidth() * 0.5, -edges_[kBSLeft].UsedWidth() * 0.5);
   Path centerline_path;
   centerline_path.AddRoundedRect(style_.GetRoundedInnerBorderFor(
       border_rect, center_offsets, include_logical_left_edge_,
       include_logical_right_edge_));
 
   graphics_context.SetStrokeColor(color);
 
-  if (!StrokeData::StrokeIsDashed(thickness, border_style == kBorderStyleDashed
-                                                 ? kDashedStroke
-                                                 : kDottedStroke)) {
+  if (!StrokeData::StrokeIsDashed(
+          thickness, border_style == EBorderStyle::kDashed ? kDashedStroke
+                                                           : kDottedStroke)) {
     DrawWideDottedBoxSideFromPath(graphics_context, centerline_path, thickness);
     return;
   }
 
   // The extra multiplier is so that the clipping mask can antialias
   // the edges to prevent jaggies.
   graphics_context.SetStrokeThickness(draw_thickness * 1.1f);
   graphics_context.SetStrokeStyle(
-      border_style == kBorderStyleDashed ? kDashedStroke : kDottedStroke);
+      border_style == EBorderStyle::kDashed ? kDashedStroke : kDottedStroke);
 
   // TODO(schenney): This code for setting up the dash effect is trying to
   // do the same thing as StrokeData::setupPaintDashPathEffect and should be
   // refactored to re-use that code. It would require
   // GraphicsContext::strokePath to take a length parameter.
   float dash_length = draw_thickness;
   float gap_length = dash_length;
-  if (border_style == kBorderStyleDashed) {
+  if (border_style == EBorderStyle::kDashed) {
     dash_length *= StrokeData::DashLengthRatio(draw_thickness);
     gap_length *= StrokeData::DashGapRatio(draw_thickness);
   }
   float path_length = centerline_path.length();
   // Don't try to show dashes if we have less than 2 dashes + 2 gaps.
   // TODO(schenney): should do this test per side.
   if (path_length >= 2 * dash_length + gap_length) {
     float gap = gap_length;
-    if (border_style == kBorderStyleDashed)
+    if (border_style == EBorderStyle::kDashed)
       gap = StrokeData::SelectBestDashGap(path_length, dash_length, gap_length);
     DashArray line_dash;
     line_dash.push_back(dash_length);
     line_dash.push_back(gap);
     graphics_context.SetLineDash(line_dash, dash_length);
   } else if (path_length > dash_length) {
     // Exactly 2 dashes proportionally sized
     float multiplier = path_length / (2 * dash_length + gap_length);
     DashArray line_dash;
     line_dash.push_back(dash_length * multiplier);
@@ skipping 57 matching lines @@
   {
     GraphicsContextStateSaver state_saver(graphics_context);
     const LayoutRectOutsets inner_insets =
         DoubleStripeInsets(edges_, BorderEdge::kDoubleBorderStripeInner);
     FloatRoundedRect inner_clip = style_.GetRoundedInnerBorderFor(
         border_rect, inner_insets, include_logical_left_edge_,
         include_logical_right_edge_);
 
     graphics_context.ClipRoundedRect(inner_clip);
     DrawBoxSideFromPath(graphics_context, border_rect, border_path, thickness,
-                        draw_thickness, side, color, kBorderStyleSolid);
+                        draw_thickness, side, color, EBorderStyle::kSolid);
   }
 
   // Draw outer border line
   {
     GraphicsContextStateSaver state_saver(graphics_context);
     LayoutRect outer_rect = border_rect;
     LayoutRectOutsets outer_insets =
         DoubleStripeInsets(edges_, BorderEdge::kDoubleBorderStripeOuter);
 
     if (BleedAvoidanceIsClipping(bleed_avoidance_)) {
       outer_rect.Inflate(1);
       outer_insets.SetTop(outer_insets.Top() - 1);
       outer_insets.SetRight(outer_insets.Right() - 1);
       outer_insets.SetBottom(outer_insets.Bottom() - 1);
       outer_insets.SetLeft(outer_insets.Left() - 1);
     }
 
     FloatRoundedRect outer_clip = style_.GetRoundedInnerBorderFor(
         outer_rect, outer_insets, include_logical_left_edge_,
         include_logical_right_edge_);
     graphics_context.ClipOutRoundedRect(outer_clip);
     DrawBoxSideFromPath(graphics_context, border_rect, border_path, thickness,
-                        draw_thickness, side, color, kBorderStyleSolid);
+                        draw_thickness, side, color, EBorderStyle::kSolid);
   }
 }
 
 void BoxBorderPainter::DrawRidgeGrooveBoxSideFromPath(
     GraphicsContext& graphics_context,
     const LayoutRect& border_rect,
     const Path& border_path,
     float thickness,
     float draw_thickness,
     BoxSide side,
     Color color,
     EBorderStyle border_style) const {
   EBorderStyle s1;
   EBorderStyle s2;
-  if (border_style == kBorderStyleGroove) {
-    s1 = kBorderStyleInset;
-    s2 = kBorderStyleOutset;
+  if (border_style == EBorderStyle::kGroove) {
+    s1 = EBorderStyle::kInset;
+    s2 = EBorderStyle::kOutset;
   } else {
-    s1 = kBorderStyleOutset;
-    s2 = kBorderStyleInset;
+    s1 = EBorderStyle::kOutset;
+    s2 = EBorderStyle::kInset;
   }
 
   // Paint full border
   DrawBoxSideFromPath(graphics_context, border_rect, border_path, thickness,
                       draw_thickness, side, color, s1);
 
   // Paint inner only
   GraphicsContextStateSaver state_saver(graphics_context);
   int top_width = edges_[kBSTop].UsedWidth() / 2;
   int bottom_width = edges_[kBSBottom].UsedWidth() / 2;
@@ skipping 272 matching lines @@
     FindIntersection(edge_quad[2], edge_quad[3], bound_quad1, bound_quad2,
                      clipping_quad[2]);
     clipping_quad[2] -= extension_offset;
     clipping_quad[3] = edge_quad[3] - extension_offset;
 
     ClipQuad(graphics_context, clipping_quad, second_miter == kSoftMiter);
   }
 }
 
 }  // namespace blink