Changed TextDirection to an enum class and renamed its members

third_party/WebKit/Source/core/editing/SelectionModifier.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 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 82 matching lines @@
     // selection. This only matters for cases where base and extend point to
     // different positions than start and end (e.g. after a double-click to
     // select a word).
     if (m_selection.isBaseFirst())
       baseIsStart = true;
     else
       baseIsStart = false;
   } else {
     switch (direction) {
       case DirectionRight:
-        if (directionOfSelection() == LTR)
+        if (directionOfSelection() == TextDirection::Ltr)
           baseIsStart = true;
         else
           baseIsStart = false;
         break;
       case DirectionForward:
         baseIsStart = true;
         break;
       case DirectionLeft:
-        if (directionOfSelection() == LTR)
+        if (directionOfSelection() == TextDirection::Ltr)
           baseIsStart = false;
         else
           baseIsStart = true;
         break;
       case DirectionBackward:
         baseIsStart = false;
         break;
     }
   }
   if (baseIsStart) {
@@ skipping 72 matching lines @@
       createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
   // The difference between modifyExtendingRight and modifyExtendingForward is:
   // modifyExtendingForward always extends forward logically.
   // modifyExtendingRight behaves the same as modifyExtendingForward except for
   // extending character or word, it extends forward logically if the enclosing
   // block is LTR direction, but it extends backward logically if the enclosing
   // block is RTL direction.
   switch (granularity) {
     case CharacterGranularity:
-      if (directionOfEnclosingBlock() == LTR)
+      if (directionOfEnclosingBlock() == TextDirection::Ltr)
         pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
       else
         pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
       break;
     case WordGranularity:
-      if (directionOfEnclosingBlock() == LTR)
+      if (directionOfEnclosingBlock() == TextDirection::Ltr)
         pos = nextWordPositionForPlatform(pos);
       else
         pos = previousWordPosition(pos);
       break;
     case LineBoundary:
-      if (directionOfEnclosingBlock() == LTR)
+      if (directionOfEnclosingBlock() == TextDirection::Ltr)
         pos = modifyExtendingForward(granularity);
       else
         pos = modifyExtendingBackward(granularity);
       break;
     case SentenceGranularity:
     case LineGranularity:
     case ParagraphGranularity:
     case SentenceBoundary:
     case ParagraphBoundary:
     case DocumentBoundary:
       // FIXME: implement all of the above?
       pos = modifyExtendingForward(granularity);
       break;
   }
-  adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR);
+  adjustPositionForUserSelectAll(
+      pos, directionOfEnclosingBlock() == TextDirection::Ltr);
   return pos;
 }
 
 VisiblePosition SelectionModifier::modifyExtendingForward(
     TextGranularity granularity) {
   VisiblePosition pos =
       createVisiblePosition(m_selection.extent(), m_selection.affinity());
   switch (granularity) {
     case CharacterGranularity:
       pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
@@ skipping 22 matching lines @@
       pos = endOfParagraph(endForPlatform());
       break;
     case DocumentBoundary:
       pos = endForPlatform();
       if (isEditablePosition(pos.deepEquivalent()))
         pos = endOfEditableContent(pos);
       else
         pos = endOfDocument(pos);
       break;
   }
-  adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR);
+  adjustPositionForUserSelectAll(
+      pos, directionOfEnclosingBlock() == TextDirection::Ltr);
   return pos;
 }
 
 VisiblePosition SelectionModifier::modifyMovingRight(
     TextGranularity granularity) {
   VisiblePosition pos;
   switch (granularity) {
     case CharacterGranularity:
       if (m_selection.isRange()) {
-        if (directionOfSelection() == LTR)
+        if (directionOfSelection() == TextDirection::Ltr)
           pos =
               createVisiblePosition(m_selection.end(), m_selection.affinity());
         else
           pos = createVisiblePosition(m_selection.start(),
                                       m_selection.affinity());
       } else {
         pos = rightPositionOf(createVisiblePosition(m_selection.extent(),
                                                     m_selection.affinity()));
       }
       break;
@@ skipping 85 matching lines @@
       createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
   // The difference between modifyExtendingLeft and modifyExtendingBackward is:
   // modifyExtendingBackward always extends backward logically.
   // modifyExtendingLeft behaves the same as modifyExtendingBackward except for
   // extending character or word, it extends backward logically if the enclosing
   // block is LTR direction, but it extends forward logically if the enclosing
   // block is RTL direction.
   switch (granularity) {
     case CharacterGranularity:
-      if (directionOfEnclosingBlock() == LTR)
+      if (directionOfEnclosingBlock() == TextDirection::Ltr)
         pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
       else
         pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
       break;
     case WordGranularity:
-      if (directionOfEnclosingBlock() == LTR)
+      if (directionOfEnclosingBlock() == TextDirection::Ltr)
         pos = previousWordPosition(pos);
       else
         pos = nextWordPositionForPlatform(pos);
       break;
     case LineBoundary:
-      if (directionOfEnclosingBlock() == LTR)
+      if (directionOfEnclosingBlock() == TextDirection::Ltr)
         pos = modifyExtendingBackward(granularity);
       else
         pos = modifyExtendingForward(granularity);
       break;
     case SentenceGranularity:
     case LineGranularity:
     case ParagraphGranularity:
     case SentenceBoundary:
     case ParagraphBoundary:
     case DocumentBoundary:
       pos = modifyExtendingBackward(granularity);
       break;
   }
-  adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR));
+  adjustPositionForUserSelectAll(
+      pos, !(directionOfEnclosingBlock() == TextDirection::Ltr));
   return pos;
 }
 
 VisiblePosition SelectionModifier::modifyExtendingBackward(
     TextGranularity granularity) {
   VisiblePosition pos =
       createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
   // Extending a selection backward by word or character from just after a table
   // selects the table.  This "makes sense" from the user perspective, esp. when
@@ skipping 27 matching lines @@
       pos = startOfParagraph(startForPlatform());
       break;
     case DocumentBoundary:
       pos = startForPlatform();
       if (isEditablePosition(pos.deepEquivalent()))
         pos = startOfEditableContent(pos);
       else
         pos = startOfDocument(pos);
       break;
   }
