ALL-IN-ONE Introduce enum class TextAffinity

Source/core/editing/Position.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2009 Apple 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 14 matching lines @@
 
 #include "config.h"
 #include "core/editing/Position.h"
 
 #include "core/HTMLNames.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
 #include "core/dom/Text.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/PositionIterator.h"
+#include "core/editing/TextAffinity.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLTableElement.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutText.h"
 #include "core/layout/line/InlineIterator.h"
@@ skipping 895 matching lines @@
         return false;
 
     LayoutObject* layoutObject = position.anchorNode()->layoutObject();
     if (!layoutObject)
         return false;
 
     return toLayoutText(layoutObject)->isRenderedCharacter(position.offsetInContainerNode());
 }
 
 template <typename Strategy>
-InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(EAffinity affinity) const
+InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(TextAffinity affinity) const
 {
     return computeInlineBoxPosition(affinity, primaryDirectionOf(*anchorNode()));
 }
 
 static bool isNonTextLeafChild(LayoutObject* object)
 {
     if (object->slowFirstChild())
         return false;
     if (object->isText())
         return false;
@@ skipping 43 matching lines @@
 {
     PositionAlgorithm<Strategy> lastPosition;
     while (position != lastPosition) {
         lastPosition = position;
         position = position.upstream(CanCrossEditingBoundary);
     }
     return position;
 }
 
 template <typename Strategy>
-InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(EAffinity affinity, TextDirection primaryDirection) const
+InlineBoxPosition PositionAlgorithm<Strategy>::computeInlineBoxPosition(TextAffinity affinity, TextDirection primaryDirection) const
 {
     InlineBox* inlineBox = nullptr;
     int caretOffset = computeEditingOffset();
     LayoutObject* layoutObject = m_anchorNode->isShadowRoot() ? toShadowRoot(m_anchorNode)->host()->layoutObject() : m_anchorNode->layoutObject();
 
     if (!layoutObject->isText()) {
         inlineBox = 0;
         if (canHaveChildrenForEditing(anchorNode()) && layoutObject->isLayoutBlockFlow() && hasRenderedNonAnonymousDescendantsWithHeight(layoutObject)) {
             // Try a visually equivalent position with possibly opposite
             // editability. This helps in case |this| is in an editable block
             // but surrounded by non-editable positions. It acts to negate the
             // logic at the beginning of LayoutObject::createVisiblePosition().
             PositionAlgorithm<Strategy> thisPosition = PositionAlgorithm<Strategy>(*this);
             PositionAlgorithm<Strategy> equivalent = downstreamIgnoringEditingBoundaries(thisPosition);
             if (equivalent == thisPosition) {
                 equivalent = upstreamIgnoringEditingBoundaries(thisPosition);
                 if (equivalent == thisPosition || downstreamIgnoringEditingBoundaries(equivalent) == thisPosition)
                     return InlineBoxPosition(inlineBox, caretOffset);
             }
 
-            return equivalent.computeInlineBoxPosition(UPSTREAM, primaryDirection);
+            return equivalent.computeInlineBoxPosition(TextAffinity::Upstream, primaryDirection);
         }
         if (layoutObject->isBox()) {
             inlineBox = toLayoutBox(layoutObject)->inlineBoxWrapper();
             if (!inlineBox || (caretOffset > inlineBox->caretMinOffset() && caretOffset < inlineBox->caretMaxOffset()))
                 return InlineBoxPosition(inlineBox, caretOffset);
         }
     } else {
         LayoutText* textLayoutObject = toLayoutText(layoutObject);
 
         InlineTextBox* box;
         InlineTextBox* candidate = 0;
 
         for (box = textLayoutObject->firstTextBox(); box; box = box->nextTextBox()) {
             int caretMinOffset = box->caretMinOffset();
             int caretMaxOffset = box->caretMaxOffset();
 
             if (caretOffset < caretMinOffset || caretOffset > caretMaxOffset || (caretOffset == caretMaxOffset && box->isLineBreak()))
                 continue;
 
             if (caretOffset > caretMinOffset && caretOffset < caretMaxOffset)
                 return InlineBoxPosition(box, caretOffset);
 
-            if (((caretOffset == caretMaxOffset) ^ (affinity == DOWNSTREAM))
-                || ((caretOffset == caretMinOffset) ^ (affinity == UPSTREAM))
+            if (((caretOffset == caretMaxOffset) ^ (affinity == TextAffinity::Downstream))
+                || ((caretOffset == caretMinOffset) ^ (affinity == TextAffinity::Upstream))
                 || (caretOffset == caretMaxOffset && box->nextLeafChild() && box->nextLeafChild()->isLineBreak()))
                 break;
 
             candidate = box;
         }
-        if (candidate && candidate == textLayoutObject->lastTextBox() && affinity == DOWNSTREAM) {
+        if (candidate && candidate == textLayoutObject->lastTextBox() && affinity == TextAffinity::Downstream) {
             box = searchAheadForBetterMatch(textLayoutObject);
             if (box)
                 caretOffset = box->caretMinOffset();
         }
         inlineBox = box ? box : candidate;
     }
 
     if (!inlineBox)
         return InlineBoxPosition(inlineBox, caretOffset);
 
@@ skipping 276 matching lines @@
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif