Introduce AdjustInlineBoxPositionForTextDirection() for ComputeInlineBoxPosition()

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 730 matching lines @@
 static bool IsStartOfDifferentDirection(const InlineBox* inline_box) {
   InlineBox* prev_box = inline_box->PrevLeafChild();
   if (!prev_box)
     return true;
   if (prev_box->Direction() == inline_box->Direction())
     return true;
   DCHECK_NE(prev_box->BidiLevel(), inline_box->BidiLevel());
   return prev_box->BidiLevel() > inline_box->BidiLevel();
 }
 
+// TODO(yosin): We have a forward declaration here to reduce patch size. We'll
+// replice this with an implementation once review finished.
+static InlineBoxPosition AdjustInlineBoxPositionForTextDirection(InlineBox*,
+                                                                 int,
+                                                                 UnicodeBidi,
+                                                                 TextDirection);
+
 template <typename Strategy>
 static InlineBoxPosition ComputeInlineBoxPositionTemplate(
     const PositionTemplate<Strategy>& position,
     TextAffinity affinity,
     TextDirection primary_direction) {
   InlineBox* inline_box = nullptr;
   int caret_offset = position.ComputeEditingOffset();
   Node* const anchor_node = position.AnchorNode();
   LayoutObject* layout_object =
       anchor_node->IsShadowRoot()
@@ skipping 63 matching lines @@
       inline_box = SearchAheadForBetterMatch(text_layout_object);
       if (inline_box)
         caret_offset = inline_box->CaretMinOffset();
     }
     if (!inline_box)
       inline_box = candidate;
   }
 
   if (!inline_box)
     return InlineBoxPosition(inline_box, caret_offset);
+  return AdjustInlineBoxPositionForTextDirection(
+      inline_box, caret_offset, layout_object->Style()->GetUnicodeBidi(),
+      primary_direction);
+}
 
+static InlineBoxPosition AdjustInlineBoxPositionForTextDirection(
+    InlineBox* inline_box,
+    int caret_offset,
+    UnicodeBidi unicode_bidi,
+    TextDirection primary_direction) {
   unsigned char level = inline_box->BidiLevel();
 
   if (inline_box->Direction() == primary_direction) {
     if (caret_offset == inline_box->CaretRightmostOffset()) {
       InlineBox* next_box = inline_box->NextLeafChild();
       if (!next_box || next_box->BidiLevel() >= level)
         return InlineBoxPosition(inline_box, caret_offset);
 
       level = next_box->BidiLevel();
       InlineBox* prev_box = inline_box;
@@ skipping 54 matching lines @@
                  inline_box->PrevLeafChildIgnoringLineBreak()) {
         if (tertiary_box->BidiLevel() <= level)
           break;
         inline_box = tertiary_box;
       }
       return InlineBoxPosition(inline_box, inline_box->CaretLeftmostOffset());
     }
     return InlineBoxPosition(inline_box, caret_offset);
   }
 
-  if (layout_object &&
-      layout_object->Style()->GetUnicodeBidi() == UnicodeBidi::kPlaintext) {
+  if (unicode_bidi == UnicodeBidi::kPlaintext) {
     if (inline_box->BidiLevel() < level)
       return InlineBoxPosition(inline_box, inline_box->CaretLeftmostOffset());
     return InlineBoxPosition(inline_box, inline_box->CaretRightmostOffset());
   }
 
   InlineBox* next_box = inline_box->NextLeafChildIgnoringLineBreak();
   if (!next_box || next_box->BidiLevel() < level) {
     // Right edge of a secondary run. Set to the left edge of the entire
     // run.
     while (InlineBox* prev_box = inline_box->PrevLeafChildIgnoringLineBreak()) {
@@ skipping 1562 matching lines @@
 
 IntRect ComputeTextRect(const EphemeralRangeInFlatTree& range) {
   return EnclosingIntRect(ComputeTextRectTemplate(range));
 }
 
 FloatRect ComputeTextFloatRect(const EphemeralRange& range) {
   return ComputeTextRectTemplate(range);
 }
 
 }  // namespace blink