Make SelectionState enum class

third_party/WebKit/Source/core/layout/line/InlineTextBox.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 155 matching lines @@
 bool InlineTextBox::IsSelected(int start_pos, int end_pos) const {
   int s_pos = std::max(start_pos - start_, 0);
   // The position after a hard line break is considered to be past its end.
   // See the corresponding code in InlineTextBox::getSelectionState.
   int e_pos = std::min(end_pos - start_, int(len_) + (IsLineBreak() ? 0 : 1));
   return (s_pos < e_pos);
 }
 
 SelectionState InlineTextBox::GetSelectionState() const {
   SelectionState state = GetLineLayoutItem().GetSelectionState();
-  if (state == SelectionStart || state == SelectionEnd ||
-      state == SelectionBoth) {
+  if (state == SelectionState::kStart || state == SelectionState::kEnd ||
+      state == SelectionState::kStartAndEnd) {
     int start_pos, end_pos;
     std::tie(start_pos, end_pos) = GetLineLayoutItem().SelectionStartEnd();
     // The position after a hard line break is considered to be past its end.
     // See the corresponding code in InlineTextBox::isSelected.
     int last_selectable = Start() + Len() - (IsLineBreak() ? 1 : 0);
 
     // FIXME: Remove -webkit-line-break: LineBreakAfterWhiteSpace.
     int end_of_line_adjustment_for_css_line_break =
         GetLineLayoutItem().Style()->GetLineBreak() ==
                 LineBreak::kAfterWhiteSpace
             ? -1
             : 0;
-    bool start = (state != SelectionEnd && start_pos >= start_ &&
+    bool start = (state != SelectionState::kEnd && start_pos >= start_ &&
                   start_pos <= start_ + len_ +
                                    end_of_line_adjustment_for_css_line_break);
-    bool end = (state != SelectionStart && end_pos > start_ &&
+    bool end = (state != SelectionState::kStart && end_pos > start_ &&
                 end_pos <= last_selectable);
     if (start && end)
-      state = SelectionBoth;
+      state = SelectionState::kStartAndEnd;
     else if (start)
-      state = SelectionStart;
+      state = SelectionState::kStart;
     else if (end)
-      state = SelectionEnd;
-    else if ((state == SelectionEnd || start_pos < start_) &&
-             (state == SelectionStart || end_pos > last_selectable))
-      state = SelectionInside;
-    else if (state == SelectionBoth)
-      state = SelectionNone;
+      state = SelectionState::kEnd;
+    else if ((state == SelectionState::kEnd || start_pos < start_) &&
+             (state == SelectionState::kStart || end_pos > last_selectable))
+      state = SelectionState::kInside;
+    else if (state == SelectionState::kStartAndEnd)
+      state = SelectionState::kNone;
   }
 
   // If there are ellipsis following, make sure their selection is updated.
   if (truncation_ != kCNoTruncation && Root().GetEllipsisBox()) {
     EllipsisBox* ellipsis = Root().GetEllipsisBox();
-    if (state != SelectionNone) {
+    if (state != SelectionState::kNone) {
       int start, end;
       SelectionStartEnd(start, end);
       // The ellipsis should be considered to be selected if the end of the
       // selection is past the beginning of the truncation and the beginning of
       // the selection is before or at the beginning of the truncation.
       ellipsis->SetSelectionState(end >= truncation_ && start <= truncation_
-                                      ? SelectionInside
-                                      : SelectionNone);
+                                      ? SelectionState::kInside
+                                      : SelectionState::kNone);
     } else {
-      ellipsis->SetSelectionState(SelectionNone);
+      ellipsis->SetSelectionState(SelectionState::kNone);
     }
   }
 
   return state;
 }
 
 bool InlineTextBox::HasWrappedSelectionNewline() const {
   DCHECK(!GetLineLayoutItem().NeedsLayout());
 
   SelectionState state = GetSelectionState();
-  if (state != SelectionStart && state != SelectionInside)
+  if (state != SelectionState::kStart && state != SelectionState::kInside)
     return false;
 
   // Checking last leaf child can be slow, so we make sure to do this
   // only after checking selection state.
   if (Root().LastLeafChild() != this)
     return false;
 
   // It's possible to have mixed LTR/RTL on a single line, and we only
   // want to paint a newline when we're the last leaf child and we make
   // sure there isn't a differently-directioned box following us.
   bool is_ltr = IsLeftToRightDirection();
   if ((!is_ltr && Root().FirstSelectedBox() != this) ||
       (is_ltr && Root().LastSelectedBox() != this))
     return false;
 
   // If we're the last inline text box in containing block, our containing block
   // is inline, and the selection continues into that block, then rely on the
   // next inline text box (if any) to paint a wrapped new line as needed.
   if (NextTextBox())
     return true;
   auto root_block = Root().Block();
-  if (root_block.IsInline() && root_block.GetSelectionState() != SelectionEnd &&
-      root_block.GetSelectionState() != SelectionBoth &&
+  if (root_block.IsInline() &&
+      root_block.GetSelectionState() != SelectionState::kEnd &&
+      root_block.GetSelectionState() != SelectionState::kStartAndEnd &&
       root_block.InlineBoxWrapper() &&
       ((is_ltr && root_block.InlineBoxWrapper()->NextOnLine()) ||
        (!is_ltr && root_block.InlineBoxWrapper()->PrevOnLine()))) {
     return false;
   }
 
   return true;
 }
 
 float InlineTextBox::NewlineSpaceWidth() const {
@@ skipping 251 matching lines @@
 
 void InlineTextBox::Paint(const PaintInfo& paint_info,
                           const LayoutPoint& paint_offset,
                           LayoutUnit /*lineTop*/,
                           LayoutUnit /*lineBottom*/) const {
   InlineTextBoxPainter(*this).Paint(paint_info, paint_offset);
 }
 
 void InlineTextBox::SelectionStartEnd(int& s_pos, int& e_pos) const {
   int start_pos, end_pos;
-  if (GetLineLayoutItem().GetSelectionState() == SelectionInside) {
+  if (GetLineLayoutItem().GetSelectionState() == SelectionState::kInside) {
     start_pos = 0;
     end_pos = GetLineLayoutItem().TextLength();
   } else {
     std::tie(start_pos, end_pos) = GetLineLayoutItem().SelectionStartEnd();
-    if (GetLineLayoutItem().GetSelectionState() == SelectionStart)
+    if (GetLineLayoutItem().GetSelectionState() == SelectionState::kStart)
       end_pos = GetLineLayoutItem().TextLength();
-    else if (GetLineLayoutItem().GetSelectionState() == SelectionEnd)
+    else if (GetLineLayoutItem().GetSelectionState() == SelectionState::kEnd)
       start_pos = 0;
   }
 
   s_pos = std::max(start_pos - start_, 0);
   e_pos = std::min(end_pos - start_, (int)len_);
 }
 
 void InlineTextBox::PaintDocumentMarker(GraphicsContext& pt,
                                         const LayoutPoint& box_origin,
                                         const DocumentMarker& marker,
@@ skipping 203 matching lines @@
   for (; printed_characters < kLayoutObjectCharacterOffset;
        printed_characters++)
     fputc(' ', stderr);
   fprintf(stderr, "(%d,%d) \"%s\"\n", Start(), Start() + Len(),
           value.Utf8().data());
 }
 
 #endif
 
 }  // namespace blink