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 63 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 489 matching lines @@
       ResolveUnderlinePosition(*decoration_info.style, &box);
   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, decoration_info.thickness);
       AppliedDecorationPainter decoration_painter(
           context, decoration_info, underline_offset, decoration,
           decoration_info.double_offset, 1);
       if (skip_intercepts) {
         text_painter.ClipDecorationsStripe(
             -decoration_info.baseline +
                 decoration_painter.DecorationBounds().Y() -
                 decoration_info.local_origin.Y(),
             decoration_painter.DecorationBounds().Height(),
             decoration_info.thickness);
       }
       decoration_painter.Paint();
     }
-    if (lines & kTextDecorationOverline) {
+    if (EnumHasFlags(lines, TextDecoration::kOverline)) {
       const int overline_offset =
           ComputeOverlineOffset(*decoration_info.style, &box);
       AppliedDecorationPainter decoration_painter(
           context, decoration_info, overline_offset, decoration,
           -decoration_info.double_offset, 1);
       if (skip_intercepts) {
         text_painter.ClipDecorationsStripe(
             -decoration_info.baseline +
                 decoration_painter.DecorationBounds().Y() -
                 decoration_info.local_origin.Y(),
             decoration_painter.DecorationBounds().Height(),
             decoration_info.thickness);
       }
       decoration_painter.Paint();
     }
     // 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);
   }
 }
 
 static void PaintDecorationsOnlyLineThrough(
     TextPainter& text_painter,
     const DecorationInfo& decoration_info,
     const PaintInfo& paint_info,
     const Vector<AppliedTextDecoration>& decorations) {
   GraphicsContext& context = paint_info.context;
   GraphicsContextStateSaver state_saver(context);
   context.SetStrokeThickness(decoration_info.thickness);
   for (const AppliedTextDecoration& decoration : decorations) {
     TextDecoration lines = decoration.Lines();
-    if (lines & kTextDecorationLineThrough) {
+    if (EnumHasFlags(lines, TextDecoration::kLineThrough)) {
       const float line_through_offset = 2 * decoration_info.baseline / 3;
       AppliedDecorationPainter decoration_painter(
           context, decoration_info, line_through_offset, decoration,
           decoration_info.double_offset, 0);
       // No skip: ink for line-through,
       // compare https://github.com/w3c/csswg-drafts/issues/711
       decoration_painter.Paint();
     }
   }
 }
@@ skipping 195 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) {
       ComputeDecorationInfo(decoration_info, inline_text_box_, box_origin,
                             style_to_use.AppliedTextDecorations());
       GraphicsContextStateSaver state_saver(context, false);
       PrepareContextForDecoration(context, state_saver,
                                   inline_text_box_.IsHorizontal(), text_style,
                                   combined_text, box_rect);
       PaintDecorationsExceptLineThrough(
           text_painter, has_line_through_decoration, inline_text_box_,
           decoration_info, paint_info, style_to_use.AppliedTextDecorations());
@@ skipping 579 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