Make EBorderStyle an enum class.

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 498 matching lines @@
     return surround_data_->border_.GetImage().Outset();
   }
   void SetBorderImageOutset(const BorderImageLengthBox&);
 
   // Border width properties.
   static float InitialBorderWidth() { return 3; }
 
   // TODO(nainar): Move all fixed point logic to a separate class.
   // border-top-width
   float BorderTopWidth() const {
-    if (surround_data_->border_.top_.Style() == kBorderStyleNone ||
-        surround_data_->border_.top_.Style() == kBorderStyleHidden)
+    if (surround_data_->border_.top_.Style() == EBorderStyle::kNone ||
+        surround_data_->border_.top_.Style() == EBorderStyle::kHidden)
       return 0;
     return static_cast<float>(BorderTopWidthInternal()) /
            kBorderWidthDenominator;
   }
   void SetBorderTopWidth(float v) {
     SetBorderTopWidthInternal(WidthToFixedPoint(v));
   }
 
   // border-bottom-width
   float BorderBottomWidth() const {
-    if (surround_data_->border_.bottom_.Style() == kBorderStyleNone ||
-        surround_data_->border_.bottom_.Style() == kBorderStyleHidden)
+    if (surround_data_->border_.bottom_.Style() == EBorderStyle::kNone ||
+        surround_data_->border_.bottom_.Style() == EBorderStyle::kHidden)
       return 0;
     return static_cast<float>(BorderBottomWidthInternal()) /
            kBorderWidthDenominator;
   }
   void SetBorderBottomWidth(float v) {
     SetBorderBottomWidthInternal(WidthToFixedPoint(v));
   }
 
   // border-left-width
   float BorderLeftWidth() const {
-    if (surround_data_->border_.left_.Style() == kBorderStyleNone ||
-        surround_data_->border_.left_.Style() == kBorderStyleHidden)
+    if (surround_data_->border_.left_.Style() == EBorderStyle::kNone ||
+        surround_data_->border_.left_.Style() == EBorderStyle::kHidden)
       return 0;
     return static_cast<float>(BorderLeftWidthInternal()) /
            kBorderWidthDenominator;
   }
   void SetBorderLeftWidth(float v) {
     SetBorderLeftWidthInternal(WidthToFixedPoint(v));
   }
 
   // border-right-width
   float BorderRightWidth() const {
-    if (surround_data_->border_.right_.Style() == kBorderStyleNone ||
-        surround_data_->border_.right_.Style() == kBorderStyleHidden)
+    if (surround_data_->border_.right_.Style() == EBorderStyle::kNone ||
+        surround_data_->border_.right_.Style() == EBorderStyle::kHidden)
       return 0;
     return static_cast<float>(BorderRightWidthInternal()) /
            kBorderWidthDenominator;
   }
   void SetBorderRightWidth(float v) {
     SetBorderRightWidthInternal(WidthToFixedPoint(v));
   }
 
   // Border style properties.
-  static EBorderStyle InitialBorderStyle() { return kBorderStyleNone; }
+  static EBorderStyle InitialBorderStyle() { return EBorderStyle::kNone; }
 
   // border-top-style
   EBorderStyle BorderTopStyle() const {
     return surround_data_->border_.Top().Style();
   }
   void SetBorderTopStyle(EBorderStyle v) {
-    SET_VAR(surround_data_, border_.top_.style_, v);
+    SET_VAR(surround_data_, border_.top_.style_, static_cast<unsigned>(v));
   }
 
   // border-right-style
   EBorderStyle BorderRightStyle() const {
     return surround_data_->border_.Right().Style();
   }
   void SetBorderRightStyle(EBorderStyle v) {
-    SET_VAR(surround_data_, border_.right_.style_, v);
+    SET_VAR(surround_data_, border_.right_.style_, static_cast<unsigned>(v));
   }
 
   // border-left-style
   EBorderStyle BorderLeftStyle() const {
     return surround_data_->border_.Left().Style();
   }
   void SetBorderLeftStyle(EBorderStyle v) {
-    SET_VAR(surround_data_, border_.left_.style_, v);
+    SET_VAR(surround_data_, border_.left_.style_, static_cast<unsigned>(v));
   }
 
   // border-bottom-style
   EBorderStyle BorderBottomStyle() const {
     return surround_data_->border_.Bottom().Style();
   }
   void SetBorderBottomStyle(EBorderStyle v) {
-    SET_VAR(surround_data_, border_.bottom_.style_, v);
+    SET_VAR(surround_data_, border_.bottom_.style_, static_cast<unsigned>(v));
   }
 
   // Border color properties.
   // border-left-color
   void SetBorderLeftColor(const StyleColor& color) {
     if (!compareEqual(BorderLeftColor(), color)) {
       SetBorderLeftColorInternal(color.Resolve(Color()));
       SetBorderLeftColorIsCurrentColor(color.IsCurrentColor());
     }
   }
