Clean up the SelectionControl class with c++11 enum class

Source/core/editing/SelectionController.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 37 matching lines @@
 namespace blink {
 PassOwnPtrWillBeRawPtr<SelectionController> SelectionController::create(LocalFrame& frame)
 {
     return adoptPtrWillBeNoop(new SelectionController(frame));
 }
 
 SelectionController::SelectionController(LocalFrame& frame)
     : m_frame(&frame)
     , m_mouseDownMayStartSelect(false)
     , m_mouseDownWasSingleClickInSelection(false)
-    , m_selectionInitiationState(HaveNotStartedSelection)
+    , m_selectionState(SelectionState::HaveNotStartedSelection)
 {
 }
 
 DEFINE_TRACE(SelectionController)
 {
     visitor->trace(m_frame);
 }
 
 static void setSelectionIfNeeded(FrameSelection& selection, const VisibleSelection& newSelection)
 {
@@ skipping 41 matching lines @@
 
 bool SelectionController::updateSelectionForMouseDownDispatchingSelectStart(Node* targetNode, const VisibleSelection& selection, TextGranularity granularity)
 {
     if (Position::nodeIsUserSelectNone(targetNode))
         return false;
 
     if (!dispatchSelectStart(targetNode))
         return false;
 
     if (selection.isRange()) {
-        m_selectionInitiationState = ExtendedSelection;
+        m_selectionState = SelectionState::ExtendedSelection;
     } else {
         granularity = CharacterGranularity;
-        m_selectionInitiationState = PlacedCaret;
+        m_selectionState = SelectionState::PlacedCaret;
     }
 
     m_frame->selection().setNonDirectionalSelectionIfNeeded(selection, granularity);
 
     return true;
 }
 
 void SelectionController::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
 {
     Node* innerNode = result.innerNode();
     VisibleSelection newSelection;
 
     if (innerNode && innerNode->layoutObject()) {
         VisiblePosition pos(innerNode->layoutObject()->positionForPoint(result.localPoint()));
         if (pos.isNotNull()) {
             newSelection = VisibleSelection(pos);
             expandSelectionUsingGranularity(newSelection, WordGranularity);
         }
 
-        if (appendTrailingWhitespace == ShouldAppendTrailingWhitespace && newSelection.isRange())
+        if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend && newSelection.isRange())
             newSelection.appendTrailingWhitespace();
 
         updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
     }
 }
 
 void SelectionController::selectClosestMisspellingFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
 {
     Node* innerNode = result.innerNode();
     VisibleSelection newSelection;
 
     if (innerNode && innerNode->layoutObject()) {
         VisiblePosition pos(innerNode->layoutObject()->positionForPoint(result.localPoint()));
         Position start = pos.deepEquivalent();
         Position end = pos.deepEquivalent();
         if (pos.isNotNull()) {
             DocumentMarkerVector markers = innerNode->document().markers().markersInRange(makeRange(pos, pos).get(), DocumentMarker::MisspellingMarkers());
             if (markers.size() == 1) {
                 start.moveToOffset(markers[0]->startOffset());
                 end.moveToOffset(markers[0]->endOffset());
                 newSelection = VisibleSelection(start, end);
             }
         }
 
-        if (appendTrailingWhitespace == ShouldAppendTrailingWhitespace && newSelection.isRange())
+        if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend && newSelection.isRange())
             newSelection.appendTrailingWhitespace();
 
         updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
     }
 }
 
 void SelectionController::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (m_mouseDownMayStartSelect) {
         selectClosestWordFromHitTestResult(result.hitTestResult(),
-            (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? ShouldAppendTrailingWhitespace : DontAppendTrailingWhitespace);
+            (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend);
     }
 }
 
 void SelectionController::selectClosestMisspellingFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (m_mouseDownMayStartSelect) {
         selectClosestMisspellingFromHitTestResult(result.hitTestResult(),
-            (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? ShouldAppendTrailingWhitespace : DontAppendTrailingWhitespace);
+            (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend);
     }
 }
 
 void SelectionController::selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (!result.hitTestResult().isLiveLink())
         return selectClosestWordFromMouseEvent(result);
 
     Node* innerNode = result.innerNode();
 
@@ skipping 14 matching lines @@
 
     if (event.event().button() != LeftButton)
         return false;
 
     if (m_frame->selection().isRange()) {
         // A double-click when range is already selected
         // should not change the selection.  So, do not call
         // selectClosestWordFromMouseEvent, but do set
         // m_beganSelectingText to prevent handleMouseReleaseEvent
         // from setting caret selection.
-        m_selectionInitiationState = ExtendedSelection;
+        m_selectionState = SelectionState::ExtendedSelection;
     } else {
         selectClosestWordFromMouseEvent(event);
     }
     return true;
 }
 
 bool SelectionController::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event)
 {
     TRACE_EVENT0("blink", "SelectionController::handleMousePressEventTripleClick");
 
@@ skipping 113 matching lines @@
 void SelectionController::handleMousePressEvent(const MouseEventWithHitTestResults& event)
 {
     // If we got the event back, that must mean it wasn't prevented,
     // so it's allowed to start a drag or selection if it wasn't in a scrollbar.
     m_mouseDownMayStartSelect = canMouseDownStartSelect(event.innerNode()) && !event.scrollbar();
     m_mouseDownWasSingleClickInSelection = false;
 }
 
 void SelectionController::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event, const IntPoint& mouseDownPos, const LayoutPoint& dragStartPos, Node* mousePressNode, const IntPoint& lastKnownMousePosition)
 {
-    if (m_selectionInitiationState != ExtendedSelection) {
+    if (m_selectionState != SelectionState::ExtendedSelection) {
         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active);
         HitTestResult result(request, mouseDownPos);
         m_frame->document()->layoutView()->hitTest(result);
 
         updateSelectionForMouseDrag(result, mousePressNode, dragStartPos, lastKnownMousePosition);
     }
     updateSelectionForMouseDrag(event.hitTestResult(), mousePressNode, dragStartPos, lastKnownMousePosition);
 }
 
 void SelectionController::updateSelectionForMouseDrag(Node* mousePressNode, const LayoutPoint& dragStartPos, const IntPoint& lastKnownMousePosition)
