ALL-IN-ONE Introduce enum class TextAffinity

Source/core/editing/VisibleSelection.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 24 matching lines @@
 #include "core/layout/LayoutObject.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "wtf/Assertions.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/CharacterNames.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 VisibleSelection::VisibleSelection()
-    : m_affinity(DOWNSTREAM)
+    : m_affinity(TextAffinity::Downstream)
     , m_changeObserver(nullptr)
     , m_selectionType(NoSelection)
     , m_baseIsFirst(true)
     , m_isDirectional(false)
 {
 }
 
-VisibleSelection::VisibleSelection(const Position& pos, EAffinity affinity, bool isDirectional)
+VisibleSelection::VisibleSelection(const Position& pos, TextAffinity affinity, bool isDirectional)
     : VisibleSelection(pos, pos, affinity, isDirectional)
 {
 }
 
-VisibleSelection::VisibleSelection(const Position& base, const Position& extent, EAffinity affinity, bool isDirectional)
+VisibleSelection::VisibleSelection(const Position& base, const Position& extent, TextAffinity affinity, bool isDirectional)
     : m_base(base)
     , m_extent(extent)
     , m_affinity(affinity)
     , m_changeObserver(nullptr)
     , m_isDirectional(isDirectional)
 {
     validate();
 }
 
-VisibleSelection::VisibleSelection(const PositionInComposedTree& base, const PositionInComposedTree& extent, EAffinity affinity, bool isDirectional)
+VisibleSelection::VisibleSelection(const PositionInComposedTree& base, const PositionInComposedTree& extent, TextAffinity affinity, bool isDirectional)
     : VisibleSelection(toPositionInDOMTree(base), toPositionInDOMTree(extent), affinity, isDirectional)
 {
 }
 
 VisibleSelection::VisibleSelection(const VisiblePosition& pos, bool isDirectional)
     : VisibleSelection(pos, pos, isDirectional)
 {
 }
 
 VisibleSelection::VisibleSelection(const VisiblePosition& base, const VisiblePosition& extent, bool isDirectional)
     : VisibleSelection(base.deepEquivalent(), extent.deepEquivalent(), base.affinity(), isDirectional)
 {
 }
 
-VisibleSelection::VisibleSelection(const EphemeralRange& range, EAffinity affinity, bool isDirectional)
+VisibleSelection::VisibleSelection(const EphemeralRange& range, TextAffinity affinity, bool isDirectional)
     : VisibleSelection(range.startPosition(), range.endPosition(), affinity, isDirectional)
 {
 }
 
-VisibleSelection::VisibleSelection(const Range* range, EAffinity affinity, bool isDirectional)
+VisibleSelection::VisibleSelection(const Range* range, TextAffinity affinity, bool isDirectional)
     : VisibleSelection(range->startPosition(), range->endPosition(), affinity, isDirectional)
 {
 }
 
 VisibleSelection::VisibleSelection(const VisibleSelection& other)
     : m_base(other.m_base)
     , m_extent(other.m_extent)
     , m_start(other.m_start)
     , m_end(other.m_end)
     , m_baseInComposedTree(other.m_baseInComposedTree)
@@ skipping 497 matching lines @@
         return CaretSelection;
     return RangeSelection;
 }
 
 void VisibleSelection::updateSelectionType()
 {
     m_selectionType = selectionType(m_start, m_end);
 
     // Affinity only makes sense for a caret
     if (m_selectionType != CaretSelection)
-        m_affinity = DOWNSTREAM;
+        m_affinity = TextAffinity::Downstream;
 }
 
 static Node* enclosingShadowHost(Node* node)
 {
     for (Node* runner = node; runner; runner = ComposedTreeTraversal::parent(*runner)) {
         if (isShadowHost(runner))
             return runner;
     }
     return nullptr;
 }
@@ skipping 139 matching lines @@
 // invalid, will be valid once the changes are undone. This is a design problem.
 // To fix it we either need to change the invariants of VisibleSelection or create a new
 // class for editing to use that can manipulate selections that are not currently valid.
 void VisibleSelection::setWithoutValidation(const Position& base, const Position& extent)
 {
     ASSERT(!base.isNull());
     ASSERT(!extent.isNull());
 
     // TODO(hajimehoshi): We doubt this assertion is needed. This was introduced
     // by http://trac.webkit.org/browser/trunk/WebCore/editing/Selection.cpp?annotate=blame&rev=21071
-    ASSERT(m_affinity == DOWNSTREAM);
+    ASSERT(m_affinity == TextAffinity::Downstream);
 
     m_base = base;
     m_extent = extent;
     m_baseInComposedTree = toPositionInComposedTree(base);
     m_extentInComposedTree = toPositionInComposedTree(extent);
     m_baseIsFirst = comparePositions(base, extent) <= 0;
     if (m_baseIsFirst) {
         m_start = base;
         m_end = extent;
     } else {
@@ skipping 421 matching lines @@
         endInComposedTree().debugPosition("endInComposedTree: ");
         extentInComposedTree().debugPosition("extentInComposedTree: ");
     } else {
         startInComposedTree().debugPosition("startInComposedTree: ");
         extentInComposedTree().debugPosition("extentInComposedTree: ");
         endInComposedTree().debugPosition("endInComposedTree: ");
         baseInComposedTree().debugPosition("baseInComposedTree: ");
     }
 
     fprintf(stderr, "isDirectional=%s\n", isDirectional() ? "true" : "false");
-    fprintf(stderr, "affinity=%s\n", affinity() == DOWNSTREAM ? "DOWNSTREaM" : affinity() == UPSTREAM ? "UPSTREAM" : "UNKNOWN");
+    fprintf(stderr, "affinity=%s\n", affinity() == TextAffinity::Downstream ? "DOWNSTREaM" : affinity() == TextAffinity::Upstream ? "UPSTREAM" : "UNKNOWN");
     fprintf(stderr, "================================\n");
 }
 
 void VisibleSelection::formatForDebugger(char* buffer, unsigned length) const
 {
     StringBuilder result;
     String s;
 
     if (isNone()) {
         result.appendLiteral("<none>");
@@ skipping 33 matching lines @@
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 
 #endif