ALL-IN-ONE Introduce enum class TextAffinity

Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 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 19 matching lines @@
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/Position.h"
 #include "core/editing/RenderedPosition.h"
+#include "core/editing/TextAffinity.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/iterators/BackwardsCharacterIterator.h"
 #include "core/editing/iterators/CharacterIterator.h"
 #include "core/editing/iterators/SimplifiedBackwardsTextIterator.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutObject.h"
@@ skipping 178 matching lines @@
 
     while (1) {
         Node* startNode = startBox->layoutObject().nonPseudoNode();
         if (!startNode)
             break;
 
         Position position = previousRootInlineBoxCandidatePosition(startNode, visiblePosition, ContentIsEditable);
         if (position.isNull())
             break;
 
-        RenderedPosition renderedPosition(position, DOWNSTREAM);
+        RenderedPosition renderedPosition(position, TextAffinity::Downstream);
         RootInlineBox* previousRoot = renderedPosition.rootBox();
         if (!previousRoot)
             break;
 
         previousBox = leafBoxes.previousTextBox(previousRoot, 0);
         if (previousBox) {
             previousBoxInDifferentBlock = true;
             return previousBox;
         }
 
@@ skipping 20 matching lines @@
 
     while (1) {
         Node* startNode =startBox->layoutObject().nonPseudoNode();
         if (!startNode)
             break;
 
         Position position = nextRootInlineBoxCandidatePosition(startNode, visiblePosition, ContentIsEditable);
         if (position.isNull())
             break;
 
-        RenderedPosition renderedPosition(position, DOWNSTREAM);
+        RenderedPosition renderedPosition(position, TextAffinity::Downstream);
         RootInlineBox* nextRoot = renderedPosition.rootBox();
         if (!nextRoot)
             break;
 
         nextBox = leafBoxes.nextTextBox(nextRoot, 0);
         if (nextBox) {
             nextBoxInDifferentBlock = true;
             return nextBox;
         }
 
@@ skipping 76 matching lines @@
     TextBreakIterator* iter = 0;
 
     CachedLogicallyOrderedLeafBoxes leafBoxes;
     Vector<UChar, 1024> string;
 
     while (1) {
         VisiblePosition adjacentCharacterPosition = direction == MoveRight ? current.right() : current.left();
         if (adjacentCharacterPosition.deepEquivalent() == current.deepEquivalent() || adjacentCharacterPosition.isNull())
             return VisiblePosition();
 
-        InlineBoxPosition boxPosition = adjacentCharacterPosition.deepEquivalent().computeInlineBoxPosition(UPSTREAM);
+        InlineBoxPosition boxPosition = adjacentCharacterPosition.deepEquivalent().computeInlineBoxPosition(TextAffinity::Upstream);
         InlineBox* box = boxPosition.inlineBox;
         int offsetInBox = boxPosition.offsetInBox;
 
         if (!box)
             break;
         if (!box->isInlineTextBox()) {
             current = adjacentCharacterPosition;
             continue;
         }
 
@@ skipping 218 matching lines @@
         if (charIt.characterAt(0) == '\n') {
             // FIXME: workaround for collapsed range (where only start position is correct) emitted for some emitted newlines (see rdar://5192593)
             VisiblePosition visPos = VisiblePosition(pos);
             if (visPos.deepEquivalent() == VisiblePosition(charIt.startPosition()).deepEquivalent()) {
                 charIt.advance(1);
                 pos = charIt.startPosition();
             }
         }
     }
 
-    // generate VisiblePosition, use UPSTREAM affinity if possible
+    // generate VisiblePosition, use TextAffinity::Upstream affinity if possible
     return VisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // ---------
 
 static unsigned startWordBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     ASSERT(offset);
     if (mayHaveMoreContext && !startOfLastWordBoundaryContext(characters, offset)) {
         needMoreContext = true;
@@ skipping 936 matching lines @@
 
     if (position2.anchorNode()->isTextNode() && !position2.inRenderedText())
         return false;
 
     const int renderedOffset1 = renderedOffsetOf(position1);
     const int renderedOffset2 = renderedOffsetOf(position2);
 
     if (layoutObject == posLayoutObject && renderedOffset1 == renderedOffset2)
         return false;
 
-    InlineBoxPosition boxPosition1 = position1.computeInlineBoxPosition(DOWNSTREAM);
-    InlineBoxPosition boxPosition2 = position2.computeInlineBoxPosition(DOWNSTREAM);
+    InlineBoxPosition boxPosition1 = position1.computeInlineBoxPosition(TextAffinity::Downstream);
+    InlineBoxPosition boxPosition2 = position2.computeInlineBoxPosition(TextAffinity::Downstream);
 
     WTF_LOG(Editing, "layoutObject1:   %p [%p]\n", layoutObject, boxPosition1.inlineBox);
     WTF_LOG(Editing, "renderedOffset1: %d\n", renderedOffset1);
     WTF_LOG(Editing, "layoutObject2:   %p [%p]\n", posLayoutObject, boxPosition2.inlineBox);
     WTF_LOG(Editing, "renderedOffset2: %d\n", renderedOffset2);
     WTF_LOG(Editing, "node1 min/max:   %d:%d\n", caretMinOffset(position1.anchorNode()), caretMaxOffset(position1.anchorNode()));
     WTF_LOG(Editing, "node2 min/max:   %d:%d\n", caretMinOffset(position2.anchorNode()), caretMaxOffset(position2.anchorNode()));
     WTF_LOG(Editing, "----------------------------------------------------------------------\n");
 
     if (!boxPosition1.inlineBox || !boxPosition2.inlineBox) {
@@ skipping 11 matching lines @@
 
     if (previousRenderedEditable(position1.anchorNode()) == position2.anchorNode()
         && !renderedOffset1 && renderedOffset2 == caretMaxOffset(position2.anchorNode())) {
         return false;
     }
 
     return true;
 }
 
 }