@@ skipping 44 matching lines @@
     // FIXME: Isn't there a better non-SVG-specific way to do this?
     if (Node* selectionBaseNode = Strategy::selectionBase(newSelection).deprecatedNode()) {
         if (LayoutObject* selectionBaseLayoutObject = selectionBaseNode->layoutObject()) {
             if (selectionBaseLayoutObject->isSVGText()) {
                 if (target->layoutObject()->containingBlock() != selectionBaseLayoutObject->containingBlock())
                     return;
             }
         }
     }
 
-    if (m_selectionInitiationState == HaveNotStartedSelection && !dispatchSelectStart(target))
+    if (m_selectionState == SelectionState::HaveNotStartedSelection && !dispatchSelectStart(target))
         return;
 
-    if (m_selectionInitiationState != ExtendedSelection) {
+    if (m_selectionState != SelectionState::ExtendedSelection) {
         // Always extend selection here because it's caused by a mouse drag
-        m_selectionInitiationState = ExtendedSelection;
+        m_selectionState = SelectionState::ExtendedSelection;
         newSelection = VisibleSelection(targetPosition);
     }
 
     if (RuntimeEnabledFeatures::userSelectAllEnabled()) {
         Node* rootUserSelectAllForMousePressNode = Position::rootUserSelectAllForNode(mousePressNode);
         if (rootUserSelectAllForMousePressNode && rootUserSelectAllForMousePressNode == Position::rootUserSelectAllForNode(target)) {
             newSelection.setBase(PositionType::beforeNode(rootUserSelectAllForMousePressNode).upstream(CanCrossEditingBoundary));
             newSelection.setExtent(PositionType::afterNode(rootUserSelectAllForMousePressNode).downstream(CanCrossEditingBoundary));
         } else {
             // Reset base for user select all when base is inside user-select-all area and extent < base.
@@ skipping 24 matching lines @@
 }
 
 bool SelectionController::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event, const LayoutPoint& dragStartPos)
 {
     bool handled = false;
     m_mouseDownMayStartSelect = false;
     // Clear the selection if the mouse didn't move after the last mouse
     // press and it's not a context menu click.  We do this so when clicking
     // on the selection, the selection goes away.  However, if we are
     // editing, place the caret.
-    if (m_mouseDownWasSingleClickInSelection && m_selectionInitiationState != ExtendedSelection
+    if (m_mouseDownWasSingleClickInSelection && m_selectionState != SelectionState::ExtendedSelection
         && dragStartPos == event.event().position()
         && m_frame->selection().isRange()
         && event.event().button() != RightButton) {
         VisibleSelection newSelection;
         Node* node = event.innerNode();
         bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
         if (node && node->layoutObject() && (caretBrowsing || node->hasEditableStyle())) {
             VisiblePosition pos = VisiblePosition(node->layoutObject()->positionForPoint(event.localPoint()));
             newSelection = VisibleSelection(pos);
         }
@@ skipping 56 matching lines @@
 #endif
     if (shouldLongPressSelectWord) {
 
 
         Node* innerNode = hitTestResult.innerNode();
         if (!hitTestResult.isLiveLink() && innerNode && (innerNode->isContentEditable() || innerNode->isTextNode()
 #if OS(ANDROID)
             || innerNode->canStartSelection()
 #endif
             )) {
-            selectClosestWordFromHitTestResult(hitTestResult, DontAppendTrailingWhitespace);
+            selectClosestWordFromHitTestResult(hitTestResult, AppendTrailingWhitespace::DontAppend);
             if (m_frame->selection().isRange())
                 return true;
         }
     }
     return false;
 }
 
 void SelectionController::sendContextMenuEvent(const MouseEventWithHitTestResults& mev, const LayoutPoint& position)
 {
     if (!m_frame->selection().contains(position)
@@ skipping 21 matching lines @@
     if (m_frame->selection().contains(p)) {
         VisiblePosition visiblePos(
             mev.innerNode()->layoutObject()->positionForPoint(mev.localPoint()));
         VisibleSelection newSelection(visiblePos);
         m_frame->selection().setSelection(newSelection);
     }
 }
 
 void SelectionController::initializeSelectionState()
 {
-    m_selectionInitiationState = HaveNotStartedSelection;
+    m_selectionState = SelectionState::HaveNotStartedSelection;
 }
 
 void SelectionController::setMouseDownMayStartSelect(bool mayStartSelect)
 {
     m_mouseDownMayStartSelect = mayStartSelect;
 }
 
 bool SelectionController::mouseDownMayStartSelect() const
 {
     return m_mouseDownMayStartSelect;
 }
 
 bool SelectionController::mouseDownWasSingleClickInSelection() const
 {
     return m_mouseDownWasSingleClickInSelection;
 }
 
 } // namespace blink