@@ skipping 88 matching lines @@
   void SetColumnRuleColor(const StyleColor& c) {
     SET_BORDERVALUE_COLOR(rare_non_inherited_data_.Access()->multi_col_, rule_,
                           c);
   }
 
   // column-rule-style (aka -webkit-column-rule-style)
   EBorderStyle ColumnRuleStyle() const {
     return rare_non_inherited_data_->multi_col_->rule_.Style();
   }
   void SetColumnRuleStyle(EBorderStyle b) {
-    SET_NESTED_VAR(rare_non_inherited_data_, multi_col_, rule_.style_, b);
+    SET_NESTED_VAR(rare_non_inherited_data_, multi_col_, rule_.style_,
+                   static_cast<unsigned>(b));
   }
 
   // column-rule-width (aka -webkit-column-rule-width)
   static unsigned short InitialColumnRuleWidth() { return 3; }
   unsigned short ColumnRuleWidth() const {
     return rare_non_inherited_data_->multi_col_->RuleWidth();
   }
   void SetColumnRuleWidth(unsigned short w) {
     SET_NESTED_BORDER_WIDTH(rare_non_inherited_data_, multi_col_, rule_, w);
   }
@@ skipping 469 matching lines @@
   // outline-color
   void SetOutlineColor(const StyleColor& v) {
     SET_BORDERVALUE_COLOR(rare_non_inherited_data_, outline_, v);
   }
 
   // outline-style
   EBorderStyle OutlineStyle() const {
     return rare_non_inherited_data_->outline_.Style();
   }
   void SetOutlineStyle(EBorderStyle v) {
-    SET_VAR(rare_non_inherited_data_, outline_.style_, v);
+    SET_VAR(rare_non_inherited_data_, outline_.style_,
+            static_cast<unsigned>(v));
   }
   static OutlineIsAuto InitialOutlineStyleIsAuto() { return kOutlineIsAutoOff; }
   OutlineIsAuto OutlineStyleIsAuto() const {
     return static_cast<OutlineIsAuto>(
         rare_non_inherited_data_->outline_.IsAuto());
   }
   void SetOutlineStyleIsAuto(OutlineIsAuto is_auto) {
     SET_VAR(rare_non_inherited_data_, outline_.is_auto_, is_auto);
   }
 
   // outline-width
   static unsigned short InitialOutlineWidth() { return 3; }
   unsigned short OutlineWidth() const {
-    if (rare_non_inherited_data_->outline_.Style() == kBorderStyleNone)
+    if (rare_non_inherited_data_->outline_.Style() == EBorderStyle::kNone)
       return 0;
     return rare_non_inherited_data_->outline_.Width();
   }
   void SetOutlineWidth(unsigned short v) {
     SET_BORDER_WIDTH(rare_non_inherited_data_, outline_, v);
   }
 
   // outline-offset
   static int InitialOutlineOffset() { return 0; }
   int OutlineOffset() const {
-    if (rare_non_inherited_data_->outline_.Style() == kBorderStyleNone)
+    if (rare_non_inherited_data_->outline_.Style() == EBorderStyle::kNone)
       return 0;
     return rare_non_inherited_data_->outline_.Offset();
   }
   void SetOutlineOffset(int v) {
     SET_VAR(rare_non_inherited_data_, outline_.offset_, v);
   }
 
   // perspective (aka -webkit-perspective)
   static float InitialPerspective() { return 0; }
   float Perspective() const { return rare_non_inherited_data_->perspective_; }
