Make EBorderStyle an enum class.

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

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2013 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
@@ skipping 1172 matching lines @@
     return LayoutBlock::BorderStart().ToInt();
 
   // Determined by the first cell of the first row. See the CSS 2.1 spec,
   // section 17.6.2.
   if (!NumEffectiveColumns())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& table_start_border = Style()->BorderStart();
-  if (table_start_border.Style() == kBorderStyleHidden)
+  if (table_start_border.Style() == EBorderStyle::kHidden)
     return 0;
-  if (table_start_border.Style() > kBorderStyleHidden)
+  if (table_start_border.Style() > EBorderStyle::kHidden)
     border_width = table_start_border.Width();
 
   // TODO(dgrogan): This logic doesn't properly account for the first column in
   // the first column-group case.
   if (LayoutTableCol* column =
           ColElementAtAbsoluteColumn(0).InnermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& column_adjoining_border = column->Style()->BorderStart();
-    if (column_adjoining_border.Style() == kBorderStyleHidden)
+    if (column_adjoining_border.Style() == EBorderStyle::kHidden)
       return 0;
-    if (column_adjoining_border.Style() > kBorderStyleHidden)
+    if (column_adjoining_border.Style() > EBorderStyle::kHidden)
       border_width =
           std::max<int>(border_width, column_adjoining_border.Width());
   }
 
   if (const LayoutTableSection* top_non_empty_section =
           this->TopNonEmptySection()) {
     const BorderValue& section_adjoining_border =
         top_non_empty_section->BorderAdjoiningTableStart();
-    if (section_adjoining_border.Style() == kBorderStyleHidden)
+    if (section_adjoining_border.Style() == EBorderStyle::kHidden)
       return 0;
 
-    if (section_adjoining_border.Style() > kBorderStyleHidden)
+    if (section_adjoining_border.Style() > EBorderStyle::kHidden)
       border_width =
           std::max<int>(border_width, section_adjoining_border.Width());
 
     if (const LayoutTableCell* adjoining_start_cell =
             top_non_empty_section->FirstRowCellAdjoiningTableStart()) {
       // FIXME: Make this work with perpendicular and flipped cells.
       const BorderValue& start_cell_adjoining_border =
           adjoining_start_cell->BorderAdjoiningTableStart();
-      if (start_cell_adjoining_border.Style() == kBorderStyleHidden)
+      if (start_cell_adjoining_border.Style() == EBorderStyle::kHidden)
         return 0;
 
       const BorderValue& first_row_adjoining_border =
           adjoining_start_cell->Row()->BorderAdjoiningTableStart();
-      if (first_row_adjoining_border.Style() == kBorderStyleHidden)
+      if (first_row_adjoining_border.Style() == EBorderStyle::kHidden)
         return 0;
 
-      if (start_cell_adjoining_border.Style() > kBorderStyleHidden) {
+      if (start_cell_adjoining_border.Style() > EBorderStyle::kHidden) {
         border_width =
             std::max<int>(border_width, start_cell_adjoining_border.Width());
       }
-      if (first_row_adjoining_border.Style() > kBorderStyleHidden) {
+      if (first_row_adjoining_border.Style() > EBorderStyle::kHidden) {
         border_width =
             std::max<int>(border_width, first_row_adjoining_border.Width());
       }
     }
   }
   return (border_width + (Style()->IsLeftToRightDirection() ? 0 : 1)) / 2;
 }
 
 int LayoutTable::CalcBorderEnd() const {
   if (!ShouldCollapseBorders())
     return LayoutBlock::BorderEnd().ToInt();
 
   // Determined by the last cell of the first row. See the CSS 2.1 spec, section
   // 17.6.2.
   if (!NumEffectiveColumns())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& table_end_border = Style()->BorderEnd();
-  if (table_end_border.Style() == kBorderStyleHidden)
+  if (table_end_border.Style() == EBorderStyle::kHidden)
     return 0;
-  if (table_end_border.Style() > kBorderStyleHidden)
+  if (table_end_border.Style() > EBorderStyle::kHidden)
     border_width = table_end_border.Width();
 
   unsigned end_column = NumEffectiveColumns() - 1;
 
   // TODO(dgrogan): This logic doesn't properly account for the last column in
   // the last column-group case.
   if (LayoutTableCol* column =
           ColElementAtAbsoluteColumn(end_column).InnermostColOrColGroup()) {
     // FIXME: We don't account for direction on columns and column groups.
     const BorderValue& column_adjoining_border = column->Style()->BorderEnd();
-    if (column_adjoining_border.Style() == kBorderStyleHidden)
+    if (column_adjoining_border.Style() == EBorderStyle::kHidden)
       return 0;
-    if (column_adjoining_border.Style() > kBorderStyleHidden)
+    if (column_adjoining_border.Style() > EBorderStyle::kHidden)
       border_width =
           std::max<int>(border_width, column_adjoining_border.Width());
   }
 
   if (const LayoutTableSection* top_non_empty_section =
           this->TopNonEmptySection()) {
     const BorderValue& section_adjoining_border =
         top_non_empty_section->BorderAdjoiningTableEnd();
-    if (section_adjoining_border.Style() == kBorderStyleHidden)
+    if (section_adjoining_border.Style() == EBorderStyle::kHidden)
       return 0;
 
-    if (section_adjoining_border.Style() > kBorderStyleHidden)
+    if (section_adjoining_border.Style() > EBorderStyle::kHidden)
       border_width =
           std::max<int>(border_width, section_adjoining_border.Width());
 
     if (const LayoutTableCell* adjoining_end_cell =
             top_non_empty_section->FirstRowCellAdjoiningTableEnd()) {
       // FIXME: Make this work with perpendicular and flipped cells.
       const BorderValue& end_cell_adjoining_border =
           adjoining_end_cell->BorderAdjoiningTableEnd();
-      if (end_cell_adjoining_border.Style() == kBorderStyleHidden)
+      if (end_cell_adjoining_border.Style() == EBorderStyle::kHidden)
         return 0;
 
       const BorderValue& first_row_adjoining_border =
           adjoining_end_cell->Row()->BorderAdjoiningTableEnd();
-      if (first_row_adjoining_border.Style() == kBorderStyleHidden)
+      if (first_row_adjoining_border.Style() == EBorderStyle::kHidden)
         return 0;
 
-      if (end_cell_adjoining_border.Style() > kBorderStyleHidden) {
+      if (end_cell_adjoining_border.Style() > EBorderStyle::kHidden) {
         border_width =
             std::max<int>(border_width, end_cell_adjoining_border.Width());
       }
-      if (first_row_adjoining_border.Style() > kBorderStyleHidden) {
+      if (first_row_adjoining_border.Style() > EBorderStyle::kHidden) {
         border_width =
             std::max<int>(border_width, first_row_adjoining_border.Width());
       }
     }
   }
   return (border_width + (Style()->IsLeftToRightDirection() ? 1 : 0)) / 2;
 }
 
 void LayoutTable::RecalcBordersInRowDirection() {
   // FIXME: We need to compute the collapsed before / after borders in the same
@@ skipping 21 matching lines @@
 int LayoutTable::OuterBorderBefore() const {
   if (!ShouldCollapseBorders())
     return 0;
   int border_width = 0;
   if (LayoutTableSection* top_section = this->TopSection()) {
     border_width = top_section->OuterBorderBefore();
     if (border_width < 0)
       return 0;  // Overridden by hidden
   }
   const BorderValue& tb = Style()->BorderBefore();
-  if (tb.Style() == kBorderStyleHidden)
+  if (tb.Style() == EBorderStyle::kHidden)
     return 0;
-  if (tb.Style() > kBorderStyleHidden)
+  if (tb.Style() > EBorderStyle::kHidden)
     border_width = std::max<int>(border_width, tb.Width() / 2);
   return border_width;
 }
 
 int LayoutTable::OuterBorderAfter() const {
   if (!ShouldCollapseBorders())
     return 0;
   int border_width = 0;
 
   if (LayoutTableSection* section = BottomSection()) {
     border_width = section->OuterBorderAfter();
     if (border_width < 0)
       return 0;  // Overridden by hidden
   }
   const BorderValue& tb = Style()->BorderAfter();
-  if (tb.Style() == kBorderStyleHidden)
+  if (tb.Style() == EBorderStyle::kHidden)
     return 0;
-  if (tb.Style() > kBorderStyleHidden)
+  if (tb.Style() > EBorderStyle::kHidden)
     border_width = std::max<int>(border_width, (tb.Width() + 1) / 2);
   return border_width;
 }
 
 int LayoutTable::OuterBorderStart() const {
   if (!ShouldCollapseBorders())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& tb = Style()->BorderStart();
-  if (tb.Style() == kBorderStyleHidden)
+  if (tb.Style() == EBorderStyle::kHidden)
     return 0;
-  if (tb.Style() > kBorderStyleHidden)
+  if (tb.Style() > EBorderStyle::kHidden)
     border_width =
         (tb.Width() + (Style()->IsLeftToRightDirection() ? 0 : 1)) / 2;
 
   bool all_hidden = true;
   for (LayoutTableSection* section = TopSection(); section;
        section = SectionBelow(section)) {
     int sw = section->OuterBorderStart();
     if (sw < 0)
       continue;
     all_hidden = false;
     border_width = std::max(border_width, sw);
   }
   if (all_hidden)
     return 0;
 
   return border_width;
 }
 
 int LayoutTable::OuterBorderEnd() const {
   if (!ShouldCollapseBorders())
     return 0;
 
   int border_width = 0;
 
   const BorderValue& tb = Style()->BorderEnd();
-  if (tb.Style() == kBorderStyleHidden)
+  if (tb.Style() == EBorderStyle::kHidden)
     return 0;
-  if (tb.Style() > kBorderStyleHidden)
+  if (tb.Style() > EBorderStyle::kHidden)
     border_width =
         (tb.Width() + (Style()->IsLeftToRightDirection() ? 1 : 0)) / 2;
 
   bool all_hidden = true;
   for (LayoutTableSection* section = TopSection(); section;
        section = SectionBelow(section)) {
     int sw = section->OuterBorderEnd();
     if (sw < 0)
       continue;
     all_hidden = false;
@@ skipping 337 matching lines @@
 }
 
 LayoutUnit LayoutTable::PaddingRight() const {
   if (ShouldCollapseBorders())
     return LayoutUnit();
 
   return LayoutBlock::PaddingRight();
 }
 
 }  // namespace blink