Utilize InlineBoxTraversal in {Left,Right}PositionOf() left/right traversal

third_party/WebKit/Source/core/editing/SelectionModifierCharacter.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 13 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/editing/SelectionModifier.h"
 
 #include "core/editing/EditingUtilities.h"
+#include "core/editing/InlineBoxTraversal.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/api/LineLayoutItem.h"
 #include "core/layout/line/InlineTextBox.h"
 #include "core/layout/line/RootInlineBox.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 13 matching lines @@
   static int CaretMinOffsetOf(TextDirection direction, const InlineBox& box) {
     if (direction == TextDirection::kLtr)
       return box.CaretMinOffset();
     return box.CaretMaxOffset();
   }
 
   static int CaretStartOffsetOf(const InlineBox& box) {
     return box.CaretLeftmostOffset();
   }
 
+  static InlineBox* FindBackwardBoundaryOfEntireBidiRun(const InlineBox& box,
+                                                        unsigned bidi_level) {
+    return InlineBoxTraversal::FindRightBoundaryOfEntireBidiRun(box,
+                                                                bidi_level);
+  }
+
+  static InlineBox* FindForwardBoundaryOfEntireBidiRun(const InlineBox& box,
+                                                       unsigned bidi_level) {
+    return InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRun(box, bidi_level);
+  }
+
   static int ForwardGraphemeBoundaryOf(TextDirection direction,
                                        Node* node,
                                        int offset) {
     if (direction == TextDirection::kLtr)
       return PreviousGraphemeBoundaryOf(node, offset);
     return NextGraphemeBoundaryOf(node, offset);
   }
 
   static InlineBox* ForwardLeafChildOf(const InlineBox& box) {
     return box.PrevLeafChild();
@@ skipping 51 matching lines @@
   static int CaretMinOffsetOf(TextDirection direction, const InlineBox& box) {
     if (direction == TextDirection::kLtr)
       return box.CaretMaxOffset();
     return box.CaretMinOffset();
   }
 
   static int CaretStartOffsetOf(const InlineBox& box) {
     return box.CaretRightmostOffset();
   }
 
+  static InlineBox* FindBackwardBoundaryOfEntireBidiRun(const InlineBox& box,
+                                                        unsigned bidi_level) {
+    return InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRun(box, bidi_level);
+  }
+
+  static InlineBox* FindForwardBoundaryOfEntireBidiRun(const InlineBox& box,
+                                                       unsigned bidi_level) {
+    return InlineBoxTraversal::FindRightBoundaryOfEntireBidiRun(box,
+                                                                bidi_level);
+  }
+
   static int ForwardGraphemeBoundaryOf(TextDirection direction,
                                        Node* node,
                                        int offset) {
     if (direction == TextDirection::kLtr)
       return NextGraphemeBoundaryOf(node, offset);
     return PreviousGraphemeBoundaryOf(node, offset);
   }
 
   static InlineBox* ForwardLeafChildOf(const InlineBox& box) {
     return box.NextLeafChild();
@@ skipping 168 matching lines @@
             prev_box = Traversal::ForwardLeafChildOf(*prev_box);
           } while (prev_box && prev_box->BidiLevel() > level);
 
           if (!prev_box || prev_box->BidiLevel() < level)
             continue;
         }
       } else {
         // Trailing edge of a secondary run. Set to the leading edge of
         // the entire run.
         while (true) {
-          while (InlineBox* next_box = Traversal::BackwardLeafChildOf(*box)) {
-            if (next_box->BidiLevel() < level)
-              break;
-            box = next_box;
-          }
+          box = Traversal::FindBackwardBoundaryOfEntireBidiRun(*box, level);
           if (box->BidiLevel() == level)
             break;
           level = box->BidiLevel();
-          while (InlineBox* prev_box = Traversal::ForwardLeafChildOf(*box)) {
-            if (prev_box->BidiLevel() < level)
-              break;
-            box = prev_box;
-          }
+          box = Traversal::FindForwardBoundaryOfEntireBidiRun(*box, level);
           if (box->BidiLevel() == level)
             break;
           level = box->BidiLevel();
         }
         line_layout_item = box->GetLineLayoutItem();
         offset = Traversal::CaretMinOffsetOf(primary_direction, *box);
       }
       break;
     }
 
@@ skipping 47 matching lines @@
 }
 
 VisiblePositionInFlatTree RightPositionOf(
     const VisiblePositionInFlatTree& visible_position) {
   return TraverseAlgorithm<EditingInFlatTreeStrategy,
                            TraversalRight<EditingInFlatTreeStrategy>>(
       visible_position);
 }
 
 }  // namespace blink