Move computeInlineBoxPosition out from PositionAlgorithm class

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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 359 matching lines @@
     TextBreakIterator* iter = 0;
 
     CachedLogicallyOrderedLeafBoxes leafBoxes;
     Vector<UChar, 1024> string;
 
     while (1) {
         VisiblePosition adjacentCharacterPosition = direction == MoveRight ? current.right() : current.left();
         if (adjacentCharacterPosition.deepEquivalent() == current.deepEquivalent() || adjacentCharacterPosition.isNull())
             return VisiblePosition();
 
-        InlineBoxPosition boxPosition = adjacentCharacterPosition.deepEquivalent().computeInlineBoxPosition(TextAffinity::Upstream);
+        InlineBoxPosition boxPosition = computeInlineBoxPosition(adjacentCharacterPosition.deepEquivalent(), TextAffinity::Upstream);
         InlineBox* box = boxPosition.inlineBox;
         int offsetInBox = boxPosition.offsetInBox;
 
         if (!box)
             break;
         if (!box->isInlineTextBox()) {
             current = adjacentCharacterPosition;
             continue;
         }
 
@@ skipping 1046 matching lines @@
     if (position.position().isNull()) {
         layoutObject = nullptr;
         return LayoutRect();
     }
     Node* node = position.position().anchorNode();
 
     layoutObject = node->layoutObject();
     if (!layoutObject)
         return LayoutRect();
 
-    InlineBoxPosition boxPosition = position.position().computeInlineBoxPosition(position.affinity());
+    InlineBoxPosition boxPosition = computeInlineBoxPosition(position.position(), position.affinity());
 
     if (boxPosition.inlineBox)
         layoutObject = &boxPosition.inlineBox->layoutObject();
 
     return layoutObject->localCaretRect(boxPosition.inlineBox, boxPosition.offsetInBox);
 }
 
 static int boundingBoxLogicalHeight(LayoutObject *o, const IntRect &rect)
 {
     return o->style()->isHorizontalWritingMode() ? rect.height() : rect.width();
@@ skipping 127 matching lines @@
 
     if (position2.anchorNode()->isTextNode() && !inRenderedText(position2))
         return false;
 
     const int renderedOffset1 = renderedOffsetOf(position1);
     const int renderedOffset2 = renderedOffsetOf(position2);
 
     if (layoutObject == posLayoutObject && renderedOffset1 == renderedOffset2)
         return false;
 
-    InlineBoxPosition boxPosition1 = position1.computeInlineBoxPosition(TextAffinity::Downstream);
-    InlineBoxPosition boxPosition2 = position2.computeInlineBoxPosition(TextAffinity::Downstream);
+    InlineBoxPosition boxPosition1 = computeInlineBoxPosition(position1, TextAffinity::Downstream);
+    InlineBoxPosition boxPosition2 = computeInlineBoxPosition(position2, TextAffinity::Downstream);
 
     WTF_LOG(Editing, "layoutObject1:   %p [%p]\n", layoutObject, boxPosition1.inlineBox);
     WTF_LOG(Editing, "renderedOffset1: %d\n", renderedOffset1);
     WTF_LOG(Editing, "layoutObject2:   %p [%p]\n", posLayoutObject, boxPosition2.inlineBox);
     WTF_LOG(Editing, "renderedOffset2: %d\n", renderedOffset2);
     WTF_LOG(Editing, "node1 min/max:   %d:%d\n", caretMinOffset(position1.anchorNode()), caretMaxOffset(position1.anchorNode()));
     WTF_LOG(Editing, "node2 min/max:   %d:%d\n", caretMinOffset(position2.anchorNode()), caretMaxOffset(position2.anchorNode()));
     WTF_LOG(Editing, "----------------------------------------------------------------------\n");
 
     if (!boxPosition1.inlineBox || !boxPosition2.inlineBox) {
@@ skipping 315 matching lines @@
 {
     return mostBackwardCaretPosition<EditingStrategy>(position, rule);
 }
 
 PositionInComposedTree mostBackwardCaretPosition(const PositionInComposedTree& position, EditingBoundaryCrossingRule rule)
 {
     return mostBackwardCaretPosition<EditingInComposedTreeStrategy>(position, rule);
 }
 
 }