-  adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR));
+  adjustPositionForUserSelectAll(
+      pos, !(directionOfEnclosingBlock() == TextDirection::Ltr));
   return pos;
 }
 
 VisiblePosition SelectionModifier::modifyMovingLeft(
     TextGranularity granularity) {
   VisiblePosition pos;
   switch (granularity) {
     case CharacterGranularity:
       if (m_selection.isRange()) {
-        if (directionOfSelection() == LTR)
+        if (directionOfSelection() == TextDirection::Ltr)
           pos = createVisiblePosition(m_selection.start(),
                                       m_selection.affinity());
         else
           pos =
               createVisiblePosition(m_selection.end(), m_selection.affinity());
       } else {
         pos = leftPositionOf(createVisiblePosition(m_selection.extent(),
                                                    m_selection.affinity()));
       }
       break;
@@ skipping 188 matching lines @@
       if (!frame() ||
           !frame()
                ->editor()
                .behavior()
                .shouldAlwaysGrowSelectionWhenExtendingToBoundary() ||
           m_selection.isCaret() || !isBoundary(granularity)) {
         m_selection.setExtent(position);
       } else {
         TextDirection textDirection = directionOfEnclosingBlock();
         if (direction == DirectionForward ||
-            (textDirection == LTR && direction == DirectionRight) ||
-            (textDirection == RTL && direction == DirectionLeft))
+            (textDirection == TextDirection::Ltr &&
+             direction == DirectionRight) ||
+            (textDirection == TextDirection::Rtl && direction == DirectionLeft))
           setSelectionEnd(&m_selection, position);
         else
           setSelectionStart(&m_selection, position);
       }
       break;
   }
 
   if (granularity == LineGranularity || granularity == ParagraphGranularity)
     m_xPosForVerticalArrowNavigation = x;
 
@@ skipping 166 matching lines @@
 
   return x;
 }
 
 DEFINE_TRACE(SelectionModifier) {
   visitor->trace(m_frame);
   visitor->trace(m_selection);
 }
 
 }  // namespace blink