Make SelectionState enum class

third_party/WebKit/Source/core/editing/LayoutSelection.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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 163 matching lines @@
 
   SelectedMap selected_map;
 
   LayoutObject* const stop =
       LayoutObjectAfterPosition(range.EndLayoutObject(), range.EndOffset());
   for (LayoutObject* runner = range.StartLayoutObject();
        runner && (runner != stop); runner = runner->NextInPreOrder()) {
     if (!runner->CanBeSelectionLeaf() && runner != range.StartLayoutObject() &&
         runner != range.EndLayoutObject())
       continue;
-    if (runner->GetSelectionState() == SelectionNone)
+    if (runner->GetSelectionState() == SelectionState::kNone)
       continue;
 
     // Blocks are responsible for painting line gaps and margin gaps.  They
     // must be examined as well.
     selected_map.object_map.Set(runner, runner->GetSelectionState());
     if (option == CollectSelectedMapOption::kCollectBlock) {
       LayoutBlock* containing_block = runner->ContainingBlock();
       while (containing_block && !containing_block->IsLayoutView()) {
         SelectedBlockMap::AddResult result = selected_map.block_map.insert(
             containing_block, containing_block->GetSelectionState());
         if (!result.is_new_entry)
           break;
         containing_block = containing_block->ContainingBlock();
       }
     }
   }
   return selected_map;
 }
 
 // Update the selection status of all LayoutObjects between |start| and |end|.
 static void SetSelectionState(const SelectionPaintRange& range) {
   if (range.IsNull())
     return;
 
   if (range.StartLayoutObject() == range.EndLayoutObject()) {
-    range.StartLayoutObject()->SetSelectionStateIfNeeded(SelectionBoth);
+    range.StartLayoutObject()->SetSelectionStateIfNeeded(
+        SelectionState::kStartAndEnd);
   } else {
-    range.StartLayoutObject()->SetSelectionStateIfNeeded(SelectionStart);
-    range.EndLayoutObject()->SetSelectionStateIfNeeded(SelectionEnd);
+    range.StartLayoutObject()->SetSelectionStateIfNeeded(
+        SelectionState::kStart);
+    range.EndLayoutObject()->SetSelectionStateIfNeeded(SelectionState::kEnd);
   }
 
   LayoutObject* const stop =
       LayoutObjectAfterPosition(range.EndLayoutObject(), range.EndOffset());
   for (LayoutObject* runner = range.StartLayoutObject();
        runner && runner != stop; runner = runner->NextInPreOrder()) {
     if (runner != range.StartLayoutObject() &&
         runner != range.EndLayoutObject() && runner->CanBeSelectionLeaf())
-      runner->SetSelectionStateIfNeeded(SelectionInside);
+      runner->SetSelectionStateIfNeeded(SelectionState::kInside);
   }
 }
 
 // Set SetSelectionState and ShouldInvalidateSelection flag of LayoutObjects
 // comparing them in |new_range| and |old_range|.
 static void UpdateLayoutObjectState(const SelectionPaintRange& new_range,
                                     const SelectionPaintRange& old_range) {
   SelectedMap old_selected_map =
       CollectSelectedMap(old_range, CollectSelectedMapOption::kCollectBlock);
 
   // Now clear the selection.
   for (auto layout_object : old_selected_map.object_map.Keys())
-    layout_object->SetSelectionStateIfNeeded(SelectionNone);
+    layout_object->SetSelectionStateIfNeeded(SelectionState::kNone);
 
   SetSelectionState(new_range);
 
   // Now that the selection state has been updated for the new objects, walk
   // them again and put them in the new objects list.
   // TODO(editing-dev): |new_selected_map| doesn't really need to store the
   // SelectionState, it's just more convenient to have it use the same data
   // structure as |old_selected_map|.
   SelectedMap new_selected_map =
       CollectSelectedMap(new_range, CollectSelectedMapOption::kCollectBlock);
@@ skipping 50 matching lines @@
 
   // Just return if the selection is already empty.
   if (paint_range_.IsNull())
     return;
 
   const SelectedMap& old_selected_map = CollectSelectedMap(
       paint_range_, CollectSelectedMapOption::kNotCollectBlock);
   // Clear SelectionState and invalidation.
   for (auto layout_object : old_selected_map.object_map.Keys()) {
     const SelectionState old_state = layout_object->GetSelectionState();
-    layout_object->SetSelectionStateIfNeeded(SelectionNone);
+    layout_object->SetSelectionStateIfNeeded(SelectionState::kNone);
     if (layout_object->GetSelectionState() == old_state)
       continue;
     layout_object->SetShouldInvalidateSelection();
   }
 
   // Reset selection.
   paint_range_ = SelectionPaintRange();
 }
 
 void LayoutSelection::Commit() {
@@ skipping 83 matching lines @@
   Commit();
   if (paint_range_.IsNull())
     return IntRect();
 
   LayoutObject* os = paint_range_.StartLayoutObject();
   LayoutObject* stop = LayoutObjectAfterPosition(paint_range_.EndLayoutObject(),
                                                  paint_range_.EndOffset());
   while (os && os != stop) {
     if ((os->CanBeSelectionLeaf() || os == paint_range_.StartLayoutObject() ||
          os == paint_range_.EndLayoutObject()) &&
-        os->GetSelectionState() != SelectionNone) {
+        os->GetSelectionState() != SelectionState::kNone) {
       // Blocks are responsible for painting line gaps and margin gaps. They
       // must be examined as well.
       sel_rect.Unite(SelectionRectForLayoutObject(os));
       const LayoutBlock* cb = os->ContainingBlock();
       while (cb && !cb->IsLayoutView()) {
         sel_rect.Unite(SelectionRectForLayoutObject(cb));
         VisitedContainingBlockSet::AddResult add_result =
             visited_containing_blocks.insert(cb);
         if (!add_result.is_new_entry)
           break;
@@ skipping 11 matching lines @@
   if (paint_range_.IsNull())
     return;
 
   LayoutObject* end = LayoutObjectAfterPosition(paint_range_.EndLayoutObject(),
                                                 paint_range_.EndOffset());
   for (LayoutObject* o = paint_range_.StartLayoutObject(); o && o != end;
        o = o->NextInPreOrder()) {
     if (!o->CanBeSelectionLeaf() && o != paint_range_.StartLayoutObject() &&
         o != paint_range_.EndLayoutObject())
       continue;
-    if (o->GetSelectionState() == SelectionNone)
+    if (o->GetSelectionState() == SelectionState::kNone)
       continue;
 
     o->SetShouldInvalidateSelection();
   }
 }
 
 DEFINE_TRACE(LayoutSelection) {
   visitor->Trace(frame_selection_);
 }
 
 }  // namespace blink