Changed TextDirection to an enum class and renamed its members

third_party/WebKit/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
@@ skipping 688 matching lines @@
     }
 
     if (!iter)
       break;
 
     iter->first();
     int offsetInIterator = offsetInBox - textBox->start() + previousBoxLength;
 
     bool isWordBreak;
     bool boxHasSameDirectionalityAsBlock = box->direction() == blockDirection;
-    bool movingBackward = (direction == MoveLeft && box->direction() == LTR) ||
-                          (direction == MoveRight && box->direction() == RTL);
+    bool movingBackward =
+        (direction == MoveLeft && box->direction() == TextDirection::Ltr) ||
+        (direction == MoveRight && box->direction() == TextDirection::Rtl);
     if ((skipsSpaceWhenMovingRight && boxHasSameDirectionalityAsBlock) ||
         (!skipsSpaceWhenMovingRight && movingBackward)) {
       bool logicalStartInLayoutObject =
           offsetInBox == static_cast<int>(textBox->start()) &&
           previousBoxInDifferentBlock;
       isWordBreak = isLogicalStartOfWord(iter, offsetInIterator,
                                          logicalStartInLayoutObject);
     } else {
       bool logicalEndInLayoutObject =
           offsetInBox == static_cast<int>(textBox->start() + textBox->len()) &&
@@ skipping 16 matching lines @@
   VisiblePosition leftWordBreak =
       visualWordPosition(visiblePosition, MoveLeft, skipsSpaceWhenMovingRight);
   leftWordBreak = honorEditingBoundaryAtOrBefore(
       leftWordBreak, visiblePosition.deepEquivalent());
 
   // FIXME: How should we handle a non-editable position?
   if (leftWordBreak.isNull() &&
       isEditablePosition(visiblePosition.deepEquivalent())) {
     TextDirection blockDirection =
         directionOfEnclosingBlock(visiblePosition.deepEquivalent());
-    leftWordBreak = blockDirection == LTR
+    leftWordBreak = blockDirection == TextDirection::Ltr
                         ? startOfEditableContent(visiblePosition)
                         : endOfEditableContent(visiblePosition);
   }
   return leftWordBreak;
 }
 
 VisiblePosition rightWordPosition(const VisiblePosition& visiblePosition,
                                   bool skipsSpaceWhenMovingRight) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   VisiblePosition rightWordBreak =
       visualWordPosition(visiblePosition, MoveRight, skipsSpaceWhenMovingRight);
   rightWordBreak = honorEditingBoundaryAtOrBefore(
       rightWordBreak, visiblePosition.deepEquivalent());
 
   // FIXME: How should we handle a non-editable position?
   if (rightWordBreak.isNull() &&
       isEditablePosition(visiblePosition.deepEquivalent())) {
     TextDirection blockDirection =
         directionOfEnclosingBlock(visiblePosition.deepEquivalent());
-    rightWordBreak = blockDirection == LTR
+    rightWordBreak = blockDirection == TextDirection::Ltr
                          ? endOfEditableContent(visiblePosition)
                          : startOfEditableContent(visiblePosition);
   }
   return rightWordBreak;
 }
 
 template <typename Strategy>
 static ContainerNode* nonShadowBoundaryParentNode(Node* node) {
   ContainerNode* parent = Strategy::parent(*node);
   return parent && !parent->isShadowRoot() ? parent : nullptr;
@@ skipping 1427 matching lines @@
   // of INPUT/TEXTAREA element, by |nextPosition().isNull()|, because of
   // an inner editor is an only leaf node.
   if (!nextPosition.deepEquivalent().isAfterAnchor())
     return false;
   return isTextControlElement(nextPosition.deepEquivalent().anchorNode());
 }
 
 VisiblePosition leftBoundaryOfLine(const VisiblePosition& c,
                                    TextDirection direction) {
   DCHECK(c.isValid()) << c;
-  return direction == LTR ? logicalStartOfLine(c) : logicalEndOfLine(c);
+  return direction == TextDirection::Ltr ? logicalStartOfLine(c)
+                                         : logicalEndOfLine(c);
 }
 
 VisiblePosition rightBoundaryOfLine(const VisiblePosition& c,
                                     TextDirection direction) {
   DCHECK(c.isValid()) << c;
-  return direction == LTR ? logicalEndOfLine(c) : logicalStartOfLine(c);
+  return direction == TextDirection::Ltr ? logicalEndOfLine(c)
+                                         : logicalStartOfLine(c);
 }
 
 static bool isNonTextLeafChild(LayoutObject* object) {
   if (object->slowFirstChild())
     return false;
   if (object->isText())
     return false;
   return true;
 }
 
