Make TextDecoration an enum class.

third_party/WebKit/Source/core/paint/InlineTextBoxPainter.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/InlineTextBoxPainter.h"
 
 #include "core/editing/CompositionUnderline.h"
 #include "core/editing/Editor.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 34 matching lines @@
     const InlineTextBox* inline_text_box) {
   bool first_line = inline_text_box->IsFirstLineStyle();
   for (LineLayoutItem current = inline_text_box->Parent()->GetLineLayoutItem();
        ;) {
     if (current.IsLayoutBlock())
       return current;
     if (!current.IsLayoutInline() || current.IsRubyText())
       return nullptr;
 
     const ComputedStyle& style_to_use = current.StyleRef(first_line);
-    if (style_to_use.GetTextDecoration() & kTextDecorationUnderline)
+    if (EnumHasFlags(style_to_use.GetTextDecoration(),
+                     TextDecoration::kUnderline))
       return current;
 
     current = current.Parent();
     if (!current)
       return current;
 
     if (Node* node = current.GetNode()) {
       if (isHTMLAnchorElement(node) || node->HasTagName(HTMLNames::fontTag))
         return current;
     }
@@ skipping 153 matching lines @@
       decoration_info.underline_position;
   bool flip_underline_and_overline = false;
   if (underline_position == ResolvedUnderlinePosition::kOver) {
     flip_underline_and_overline = true;
     underline_position = ResolvedUnderlinePosition::kUnder;
   }
 
   for (const AppliedTextDecoration& decoration : decorations) {
     TextDecoration lines = decoration.Lines();
     if (flip_underline_and_overline) {
-      lines = static_cast<TextDecoration>(
-          lines ^ (kTextDecorationUnderline | kTextDecorationOverline));
+      lines ^= (TextDecoration::kUnderline | TextDecoration::kOverline);
     }
-    if ((lines & kTextDecorationUnderline) && decoration_info.font_data) {
+    if (EnumHasFlags(lines, TextDecoration::kUnderline) &&
+        decoration_info.font_data) {
       const int underline_offset = ComputeUnderlineOffset(
           underline_position, *decoration_info.style,
           decoration_info.font_data->GetFontMetrics(), &box, decorating_box,
           decoration_info.thickness);
       text_painter.PaintDecorationUnderOrOverLine(
           context, decoration_info, decoration, underline_offset,
           decoration_info.double_offset);
     }
-    if (lines & kTextDecorationOverline) {
+    if (EnumHasFlags(lines, TextDecoration::kOverline)) {
       const int overline_offset = ComputeUnderlineOffsetForUnder(
           *decoration_info.style, &box, decorating_box,
           decoration_info.thickness,
           flip_underline_and_overline ? LineVerticalPositionType::TopOfEmHeight
                                       : LineVerticalPositionType::TextTop);
       text_painter.PaintDecorationUnderOrOverLine(
           context, decoration_info, decoration, overline_offset,
           -decoration_info.double_offset);
     }
     // We could instead build a vector of the TextDecoration instances needing
     // line-through but this is a rare case so better to avoid vector overhead.
-    has_line_through_decoration |= ((lines & kTextDecorationLineThrough) != 0);
+    has_line_through_decoration |=
+        EnumHasFlags(lines, TextDecoration::kLineThrough);
   }
 }
 
 void InlineTextBoxPainter::Paint(const PaintInfo& paint_info,
                                  const LayoutPoint& paint_offset) {
   if (!ShouldPaintTextBox(paint_info))
     return;
 
   DCHECK(!ShouldPaintSelfOutline(paint_info.phase) &&
          !ShouldPaintDescendantOutlines(paint_info.phase));
@@ skipping 188 matching lines @@
                                  emphasis_mark_position);
   if (combined_text)
     text_painter.SetCombinedText(combined_text);
   if (inline_text_box_.Truncation() != kCNoTruncation && ltr != flow_is_ltr)
     text_painter.SetEllipsisOffset(inline_text_box_.Truncation());
 
   if (!paint_selected_text_only) {
     // Paint text decorations except line-through.
     DecorationInfo decoration_info;
     bool has_line_through_decoration = false;
-    if (style_to_use.TextDecorationsInEffect() != kTextDecorationNone &&
+    if (style_to_use.TextDecorationsInEffect() != TextDecoration::kNone &&
         inline_text_box_.Truncation() != kCFullTruncation) {
       LayoutPoint local_origin = LayoutPoint(box_origin);
       LayoutUnit width = inline_text_box_.LogicalWidth();
       ComputeOriginAndWidthForBox(inline_text_box_, local_origin, width);
       const LineLayoutItem& decorating_box =
           EnclosingUnderlineObject(&inline_text_box_);
       const ComputedStyle* decorating_box_style =
           decorating_box ? decorating_box.Style() : nullptr;
       text_painter.ComputeDecorationInfo(decoration_info, box_origin,
                                          local_origin, width,
@@ skipping 705 matching lines @@
 
   LayoutRect box_rect(box_origin, LayoutSize(inline_text_box_.LogicalWidth(),
                                              inline_text_box_.LogicalHeight()));
   context.Clip(FloatRect(box_rect));
   context.DrawHighlightForText(font, run, FloatPoint(box_origin),
                                box_rect.Height().ToInt(), color,
                                paint_offsets.first, paint_offsets.second);
 }
 
 }  // namespace blink