@@ skipping 1698 matching lines @@
                 o.BorderLeftColorIsCurrentColor() &&
             BorderRightColorIsCurrentColor() ==
                 o.BorderRightColorIsCurrentColor() &&
             BorderTopColorIsCurrentColor() ==
                 o.BorderTopColorIsCurrentColor() &&
             BorderBottomColorIsCurrentColor() ==
                 o.BorderBottomColorIsCurrentColor());
   }
 
   bool BorderColorVisuallyEquals(const ComputedStyle& o) const {
-    if ((BorderLeftStyle() == kBorderStyleNone &&
-         o.BorderLeftStyle() == kBorderStyleNone) &&
-        (BorderRightStyle() == kBorderStyleNone &&
-         o.BorderRightStyle() == kBorderStyleNone) &&
-        (BorderTopStyle() == kBorderStyleNone &&
-         o.BorderTopStyle() == kBorderStyleNone) &&
-        (BorderBottomStyle() == kBorderStyleNone &&
-         o.BorderBottomStyle() == kBorderStyleNone))
+    if ((BorderLeftStyle() == EBorderStyle::kNone &&
+         o.BorderLeftStyle() == EBorderStyle::kNone) &&
+        (BorderRightStyle() == EBorderStyle::kNone &&
+         o.BorderRightStyle() == EBorderStyle::kNone) &&
+        (BorderTopStyle() == EBorderStyle::kNone &&
+         o.BorderTopStyle() == EBorderStyle::kNone) &&
+        (BorderBottomStyle() == EBorderStyle::kNone &&
+         o.BorderBottomStyle() == EBorderStyle::kNone))
       return true;
-    if ((BorderLeftStyle() == kBorderStyleHidden &&
-         o.BorderLeftStyle() == kBorderStyleHidden) &&
-        (BorderRightStyle() == kBorderStyleHidden &&
-         o.BorderRightStyle() == kBorderStyleHidden) &&
-        (BorderTopStyle() == kBorderStyleHidden &&
-         o.BorderTopStyle() == kBorderStyleHidden) &&
-        (BorderBottomStyle() == kBorderStyleHidden &&
-         o.BorderBottomStyle() == kBorderStyleHidden))
+    if ((BorderLeftStyle() == EBorderStyle::kHidden &&
+         o.BorderLeftStyle() == EBorderStyle::kHidden) &&
+        (BorderRightStyle() == EBorderStyle::kHidden &&
+         o.BorderRightStyle() == EBorderStyle::kHidden) &&
+        (BorderTopStyle() == EBorderStyle::kHidden &&
+         o.BorderTopStyle() == EBorderStyle::kHidden) &&
+        (BorderBottomStyle() == EBorderStyle::kHidden &&
+         o.BorderBottomStyle() == EBorderStyle::kHidden))
       return true;
     return BorderColorEquals(o);
   }
 
   void ResetBorder() {
     ResetBorderImage();
     ResetBorderTop();
     ResetBorderRight();
     ResetBorderBottom();
     ResetBorderLeft();
@@ skipping 77 matching lines @@
     return rare_non_inherited_data_->perspective_ > 0;
   }
 
   // Page size utility functions.
   void ResetPageSizeType() {
     SET_VAR(rare_non_inherited_data_, page_size_type_, PAGE_SIZE_AUTO);
   }
 
   // Outline utility functions.
   bool HasOutline() const {
-    return OutlineWidth() > 0 && OutlineStyle() > kBorderStyleHidden;
+    return OutlineWidth() > 0 && OutlineStyle() > EBorderStyle::kHidden;
   }
   int OutlineOutsetExtent() const;
   float GetOutlineStrokeWidthForFocusRing() const;
   bool HasOutlineWithCurrentColor() const {
     return HasOutline() && OutlineColor().IsCurrentColor();
   }
 
   // Position utility functions.
   bool HasOutOfFlowPosition() const {
     return GetPosition() == EPosition::kAbsolute ||
@@ skipping 733 matching lines @@
       PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h