@@ skipping 1093 matching lines @@
       mostForwardCaretPosition(p);
   TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
   const TextAffinity affinity = visiblePosition.affinity();
 
   while (true) {
     InlineBoxPosition boxPosition =
         computeInlineBoxPosition(p, affinity, primaryDirection);
     InlineBox* box = boxPosition.inlineBox;
     int offset = boxPosition.offsetInBox;
     if (!box)
-      return primaryDirection == LTR
+      return primaryDirection == TextDirection::Ltr
                  ? previousVisuallyDistinctCandidate(deepPosition)
                  : nextVisuallyDistinctCandidate(deepPosition);
 
     LineLayoutItem lineLayoutItem = box->getLineLayoutItem();
 
     while (true) {
       if ((lineLayoutItem.isAtomicInlineLevel() || lineLayoutItem.isBR()) &&
           offset == box->caretRightmostOffset())
         return box->isLeftToRightDirection()
                    ? previousVisuallyDistinctCandidate(deepPosition)
                    : nextVisuallyDistinctCandidate(deepPosition);
 
       if (!lineLayoutItem.node()) {
         box = box->prevLeafChild();
         if (!box)
-          return primaryDirection == LTR
+          return primaryDirection == TextDirection::Ltr
                      ? previousVisuallyDistinctCandidate(deepPosition)
                      : nextVisuallyDistinctCandidate(deepPosition);
         lineLayoutItem = box->getLineLayoutItem();
         offset = box->caretRightmostOffset();
         continue;
       }
 
       offset = box->isLeftToRightDirection()
                    ? previousGraphemeBoundaryOf(lineLayoutItem.node(), offset)
                    : nextGraphemeBoundaryOf(lineLayoutItem.node(), offset);
 
       int caretMinOffset = box->caretMinOffset();
       int caretMaxOffset = box->caretMaxOffset();
 
       if (offset > caretMinOffset && offset < caretMaxOffset)
         break;
 
       if (box->isLeftToRightDirection() ? offset < caretMinOffset
                                         : offset > caretMaxOffset) {
         // Overshot to the left.
         InlineBox* prevBox = box->prevLeafChildIgnoringLineBreak();
         if (!prevBox) {
           PositionTemplate<Strategy> positionOnLeft =
-              primaryDirection == LTR ? previousVisuallyDistinctCandidate(
-                                            visiblePosition.deepEquivalent())
-                                      : nextVisuallyDistinctCandidate(
-                                            visiblePosition.deepEquivalent());
+              primaryDirection == TextDirection::Ltr
+                  ? previousVisuallyDistinctCandidate(
+                        visiblePosition.deepEquivalent())
+                  : nextVisuallyDistinctCandidate(
+                        visiblePosition.deepEquivalent());
           if (positionOnLeft.isNull())
             return PositionTemplate<Strategy>();
 
           InlineBox* boxOnLeft = computeInlineBoxPosition(
                                      positionOnLeft, affinity, primaryDirection)
                                      .inlineBox;
           if (boxOnLeft && boxOnLeft->root() == box->root())
             return PositionTemplate<Strategy>();
           return positionOnLeft;
         }
 
         // Reposition at the other logical position corresponding to our
         // edge's visual position and go for another round.
         box = prevBox;
         lineLayoutItem = box->getLineLayoutItem();
         offset = prevBox->caretRightmostOffset();
         continue;
       }
 
       DCHECK_EQ(offset, box->caretLeftmostOffset());
 
       unsigned char level = box->bidiLevel();
       InlineBox* prevBox = box->prevLeafChild();
 
       if (box->direction() == primaryDirection) {
         if (!prevBox) {
           InlineBox* logicalStart = 0;
-          if (primaryDirection == LTR
+          if (primaryDirection == TextDirection::Ltr
                   ? box->root().getLogicalStartBoxWithNode(logicalStart)
                   : box->root().getLogicalEndBoxWithNode(logicalStart)) {
             box = logicalStart;
             lineLayoutItem = box->getLineLayoutItem();
-            offset = primaryDirection == LTR ? box->caretMinOffset()
-                                             : box->caretMaxOffset();
+            offset = primaryDirection == TextDirection::Ltr
+                         ? box->caretMinOffset()
+                         : box->caretMaxOffset();
           }
           break;
         }
         if (prevBox->bidiLevel() >= level)
           break;
 
         level = prevBox->bidiLevel();
 
         InlineBox* nextBox = box;
         do {
@@ skipping 41 matching lines @@
           while (InlineBox* prevBox = box->prevLeafChild()) {
             if (prevBox->bidiLevel() < level)
               break;
             box = prevBox;
           }
           if (box->bidiLevel() == level)
             break;
           level = box->bidiLevel();
         }
         lineLayoutItem = box->getLineLayoutItem();
-        offset = primaryDirection == LTR ? box->caretMinOffset()
-                                         : box->caretMaxOffset();
+        offset = primaryDirection == TextDirection::Ltr ? box->caretMinOffset()
+                                                        : box->caretMaxOffset();
       }
       break;
     }
 
     p = PositionTemplate<Strategy>::editingPositionOf(lineLayoutItem.node(),
                                                       offset);
 
     if ((isVisuallyEquivalentCandidate(p) &&
          mostForwardCaretPosition(p) != downstreamStart) ||
         p.atStartOfTree() || p.atEndOfTree())
       return p;
 
     DCHECK_NE(p, deepPosition);
   }
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> leftPositionOfAlgorithm(
     const VisiblePositionTemplate<Strategy>& visiblePosition) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   const PositionTemplate<Strategy> pos =
       leftVisuallyDistinctCandidate(visiblePosition);
   // TODO(yosin) Why can't we move left from the last position in a tree?
   if (pos.atStartOfTree() || pos.atEndOfTree())
     return VisiblePositionTemplate<Strategy>();
 
   const VisiblePositionTemplate<Strategy> left = createVisiblePosition(pos);
   DCHECK_NE(left.deepEquivalent(), visiblePosition.deepEquivalent());
 
-  return directionOfEnclosingBlock(left.deepEquivalent()) == LTR
+  return directionOfEnclosingBlock(left.deepEquivalent()) == TextDirection::Ltr
              ? honorEditingBoundaryAtOrBefore(left,
                                               visiblePosition.deepEquivalent())
              : honorEditingBoundaryAtOrAfter(left,
                                              visiblePosition.deepEquivalent());
 }
 
 VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition) {
   return leftPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
@@ skipping 16 matching lines @@
       mostForwardCaretPosition(p);
   TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
   const TextAffinity affinity = visiblePosition.affinity();
 
   while (true) {
     InlineBoxPosition boxPosition =
         computeInlineBoxPosition(p, affinity, primaryDirection);
     InlineBox* box = boxPosition.inlineBox;
     int offset = boxPosition.offsetInBox;
     if (!box)
-      return primaryDirection == LTR
+      return primaryDirection == TextDirection::Ltr
                  ? nextVisuallyDistinctCandidate(deepPosition)
                  : previousVisuallyDistinctCandidate(deepPosition);
 
     LayoutObject* layoutObject =
         LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
 
     while (true) {
       if ((layoutObject->isAtomicInlineLevel() || layoutObject->isBR()) &&
           offset == box->caretLeftmostOffset())
         return box->isLeftToRightDirection()
                    ? nextVisuallyDistinctCandidate(deepPosition)
                    : previousVisuallyDistinctCandidate(deepPosition);
 
       if (!layoutObject->node()) {
         box = box->nextLeafChild();
         if (!box)
-          return primaryDirection == LTR
+          return primaryDirection == TextDirection::Ltr
                      ? nextVisuallyDistinctCandidate(deepPosition)
                      : previousVisuallyDistinctCandidate(deepPosition);
         layoutObject =
             LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
         offset = box->caretLeftmostOffset();
         continue;
       }
 
       offset = box->isLeftToRightDirection()
                    ? nextGraphemeBoundaryOf(layoutObject->node(), offset)
                    : previousGraphemeBoundaryOf(layoutObject->node(), offset);
 
       int caretMinOffset = box->caretMinOffset();
       int caretMaxOffset = box->caretMaxOffset();
 
       if (offset > caretMinOffset && offset < caretMaxOffset)
         break;
 
       if (box->isLeftToRightDirection() ? offset > caretMaxOffset
                                         : offset < caretMinOffset) {
         // Overshot to the right.
         InlineBox* nextBox = box->nextLeafChildIgnoringLineBreak();
         if (!nextBox) {
           PositionTemplate<Strategy> positionOnRight =
-              primaryDirection == LTR
+              primaryDirection == TextDirection::Ltr
                   ? nextVisuallyDistinctCandidate(deepPosition)
                   : previousVisuallyDistinctCandidate(deepPosition);
           if (positionOnRight.isNull())
             return PositionTemplate<Strategy>();
 
           InlineBox* boxOnRight =
               computeInlineBoxPosition(positionOnRight, affinity,
                                        primaryDirection)
                   .inlineBox;
           if (boxOnRight && boxOnRight->root() == box->root())
@@ skipping 11 matching lines @@
       }
 
       DCHECK_EQ(offset, box->caretRightmostOffset());
 
       unsigned char level = box->bidiLevel();
       InlineBox* nextBox = box->nextLeafChild();
 
       if (box->direction() == primaryDirection) {
         if (!nextBox) {
           InlineBox* logicalEnd = 0;
-          if (primaryDirection == LTR
+          if (primaryDirection == TextDirection::Ltr
                   ? box->root().getLogicalEndBoxWithNode(logicalEnd)
                   : box->root().getLogicalStartBoxWithNode(logicalEnd)) {
             box = logicalEnd;
             layoutObject =
                 LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
-            offset = primaryDirection == LTR ? box->caretMaxOffset()
-                                             : box->caretMinOffset();
+            offset = primaryDirection == TextDirection::Ltr
+                         ? box->caretMaxOffset()
+                         : box->caretMinOffset();
           }
           break;
         }
 
         if (nextBox->bidiLevel() >= level)
           break;
 
         level = nextBox->bidiLevel();
 
         InlineBox* prevBox = box;
@@ skipping 48 matching lines @@
             if (nextBox->bidiLevel() < level)
               break;
             box = nextBox;
           }
           if (box->bidiLevel() == level)
             break;
           level = box->bidiLevel();
         }
         layoutObject =
             LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
-        offset = primaryDirection == LTR ? box->caretMaxOffset()
-                                         : box->caretMinOffset();
+        offset = primaryDirection == TextDirection::Ltr ? box->caretMaxOffset()
+                                                        : box->caretMinOffset();
       }
       break;
     }
 
     p = PositionTemplate<Strategy>::editingPositionOf(layoutObject->node(),
                                                       offset);
 
     if ((isVisuallyEquivalentCandidate(p) &&
          mostForwardCaretPosition(p) != downstreamStart) ||
         p.atStartOfTree() || p.atEndOfTree())
       return p;
 
     DCHECK_NE(p, deepPosition);
   }
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> rightPositionOfAlgorithm(
     const VisiblePositionTemplate<Strategy>& visiblePosition) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   const PositionTemplate<Strategy> pos =
       rightVisuallyDistinctCandidate(visiblePosition);
   // FIXME: Why can't we move left from the last position in a tree?
   if (pos.atStartOfTree() || pos.atEndOfTree())
     return VisiblePositionTemplate<Strategy>();
 
   const VisiblePositionTemplate<Strategy> right = createVisiblePosition(pos);
   DCHECK_NE(right.deepEquivalent(), visiblePosition.deepEquivalent());
 
-  return directionOfEnclosingBlock(right.deepEquivalent()) == LTR
+  return directionOfEnclosingBlock(right.deepEquivalent()) == TextDirection::Ltr
              ? honorEditingBoundaryAtOrAfter(right,
                                              visiblePosition.deepEquivalent())
              : honorEditingBoundaryAtOrBefore(right,
                                               visiblePosition.deepEquivalent());
 }
 
 VisiblePosition rightPositionOf(const VisiblePosition& visiblePosition) {
   return rightPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
@@ skipping 108 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink