Make InlineBoxTraversal return const pointers and/or references

InlineBoxTraversal is not supposed to alter the layout tree, so its
member functions should return const pointers.

Some member functions always return non-null values, so their return
types are changed to const references to beffer clarity.

This is also a preparation patch for crrev.com/c/1038058, splitting off
some of its trivial changes to reduce the size of the big patch.

Bug: 822575
Change-Id: I9c32814a88d42e9115be97425b0e0015c4d1779d
Reviewed-on: https://chromium-review.googlesource.com/1048785Reviewed-by: Emil A Eklund <eae@chromium.org>
Reviewed-by: Yoshifumi Inoue <yosin@chromium.org>
Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556674}

third_party/blink/renderer/core/editing/inline_box_position.cc

@@ -54,11 +54,11 @@ class LeftEdge {
     return InlineBoxPosition(&inline_box, inline_box.CaretLeftmostOffset());
   }
 
-  static InlineBox* BackwardLeafChild(const InlineBox& inline_box) {
+  static const InlineBox* BackwardLeafChild(const InlineBox& inline_box) {
     return inline_box.PrevLeafChild();
   }
 
-  static InlineBox* BackwardLeafChildIgnoringLineBreak(
+  static const InlineBox* BackwardLeafChildIgnoringLineBreak(
       const InlineBox& inline_box) {
     return inline_box.PrevLeafChildIgnoringLineBreak();
   }
@@ -67,7 +67,7 @@ class LeftEdge {
   // See [1] for details.
   // [1] UNICODE BIDIRECTIONAL ALGORITHM, http://unicode.org/reports/tr9/
   static bool IsStartOfDifferentDirection(const InlineBox& inline_box) {
-    InlineBox* prev_box = inline_box.PrevLeafChild();
+    const InlineBox* prev_box = inline_box.PrevLeafChild();
     if (!prev_box)
       return true;
     if (prev_box->Direction() == inline_box.Direction())
@@ -76,36 +76,36 @@ class LeftEdge {
     return prev_box->BidiLevel() > inline_box.BidiLevel();
   }
 
-  static InlineBox* FindForwardBidiRun(const InlineBox& inline_box,
-                                       unsigned bidi_level) {
+  static const InlineBox* FindForwardBidiRun(const InlineBox& inline_box,
+                                             unsigned bidi_level) {
     return InlineBoxTraversal::FindRightBidiRun(inline_box, bidi_level);
   }
 
   static InlineBoxPosition FindForwardBoundaryOfEntireBidiRunIgnoringLineBreak(
       const InlineBox& inline_box,
       unsigned bidi_level) {
-    const InlineBox* result_box =
+    const InlineBox& result_box =
         InlineBoxTraversal::FindRightBoundaryOfEntireBidiRunIgnoringLineBreak(
             inline_box, bidi_level);
-    return InlineBoxPosition(result_box, result_box->CaretRightmostOffset());
+    return InlineBoxPosition(&result_box, result_box.CaretRightmostOffset());
   }
 
   static InlineBoxPosition FindBackwardBoundaryOfEntireBidiRun(
       const InlineBox& inline_box,
       unsigned bidi_level) {
-    const InlineBox* result_box =
+    const InlineBox& result_box =
         InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRun(inline_box,
                                                             bidi_level);
-    return InlineBoxPosition(result_box, result_box->CaretLeftmostOffset());
+    return InlineBoxPosition(&result_box, result_box.CaretLeftmostOffset());
   }
 
   static InlineBoxPosition FindBackwardBoundaryOfBidiRunIgnoringLineBreak(
       const InlineBox& inline_box,
       unsigned bidi_level) {
-    const InlineBox* result_box =
+    const InlineBox& result_box =
         InlineBoxTraversal::FindLeftBoundaryOfBidiRunIgnoringLineBreak(
             inline_box, bidi_level);
-    return InlineBoxPosition(result_box, result_box->CaretLeftmostOffset());
+    return InlineBoxPosition(&result_box, result_box.CaretLeftmostOffset());
   }
 };
 
@@ -118,7 +118,7 @@ class RightEdge {
     return InlineBoxPosition(&inline_box, inline_box.CaretRightmostOffset());
   }
 
-  static InlineBox* BackwardLeafChild(const InlineBox& inline_box) {
+  static const InlineBox* BackwardLeafChild(const InlineBox& inline_box) {
     return inline_box.NextLeafChild();
   }
 
@@ -136,36 +136,36 @@ class RightEdge {
     return next_box->BidiLevel() >= inline_box.BidiLevel();
   }
 
-  static InlineBox* FindForwardBidiRun(const InlineBox& inline_box,
-                                       unsigned bidi_level) {
+  static const InlineBox* FindForwardBidiRun(const InlineBox& inline_box,
+                                             unsigned bidi_level) {
     return InlineBoxTraversal::FindLeftBidiRun(inline_box, bidi_level);
   }
 
   static InlineBoxPosition FindForwardBoundaryOfEntireBidiRunIgnoringLineBreak(
       const InlineBox& inline_box,
       unsigned bidi_level) {
-    const InlineBox* result_box =
+    const InlineBox& result_box =
         InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRunIgnoringLineBreak(
             inline_box, bidi_level);
-    return InlineBoxPosition(result_box, result_box->CaretLeftmostOffset());
+    return InlineBoxPosition(&result_box, result_box.CaretLeftmostOffset());
   }
 
   static InlineBoxPosition FindBackwardBoundaryOfEntireBidiRun(
       const InlineBox& inline_box,
       unsigned bidi_level) {
-    const InlineBox* result_box =
+    const InlineBox& result_box =
         InlineBoxTraversal::FindRightBoundaryOfEntireBidiRun(inline_box,
                                                              bidi_level);
-    return InlineBoxPosition(result_box, result_box->CaretRightmostOffset());
+    return InlineBoxPosition(&result_box, result_box.CaretRightmostOffset());
   }
 
   static InlineBoxPosition FindBackwardBoundaryOfBidiRunIgnoringLineBreak(
       const InlineBox& inline_box,
       unsigned bidi_level) {
-    const InlineBox* result_box =
+    const InlineBox& result_box =
         InlineBoxTraversal::FindRightBoundaryOfBidiRunIgnoringLineBreak(
             inline_box, bidi_level);
-    return InlineBoxPosition(result_box, result_box->CaretRightmostOffset());
+    return InlineBoxPosition(&result_box, result_box.CaretRightmostOffset());
   }
 };
 
@@ -238,7 +238,7 @@ InlineBoxPosition AdjustInlineBoxPositionForPrimaryDirection(
     return EdgeSide::UnadjustedInlineBoxPosition(inline_box);
 
   const unsigned level = EdgeSide::BackwardLeafChild(inline_box)->BidiLevel();
-  InlineBox* const forward_box =
+  const InlineBox* const forward_box =
       EdgeSide::FindForwardBidiRun(inline_box, level);
 
   // For example, abc FED 123 ^ CBA when adjusting right edge of 123

third_party/blink/renderer/core/editing/inline_box_traversal.cc

@@ -14,7 +14,7 @@ namespace {
 struct TraverseLeft {
   STATIC_ONLY(TraverseLeft);
 
-  static InlineBox* Forward(const InlineBox& inline_box) {
+  static const InlineBox* Forward(const InlineBox& inline_box) {
     return inline_box.PrevLeafChild();
   }
 };
@@ -23,7 +23,7 @@ struct TraverseLeft {
 struct TraverseLeftIgnoringLineBreak {
   STATIC_ONLY(TraverseLeftIgnoringLineBreak);
 
-  static InlineBox* Forward(const InlineBox& inline_box) {
+  static const InlineBox* Forward(const InlineBox& inline_box) {
     return inline_box.PrevLeafChildIgnoringLineBreak();
   }
 };
@@ -32,7 +32,7 @@ struct TraverseLeftIgnoringLineBreak {
 struct TraverseRight {
   STATIC_ONLY(TraverseRight);
 
-  static InlineBox* Forward(const InlineBox& inline_box) {
+  static const InlineBox* Forward(const InlineBox& inline_box) {
     return inline_box.NextLeafChild();
   }
 };
@@ -41,14 +41,14 @@ struct TraverseRight {
 struct TraverseRightIgnoringLineBreak {
   STATIC_ONLY(TraverseRightIgnoringLineBreak);
 
-  static InlineBox* Forward(const InlineBox& inline_box) {
+  static const InlineBox* Forward(const InlineBox& inline_box) {
     return inline_box.NextLeafChildIgnoringLineBreak();
   }
 };
 
 template <typename TraversalStrategy>
-InlineBox* FindBidiRun(const InlineBox& start, unsigned bidi_level) {
-  for (InlineBox* runner = TraversalStrategy::Forward(start); runner;
+const InlineBox* FindBidiRun(const InlineBox& start, unsigned bidi_level) {
+  for (const InlineBox* runner = TraversalStrategy::Forward(start); runner;
        runner = TraversalStrategy::Forward(*runner)) {
     if (runner->BidiLevel() <= bidi_level)
       return runner;
@@ -57,76 +57,79 @@ InlineBox* FindBidiRun(const InlineBox& start, unsigned bidi_level) {
 }
 
 template <typename TraversalStrategy>
-InlineBox* FindBoudnaryOfBidiRun(const InlineBox& start, unsigned bidi_level) {
-  InlineBox* result = const_cast<InlineBox*>(&start);
-  for (InlineBox* runner = TraversalStrategy::Forward(start); runner;
+const InlineBox& FindBoudnaryOfBidiRun(const InlineBox& start,
+                                       unsigned bidi_level) {
+  const InlineBox* result = &start;
+  for (const InlineBox* runner = TraversalStrategy::Forward(start); runner;
        runner = TraversalStrategy::Forward(*runner)) {
     if (runner->BidiLevel() <= bidi_level)
-      return result;
+      return *result;
     result = runner;
   }
-  return result;
+  return *result;
 }
 
 template <typename TraversalStrategy>
-InlineBox* FindBoudnaryOfEntireBidiRun(const InlineBox& start,
-                                       unsigned bidi_level) {
-  InlineBox* result = const_cast<InlineBox*>(&start);
-  for (InlineBox* runner = TraversalStrategy::Forward(start); runner;
+const InlineBox& FindBoudnaryOfEntireBidiRun(const InlineBox& start,
+                                             unsigned bidi_level) {
+  const InlineBox* result = &start;
+  for (const InlineBox* runner = TraversalStrategy::Forward(start); runner;
        runner = TraversalStrategy::Forward(*runner)) {
     if (runner->BidiLevel() < bidi_level)
-      return result;
+      return *result;
     result = runner;
   }
-  return result;
+  return *result;
 }
 
 }  // namespace
 
-InlineBox* InlineBoxTraversal::FindLeftBidiRun(const InlineBox& box,
-                                               unsigned bidi_level) {
+const InlineBox* InlineBoxTraversal::FindLeftBidiRun(const InlineBox& box,
+                                                     unsigned bidi_level) {
   return FindBidiRun<TraverseLeft>(box, bidi_level);
 }
 
-InlineBox* InlineBoxTraversal::FindRightBidiRun(const InlineBox& box,
-                                                unsigned bidi_level) {
+const InlineBox* InlineBoxTraversal::FindRightBidiRun(const InlineBox& box,
+                                                      unsigned bidi_level) {
   return FindBidiRun<TraverseRight>(box, bidi_level);
 }
 
-InlineBox* InlineBoxTraversal::FindLeftBoundaryOfBidiRunIgnoringLineBreak(
+const InlineBox& InlineBoxTraversal::FindLeftBoundaryOfBidiRunIgnoringLineBreak(
     const InlineBox& inline_box,
     unsigned bidi_level) {
   return FindBoudnaryOfBidiRun<TraverseLeftIgnoringLineBreak>(inline_box,
                                                               bidi_level);
 }
 
-InlineBox* InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRun(
+const InlineBox& InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRun(
     const InlineBox& inline_box,
     unsigned bidi_level) {
   return FindBoudnaryOfEntireBidiRun<TraverseLeft>(inline_box, bidi_level);
 }
 
-InlineBox* InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRunIgnoringLineBreak(
+const InlineBox&
+InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRunIgnoringLineBreak(
     const InlineBox& inline_box,
     unsigned bidi_level) {
   return FindBoudnaryOfEntireBidiRun<TraverseLeftIgnoringLineBreak>(inline_box,
                                                                     bidi_level);
 }
 
-InlineBox* InlineBoxTraversal::FindRightBoundaryOfBidiRunIgnoringLineBreak(
+const InlineBox&
+InlineBoxTraversal::FindRightBoundaryOfBidiRunIgnoringLineBreak(
     const InlineBox& inline_box,
     unsigned bidi_level) {
   return FindBoudnaryOfBidiRun<TraverseRightIgnoringLineBreak>(inline_box,
                                                                bidi_level);
 }
 
-InlineBox* InlineBoxTraversal::FindRightBoundaryOfEntireBidiRun(
+const InlineBox& InlineBoxTraversal::FindRightBoundaryOfEntireBidiRun(
     const InlineBox& inline_box,
     unsigned bidi_level) {
   return FindBoudnaryOfEntireBidiRun<TraverseRight>(inline_box, bidi_level);
 }
 
-InlineBox*
+const InlineBox&
 InlineBoxTraversal::FindRightBoundaryOfEntireBidiRunIgnoringLineBreak(
     const InlineBox& inline_box,
     unsigned bidi_level) {

third_party/blink/renderer/core/editing/inline_box_traversal.h

@@ -22,30 +22,32 @@ class InlineBoxTraversal final {
   // Traverses left/right from |box|, and returns the first box with bidi level
   // less than or equal to |bidi_level| (excluding |box| itself). Returns
   // |nullptr| when such a box doesn't exist.
-  static InlineBox* FindLeftBidiRun(const InlineBox& box, unsigned bidi_level);
-  static InlineBox* FindRightBidiRun(const InlineBox& box, unsigned bidi_level);
+  static const InlineBox* FindLeftBidiRun(const InlineBox& box,
+                                          unsigned bidi_level);
+  static const InlineBox* FindRightBidiRun(const InlineBox& box,
+                                           unsigned bidi_level);
 
   // Traverses left/right from |box|, and returns the last non-linebreak box
   // with bidi level greater than |bidi_level| (including |box| itself).
-  static InlineBox* FindLeftBoundaryOfBidiRunIgnoringLineBreak(
+  static const InlineBox& FindLeftBoundaryOfBidiRunIgnoringLineBreak(
       const InlineBox& box,
       unsigned bidi_level);
-  static InlineBox* FindRightBoundaryOfBidiRunIgnoringLineBreak(
+  static const InlineBox& FindRightBoundaryOfBidiRunIgnoringLineBreak(
       const InlineBox& box,
       unsigned bidi_level);
 
   // Traverses left/right from |box|, and returns the last box with bidi level
   // greater than or equal to |bidi_level| (including |box| itself).
-  static InlineBox* FindLeftBoundaryOfEntireBidiRun(const InlineBox& box,
-                                                    unsigned bidi_level);
-  static InlineBox* FindRightBoundaryOfEntireBidiRun(const InlineBox& box,
-                                                     unsigned bidi_level);
+  static const InlineBox& FindLeftBoundaryOfEntireBidiRun(const InlineBox& box,
+                                                          unsigned bidi_level);
+  static const InlineBox& FindRightBoundaryOfEntireBidiRun(const InlineBox& box,
+                                                           unsigned bidi_level);
 
   // Variants of the above two where line break boxes are ignored.
-  static InlineBox* FindLeftBoundaryOfEntireBidiRunIgnoringLineBreak(
+  static const InlineBox& FindLeftBoundaryOfEntireBidiRunIgnoringLineBreak(
       const InlineBox&,
       unsigned bidi_level);
-  static InlineBox* FindRightBoundaryOfEntireBidiRunIgnoringLineBreak(
+  static const InlineBox& FindRightBoundaryOfEntireBidiRunIgnoringLineBreak(
       const InlineBox&,
       unsigned bidi_level);
 };

third_party/blink/renderer/core/editing/rendered_position.cc

@@ -113,10 +113,10 @@ RenderedPosition RenderedPosition::LeftBoundaryOfBidiRun(
   if (!inline_box_ || bidi_level_of_run > inline_box_->BidiLevel())
     return RenderedPosition();
 
-  const InlineBox* const box =
+  const InlineBox& box =
       InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRunIgnoringLineBreak(
           *inline_box_, bidi_level_of_run);
-  return RenderedPosition(box, box->CaretLeftmostOffset());
+  return RenderedPosition(&box, box.CaretLeftmostOffset());
 }
 
 RenderedPosition RenderedPosition::RightBoundaryOfBidiRun(
@@ -124,10 +124,10 @@ RenderedPosition RenderedPosition::RightBoundaryOfBidiRun(
   if (!inline_box_ || bidi_level_of_run > inline_box_->BidiLevel())
     return RenderedPosition();
 
-  const InlineBox* const box =
+  const InlineBox& box =
       InlineBoxTraversal::FindRightBoundaryOfEntireBidiRunIgnoringLineBreak(
           *inline_box_, bidi_level_of_run);
-  return RenderedPosition(box, box->CaretRightmostOffset());
+  return RenderedPosition(&box, box.CaretRightmostOffset());
 }
 
 bool RenderedPosition::AtLeftBoundaryOfBidiRun(

third_party/blink/renderer/core/editing/selection_modifier_character.cc

@@ -67,24 +67,26 @@ struct TraversalLeft {
     return box.CaretLeftmostOffset();
   }
 
-  static InlineBox* FindBackwardBidiRun(const InlineBox& box,
-                                        unsigned bidi_level) {
+  static const InlineBox* FindBackwardBidiRun(const InlineBox& box,
+                                              unsigned bidi_level) {
     return InlineBoxTraversal::FindRightBidiRun(box, bidi_level);
   }
 
-  static InlineBox* FindBackwardBoundaryOfEntireBidiRun(const InlineBox& box,
-                                                        unsigned bidi_level) {
+  static const InlineBox& FindBackwardBoundaryOfEntireBidiRun(
+      const InlineBox& box,
+      unsigned bidi_level) {
     return InlineBoxTraversal::FindRightBoundaryOfEntireBidiRun(box,
                                                                 bidi_level);
   }
 
-  static InlineBox* FindForwardBidiRun(const InlineBox& box,
-                                       unsigned bidi_level) {
+  static const InlineBox* FindForwardBidiRun(const InlineBox& box,
+                                             unsigned bidi_level) {
     return InlineBoxTraversal::FindLeftBidiRun(box, bidi_level);
   }
 
-  static InlineBox* FindForwardBoundaryOfEntireBidiRun(const InlineBox& box,
-                                                       unsigned bidi_level) {
+  static const InlineBox& FindForwardBoundaryOfEntireBidiRun(
+      const InlineBox& box,
+      unsigned bidi_level) {
     return InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRun(box, bidi_level);
   }
 
@@ -96,11 +98,12 @@ struct TraversalLeft {
     return NextGraphemeBoundaryOf(node, offset);
   }
 
-  static InlineBox* ForwardLeafChildOf(const InlineBox& box) {
+  static const InlineBox* ForwardLeafChildOf(const InlineBox& box) {
     return box.PrevLeafChild();
   }
 
-  static InlineBox* ForwardLeafChildIgnoringLineBreakOf(const InlineBox& box) {
+  static const InlineBox* ForwardLeafChildIgnoringLineBreakOf(
+      const InlineBox& box) {
     return box.PrevLeafChildIgnoringLineBreak();
   }
 
@@ -144,7 +147,7 @@ template <typename Strategy>
 struct TraversalRight {
   STATIC_ONLY(TraversalRight);
 
-  static InlineBox* BackwardLeafChildOf(const InlineBox& box) {
+  static const InlineBox* BackwardLeafChildOf(const InlineBox& box) {
     return box.PrevLeafChild();
   }
 
@@ -162,23 +165,25 @@ struct TraversalRight {
     return box.CaretRightmostOffset();
   }
 
-  static InlineBox* FindBackwardBidiRun(const InlineBox& box,
-                                        unsigned bidi_level) {
+  static const InlineBox* FindBackwardBidiRun(const InlineBox& box,
+                                              unsigned bidi_level) {
     return InlineBoxTraversal::FindLeftBidiRun(box, bidi_level);
   }
 
-  static InlineBox* FindBackwardBoundaryOfEntireBidiRun(const InlineBox& box,
-                                                        unsigned bidi_level) {
+  static const InlineBox& FindBackwardBoundaryOfEntireBidiRun(
+      const InlineBox& box,
+      unsigned bidi_level) {
     return InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRun(box, bidi_level);
   }
 
-  static InlineBox* FindForwardBidiRun(const InlineBox& box,
-                                       unsigned bidi_level) {
+  static const InlineBox* FindForwardBidiRun(const InlineBox& box,
+                                             unsigned bidi_level) {
     return InlineBoxTraversal::FindRightBidiRun(box, bidi_level);
   }
 
-  static InlineBox* FindForwardBoundaryOfEntireBidiRun(const InlineBox& box,
-                                                       unsigned bidi_level) {
+  static const InlineBox& FindForwardBoundaryOfEntireBidiRun(
+      const InlineBox& box,
+      unsigned bidi_level) {
     return InlineBoxTraversal::FindRightBoundaryOfEntireBidiRun(box,
                                                                 bidi_level);
   }
@@ -191,11 +196,12 @@ struct TraversalRight {
     return PreviousGraphemeBoundaryOf(node, offset);
   }
 
-  static InlineBox* ForwardLeafChildOf(const InlineBox& box) {
+  static const InlineBox* ForwardLeafChildOf(const InlineBox& box) {
     return box.NextLeafChild();
   }
 
-  static InlineBox* ForwardLeafChildIgnoringLineBreakOf(const InlineBox& box) {
+  static const InlineBox* ForwardLeafChildIgnoringLineBreakOf(
+      const InlineBox& box) {
     return box.NextLeafChildIgnoringLineBreak();
   }
 
@@ -247,21 +253,21 @@ template <typename Traversal>
 const InlineBox* LeadingBoxOfEntireSecondaryRun(const InlineBox* box) {
   const InlineBox* runner = box;
   while (true) {
-    const InlineBox* const backward_box =
+    const InlineBox& backward_box =
         Traversal::FindBackwardBoundaryOfEntireBidiRun(*runner,
                                                        runner->BidiLevel());
-    if (backward_box->BidiLevel() == runner->BidiLevel())
-      return backward_box;
-    DCHECK_GT(backward_box->BidiLevel(), runner->BidiLevel());
-    runner = backward_box;
+    if (backward_box.BidiLevel() == runner->BidiLevel())
+      return &backward_box;
+    DCHECK_GT(backward_box.BidiLevel(), runner->BidiLevel());
+    runner = &backward_box;
 
-    const InlineBox* const forward_box =
+    const InlineBox& forward_box =
         Traversal::FindForwardBoundaryOfEntireBidiRun(*runner,
                                                       runner->BidiLevel());
-    if (forward_box->BidiLevel() == runner->BidiLevel())
-      return forward_box;
-    DCHECK_GT(forward_box->BidiLevel(), runner->BidiLevel());
-    runner = forward_box;
+    if (forward_box.BidiLevel() == runner->BidiLevel())
+      return &forward_box;
+    DCHECK_GT(forward_box.BidiLevel(), runner->BidiLevel());
+    runner = &forward_box;
   }
 }
 
@@ -320,7 +326,7 @@ static PositionTemplate<Strategy> TraverseInternalAlgorithm(
 
       if (Traversal::IsOvershot(offset, *box)) {
         // Overshot forwardly.
-        InlineBox* const forward_box =
+        const InlineBox* const forward_box =
             Traversal::ForwardLeafChildIgnoringLineBreakOf(*box);
         if (!forward_box) {
           const PositionTemplate<Strategy>& forward_position =
@@ -349,7 +355,7 @@ static PositionTemplate<Strategy> TraverseInternalAlgorithm(
       DCHECK_EQ(offset, Traversal::CaretStartOffsetOf(*box));
 
       unsigned char level = box->BidiLevel();
-      InlineBox* forward_box = Traversal::ForwardLeafChildOf(*box);
+      const InlineBox* forward_box = Traversal::ForwardLeafChildOf(*box);
 
       if (box->Direction() == primary_direction) {
         if (!forward_box) {
@@ -366,7 +372,7 @@ static PositionTemplate<Strategy> TraverseInternalAlgorithm(
 
         level = forward_box->BidiLevel();
 
-        InlineBox* const backward_box =
+        const InlineBox* const backward_box =
             Traversal::FindBackwardBidiRun(*box, level);
         if (backward_box && backward_box->BidiLevel() == level)
           break;

third_party/blink/renderer/core/layout/layout_text.cc

@@ -696,23 +696,23 @@ CreatePositionWithAffinityForBoxAfterAdjustingOffsetForBiDi(
 
     if (prev_box && prev_box->BidiLevel() > box->BidiLevel()) {
       // e.g. left of B in aDC12BAb
-      const InlineBox* leftmost_box =
+      const InlineBox& leftmost_box =
           InlineBoxTraversal::FindLeftBoundaryOfBidiRunIgnoringLineBreak(
               *prev_box, box->BidiLevel());
       return CreatePositionWithAffinityForBox(
-          leftmost_box, leftmost_box->CaretRightmostOffset(),
+          &leftmost_box, leftmost_box.CaretRightmostOffset(),
           should_affinity_be_downstream);
     }
 
     if (!prev_box || prev_box->BidiLevel() < box->BidiLevel()) {
       // e.g. left of D in aDC12BAb
-      const InlineBox* rightmost_box =
+      const InlineBox& rightmost_box =
           InlineBoxTraversal::FindRightBoundaryOfEntireBidiRunIgnoringLineBreak(
               *box, box->BidiLevel());
       return CreatePositionWithAffinityForBox(
-          rightmost_box,
-          box->IsLeftToRightDirection() ? rightmost_box->CaretMaxOffset()
-                                        : rightmost_box->CaretMinOffset(),
+          &rightmost_box,
+          box->IsLeftToRightDirection() ? rightmost_box.CaretMaxOffset()
+                                        : rightmost_box.CaretMinOffset(),
           should_affinity_be_downstream);
     }
 
@@ -730,24 +730,24 @@ CreatePositionWithAffinityForBoxAfterAdjustingOffsetForBiDi(
 
   if (next_box && next_box->BidiLevel() > box->BidiLevel()) {
     // e.g. right of C in aDC12BAb
-    const InlineBox* rightmost_box =
+    const InlineBox& rightmost_box =
         InlineBoxTraversal::FindRightBoundaryOfBidiRunIgnoringLineBreak(
             *next_box, box->BidiLevel());
-    return CreatePositionWithAffinityForBox(
-        rightmost_box, rightmost_box->CaretLeftmostOffset(),
-        should_affinity_be_downstream);
+    return CreatePositionWithAffinityForBox(&rightmost_box,
+                                            rightmost_box.CaretLeftmostOffset(),
+                                            should_affinity_be_downstream);
   }
 
   if (!next_box || next_box->BidiLevel() < box->BidiLevel()) {
     // e.g. right of A in aDC12BAb
-    const InlineBox* leftmost_box =
+    const InlineBox& leftmost_box =
         InlineBoxTraversal::FindLeftBoundaryOfEntireBidiRunIgnoringLineBreak(
             *box, box->BidiLevel());
-    return CreatePositionWithAffinityForBox(
-        leftmost_box,
-        box->IsLeftToRightDirection() ? leftmost_box->CaretMinOffset()
-                                      : leftmost_box->CaretMaxOffset(),
-        should_affinity_be_downstream);
+    return CreatePositionWithAffinityForBox(&leftmost_box,
+                                            box->IsLeftToRightDirection()
+                                                ? leftmost_box.CaretMinOffset()
+                                                : leftmost_box.CaretMaxOffset(),
+                                            should_affinity_be_downstream);
   }
 
   return CreatePositionWithAffinityForBox(box, box->CaretLeftmostOffset(),