Utilize VisibleSelectionTemplate template class in SelectionController

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  * Copyright (C) 2015 Google 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
@@ skipping 48 matching lines @@
 {
 }
 
 DEFINE_TRACE(SelectionController)
 {
     visitor->trace(m_frame);
 }
 
 namespace {
 
-void setSelectionIfNeeded(FrameSelection& selection, const VisibleSelection& newSelection)
+template <typename Strategy>
+void setSelectionIfNeeded(FrameSelection& selection, const VisibleSelectionTemplate<Strategy>& newSelection)
 {
-    if (equalSelectionsInDOMTree(selection.selection(), newSelection))
+    if (selection.visibleSelection<Strategy>() == newSelection)
         return;
     selection.setSelection(newSelection);
 }
 
 bool dispatchSelectStart(Node* node)
 {
     if (!node || !node->layoutObject())
         return true;
 
     return node->dispatchEvent(Event::createCancelableBubble(EventTypeNames::selectstart));
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy> expandSelectionToRespectUserSelectAll(Node* targetNode, const VisibleSelectionTemplate<Strategy>& selection)
 {
     Node* rootUserSelectAll = Strategy::rootUserSelectAllForNode(targetNode);
     if (!rootUserSelectAll)
         return selection;
 
     VisibleSelectionTemplate<Strategy> newSelection(selection);
     newSelection.setBase(mostBackwardCaretPosition(PositionAlgorithm<Strategy>::beforeNode(rootUserSelectAll), CanCrossEditingBoundary));
     newSelection.setExtent(mostForwardCaretPosition(PositionAlgorithm<Strategy>::afterNode(rootUserSelectAll), CanCrossEditingBoundary));
 
     return newSelection;
 }
 
-// TODO(yosin) |expandSelectionToRespectUserSelectAll()| with |VisibleSelection|
-// should be removed once we have full version of |VisibleSelectionTemplate|.
-static VisibleSelectionTemplate<EditingStrategy> expandSelectionToRespectUserSelectAll(Node* targetNode, const VisibleSelection& selection)
-{
-    return expandSelectionToRespectUserSelectAll(targetNode, VisibleSelectionTemplate<EditingStrategy>(selection));
-}
-
-bool expandSelectionUsingGranularity(VisibleSelection& selection, TextGranularity granularity)
-{
-    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
-        return selection.expandUsingGranularityInComposedTree(granularity);
-    return selection.expandUsingGranularity(granularity);
-}
-
 template <typename Strategy>
 static int textDistance(const PositionAlgorithm<Strategy>& start, const PositionAlgorithm<Strategy>& end)
 {
     return TextIteratorAlgorithm<Strategy>::rangeLength(start, end, true);
 }
 
 bool canMouseDownStartSelect(Node* node)
 {
     if (!node || !node->layoutObject())
         return true;
@@ skipping 23 matching lines @@
     // existing selection so we can allow for text dragging.
     if (FrameView* view = m_frame->view()) {
         LayoutPoint vPoint = view->rootFrameToContents(event.event().position());
         if (!extendSelection && selection().contains(vPoint)) {
             m_mouseDownWasSingleClickInSelection = true;
             return false;
         }
     }
 
     const PositionWithAffinity eventPos = innerNode->layoutObject()->positionForPoint(event.localPoint());
-    VisiblePositionTemplate<Strategy> visiblePos = createVisiblePosition(fromPositionInDOMTree<Strategy>(eventPos.position()), eventPos.affinity());
+    VisiblePositionTemplate<Strategy> visiblePos = createVisiblePosition(fromPositionInDOMTree<Strategy>(eventPos));
     if (visiblePos.isNull())
         visiblePos = createVisiblePosition(PositionAlgorithm<Strategy>::firstPositionInOrBeforeNode(innerNode));
     PositionAlgorithm<Strategy> pos = visiblePos.deepEquivalent();
 
-    VisibleSelectionTemplate<Strategy> newSelection(selection().selection());
+    VisibleSelectionTemplate<Strategy> newSelection = selection().visibleSelection<Strategy>();
     TextGranularity granularity = CharacterGranularity;
 
     if (extendSelection && newSelection.isCaretOrRange()) {
         const VisibleSelectionTemplate<Strategy> selectionInUserSelectAll(expandSelectionToRespectUserSelectAll(innerNode, VisibleSelectionTemplate<Strategy>(createVisiblePosition(pos))));
         if (selectionInUserSelectAll.isRange()) {
             if (selectionInUserSelectAll.start().compareTo(newSelection.start()) < 0)
                 pos = selectionInUserSelectAll.start();
             else if (newSelection.end().compareTo(selectionInUserSelectAll.end()) < 0)
                 pos = selectionInUserSelectAll.end();
         }
 
         if (!m_frame->editor().behavior().shouldConsiderSelectionAsDirectional()) {
             if (pos.isNotNull()) {
-                // See <rdar://problem/3668157> REGRESSION (Mail): shift-click deselects when selection
-                // was created right-to-left
+                // See <rdar://problem/3668157> REGRESSION (Mail): shift-click
+                // deselects when selection was created right-to-left
                 const PositionAlgorithm<Strategy> start = newSelection.start();
                 const PositionAlgorithm<Strategy> end = newSelection.end();
                 int distanceToStart = textDistance(start, pos);
                 int distanceToEnd = textDistance(pos, end);
                 if (distanceToStart <= distanceToEnd)
                     newSelection = VisibleSelectionTemplate<Strategy>(end, pos);
                 else
                     newSelection = VisibleSelectionTemplate<Strategy>(start, pos);
             }
         } else {
@@ skipping 16 matching lines @@
 template <typename Strategy>
 void SelectionController::updateSelectionForMouseDragAlgorithm(const HitTestResult& hitTestResult, Node* mousePressNode, const LayoutPoint& dragStartPos, const IntPoint& lastKnownMousePosition)
 {
     if (!m_mouseDownMayStartSelect)
         return;
 
     Node* target = hitTestResult.innerNode();
     if (!target)
         return;
 
-    const PositionWithAffinity rawTargetPosition = selection().selection().positionRespectingEditingBoundary(hitTestResult.localPoint(), target);
-    const VisiblePositionTemplate<Strategy> targetPosition = createVisiblePosition(fromPositionInDOMTree<Strategy>(rawTargetPosition.position()), rawTargetPosition.affinity());
+    PositionWithAffinity rawTargetPosition = selection().selection().positionRespectingEditingBoundary(hitTestResult.localPoint(), target);
+    VisiblePositionTemplate<Strategy> targetPosition = createVisiblePosition(fromPositionInDOMTree<Strategy>(rawTargetPosition));
     // Don't modify the selection if we're not on a node.
     if (targetPosition.isNull())
         return;
 
     // Restart the selection if this is the first mouse move. This work is usually
     // done in handleMousePressEvent, but not if the mouse press was on an existing selection.
-    VisibleSelectionTemplate<Strategy> newSelection(selection().selection());
+    VisibleSelectionTemplate<Strategy> newSelection = selection().visibleSelection<Strategy>();
 
     // Special case to limit selection to the containing block for SVG text.
     // FIXME: Isn't there a better non-SVG-specific way to do this?
     if (Node* selectionBaseNode = newSelection.base().anchorNode()) {
         if (LayoutObject* selectionBaseLayoutObject = selectionBaseNode->layoutObject()) {
             if (selectionBaseLayoutObject->isSVGText()) {
                 if (target->layoutObject()->containingBlock() != selectionBaseLayoutObject->containingBlock())
                     return;
             }
         }
@@ skipping 63 matching lines @@
     } else {
         granularity = CharacterGranularity;
         m_selectionState = SelectionState::PlacedCaret;
     }
 
     this->selection().setNonDirectionalSelectionIfNeeded(selection, granularity);
 
     return true;
 }
 
+template <typename Strategy>
 void SelectionController::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
 {
     Node* innerNode = result.innerNode();
-    VisibleSelection newSelection;
+    VisibleSelectionTemplate<Strategy> newSelection;
 
     if (!innerNode || !innerNode->layoutObject())
         return;
 
-    VisiblePosition pos = createVisiblePosition(innerNode->layoutObject()->positionForPoint(result.localPoint()));
+    const VisiblePositionTemplate<Strategy> pos = createVisiblePosition(fromPositionInDOMTree<Strategy>(innerNode->layoutObject()->positionForPoint(result.localPoint())));
     if (pos.isNotNull()) {
-        newSelection = VisibleSelection(pos);
-        expandSelectionUsingGranularity(newSelection, WordGranularity);
+        newSelection = VisibleSelectionTemplate<Strategy>(pos);
+        newSelection.expandUsingGranularity(WordGranularity);
     }
 
 #if OS(ANDROID)
     // If node is not editable and doesn't have text except space, tab or
     // line break, do not select that 'empty' area.
     if (!innerNode->hasEditableStyle()) {
-        const EphemeralRangeInComposedTree range = EphemeralRangeInComposedTree(newSelection.startInComposedTree(), newSelection.endInComposedTree());
+        EphemeralRangeTemplate<Strategy> range = EphemeralRangeTemplate<Strategy>(newSelection.start(), newSelection.end());
         String str = plainText(range, TextIteratorDefaultBehavior);
         if (str.isEmpty() || str.simplifyWhiteSpace().containsOnlyWhitespace())
             return;
     }
 #endif
 
     if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend && newSelection.isRange())
         newSelection.appendTrailingWhitespace();
 
     updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
 }
 
+template <typename Strategy>
 void SelectionController::selectClosestMisspellingFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
 {
     Node* innerNode = result.innerNode();
-    VisibleSelection newSelection;
+    VisibleSelectionTemplate<Strategy> newSelection;
 
     if (!innerNode || !innerNode->layoutObject())
         return;
 
-    VisiblePosition pos = createVisiblePosition(innerNode->layoutObject()->positionForPoint(result.localPoint()));
+    VisiblePositionTemplate<Strategy> pos = createVisiblePosition(fromPositionInDOMTree<Strategy>(innerNode->layoutObject()->positionForPoint(result.localPoint())));
     if (pos.isNotNull()) {
-        const Position markerPosition = pos.deepEquivalent().parentAnchoredEquivalent();
-        DocumentMarkerVector markers = innerNode->document().markers().markersInRange(EphemeralRange(markerPosition), DocumentMarker::MisspellingMarkers());
+        const PositionAlgorithm<Strategy> markerPosition = pos.deepEquivalent().parentAnchoredEquivalent();
+        DocumentMarkerVector markers = innerNode->document().markers().markersInRange(EphemeralRange(toPositionInDOMTree(markerPosition)), DocumentMarker::MisspellingMarkers());
         if (markers.size() == 1) {
             Node* containerNode = markerPosition.computeContainerNode();
-            const Position start(containerNode, markers[0]->startOffset());
-            const Position end(containerNode, markers[0]->endOffset());
-            newSelection = VisibleSelection(start, end);
+            const PositionAlgorithm<Strategy> start(containerNode, markers[0]->startOffset());
+            const PositionAlgorithm<Strategy> end(containerNode, markers[0]->endOffset());
+            newSelection = VisibleSelectionTemplate<Strategy>(start, end);
         }
     }
 
     if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend && newSelection.isRange())
         newSelection.appendTrailingWhitespace();
 
     updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
 }
 
 void SelectionController::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (!m_mouseDownMayStartSelect)
         return;
 
-    selectClosestWordFromHitTestResult(result.hitTestResult(),
-        (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend);
+    AppendTrailingWhitespace appendTrailingWhitespace = (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend;
+
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return selectClosestWordFromHitTestResult<EditingInComposedTreeStrategy>(result.hitTestResult(), appendTrailingWhitespace);
+    selectClosestWordFromHitTestResult<EditingStrategy>(result.hitTestResult(), appendTrailingWhitespace);
 }
 
+template <typename Strategy>
 void SelectionController::selectClosestMisspellingFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (!m_mouseDownMayStartSelect)
         return;
 
-    selectClosestMisspellingFromHitTestResult(result.hitTestResult(),
+    selectClosestMisspellingFromHitTestResult<Strategy>(result.hitTestResult(),
         (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend);
 
 }
 
+template <typename Strategy>
 void SelectionController::selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (!result.hitTestResult().isLiveLink())
         return selectClosestWordFromMouseEvent(result);
 
     Node* innerNode = result.innerNode();
 
     if (!innerNode || !innerNode->layoutObject() || !m_mouseDownMayStartSelect)
         return;
 
-    VisibleSelection newSelection;
+    VisibleSelectionTemplate<Strategy> newSelection;
     Element* URLElement = result.hitTestResult().URLElement();
-    VisiblePosition pos = createVisiblePosition(innerNode->layoutObject()->positionForPoint(result.localPoint()));
+    const VisiblePositionTemplate<Strategy> pos = createVisiblePosition(fromPositionInDOMTree<Strategy>(innerNode->layoutObject()->positionForPoint(result.localPoint())));
     if (pos.isNotNull() && pos.deepEquivalent().anchorNode()->isDescendantOf(URLElement))
-        newSelection = VisibleSelection::selectionFromContentsOfNode(URLElement);
+        newSelection = VisibleSelectionTemplate<Strategy>::selectionFromContentsOfNode(URLElement);
 
     updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
 }
 
 bool SelectionController::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event)
 {
     TRACE_EVENT0("blink", "SelectionController::handleMousePressEventDoubleClick");
 
     if (event.event().button() != LeftButton)
         return false;
 
     if (selection().isRange()) {
         // A double-click when range is already selected
         // should not change the selection.  So, do not call
         // selectClosestWordFromMouseEvent, but do set
         // m_beganSelectingText to prevent handleMouseReleaseEvent
         // from setting caret selection.
         m_selectionState = SelectionState::ExtendedSelection;
     } else {
         selectClosestWordFromMouseEvent(event);
     }
     return true;
 }
 
-bool SelectionController::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event)
+template <typename Strategy>
+bool SelectionController::handleMousePressEventTripleClickAlgorithm(const MouseEventWithHitTestResults& event)
 {
     TRACE_EVENT0("blink", "SelectionController::handleMousePressEventTripleClick");
 
     if (event.event().button() != LeftButton)
         return false;
 
     Node* innerNode = event.innerNode();
     if (!(innerNode && innerNode->layoutObject() && m_mouseDownMayStartSelect))
         return false;
 
-    VisibleSelection newSelection;
-    VisiblePosition pos = createVisiblePosition(innerNode->layoutObject()->positionForPoint(event.localPoint()));
+    VisibleSelectionTemplate<Strategy> newSelection;
+    const VisiblePositionTemplate<Strategy> pos = createVisiblePosition(fromPositionInDOMTree<Strategy>(innerNode->layoutObject()->positionForPoint(event.localPoint())));
     if (pos.isNotNull()) {
-        newSelection = VisibleSelection(pos);
-        expandSelectionUsingGranularity(newSelection, ParagraphGranularity);
+        newSelection = VisibleSelectionTemplate<Strategy>(pos);
+        newSelection.expandUsingGranularity(ParagraphGranularity);
     }
 
     return updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), ParagraphGranularity);
 }
 
+bool SelectionController::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event)
+{
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return handleMousePressEventTripleClickAlgorithm<EditingInComposedTreeStrategy>(event);
+    return handleMousePressEventTripleClickAlgorithm<EditingStrategy>(event);
+}
+
 bool SelectionController::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event)
 {
     if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
         return handleMousePressEventSingleClickAlgorithm<EditingInComposedTreeStrategy>(event);
     return handleMousePressEventSingleClickAlgorithm<EditingStrategy>(event);
 }
 
 void SelectionController::handleMousePressEvent(const MouseEventWithHitTestResults& event)
 {
     // If we got the event back, that must mean it wasn't prevented,
@@ skipping 29 matching lines @@
     updateSelectionForMouseDrag(result, mousePressNode, dragStartPos, lastKnownMousePosition);
 }
 
 void SelectionController::updateSelectionForMouseDrag(const HitTestResult& hitTestResult, Node* mousePressNode, const LayoutPoint& dragStartPos, const IntPoint& lastKnownMousePosition)
 {
     if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
         return updateSelectionForMouseDragAlgorithm<EditingInComposedTreeStrategy>(hitTestResult, mousePressNode, dragStartPos, lastKnownMousePosition);
     updateSelectionForMouseDragAlgorithm<EditingStrategy>(hitTestResult, mousePressNode, dragStartPos, lastKnownMousePosition);
 }
 
-bool SelectionController::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event, const LayoutPoint& dragStartPos)
+template <typename Strategy>
+bool SelectionController::handleMouseReleaseEventAlgorithm(const MouseEventWithHitTestResults& event, const LayoutPoint& dragStartPos)
 {
     bool handled = false;
     m_mouseDownMayStartSelect = false;
     // Clear the selection if the mouse didn't move after the last mouse
     // press and it's not a context menu click.  We do this so when clicking
     // on the selection, the selection goes away.  However, if we are
     // editing, place the caret.
     if (m_mouseDownWasSingleClickInSelection && m_selectionState != SelectionState::ExtendedSelection
         && dragStartPos == event.event().position()
         && selection().isRange()
         && event.event().button() != RightButton) {
-        VisibleSelection newSelection;
+        VisibleSelectionTemplate<Strategy> newSelection;
         Node* node = event.innerNode();
         bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
         if (node && node->layoutObject() && (caretBrowsing || node->hasEditableStyle())) {
-            VisiblePosition pos = createVisiblePosition(node->layoutObject()->positionForPoint(event.localPoint()));
-            newSelection = VisibleSelection(pos);
+            const VisiblePositionTemplate<Strategy> pos = createVisiblePosition(fromPositionInDOMTree<Strategy>(node->layoutObject()->positionForPoint(event.localPoint())));
+            newSelection = VisibleSelectionTemplate<Strategy>(pos);
         }
 
         setSelectionIfNeeded(selection(), newSelection);
 
         handled = true;
     }
 
     selection().notifyLayoutObjectOfSelectionChange(UserTriggered);
 
     selection().selectFrameElementInParentIfFullySelected();
 
     if (event.event().button() == MiddleButton && !event.isOverLink()) {
         // Ignore handled, since we want to paste to where the caret was placed anyway.
         handled = handlePasteGlobalSelection(event.event()) || handled;
     }
 
     return handled;
 }
 
+bool SelectionController::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event, const LayoutPoint& dragStartPos)
+{
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return handleMouseReleaseEventAlgorithm<EditingInComposedTreeStrategy>(event, dragStartPos);
+    return handleMouseReleaseEventAlgorithm<EditingStrategy>(event, dragStartPos);
+}
 
 bool SelectionController::handlePasteGlobalSelection(const PlatformMouseEvent& mouseEvent)
 {
     // If the event was a middle click, attempt to copy global selection in after
     // the newly set caret position.
     //
     // This code is called from either the mouse up or mouse down handling. There
     // is some debate about when the global selection is pasted:
     //   xterm: pastes on up.
     //   GTK: pastes on down.
@@ skipping 12 matching lines @@
     if (!m_frame->page())
         return false;
     Frame* focusFrame = m_frame->page()->focusController().focusedOrMainFrame();
     // Do not paste here if the focus was moved somewhere else.
     if (m_frame == focusFrame && m_frame->editor().behavior().supportsGlobalSelection())
         return m_frame->editor().command("PasteGlobalSelection").execute();
 
     return false;
 }
 
-bool SelectionController::handleGestureLongPress(const PlatformGestureEvent& gestureEvent, const HitTestResult& hitTestResult)
+template <typename Strategy>
+bool SelectionController::handleGestureLongPressAlgorithm(const PlatformGestureEvent& gestureEvent, const HitTestResult& hitTestResult)
 {
     if (hitTestResult.isLiveLink())
         return false;
 
 #if OS(ANDROID)
     bool shouldLongPressSelectWord = true;
 #else
     bool shouldLongPressSelectWord = m_frame->settings() && m_frame->settings()->touchEditingEnabled();
 #endif
     if (!shouldLongPressSelectWord)
         return false;
 
     Node* innerNode = hitTestResult.innerNode();
 #if OS(ANDROID)
     bool innerNodeIsSelectable = innerNode && (innerNode->isContentEditable() || innerNode->isTextNode() || innerNode->canStartSelection());
 #else
     bool innerNodeIsSelectable = innerNode && (innerNode->isContentEditable() || innerNode->isTextNode());
 #endif
     if (!innerNodeIsSelectable)
         return false;
 
-    selectClosestWordFromHitTestResult(hitTestResult, AppendTrailingWhitespace::DontAppend);
-    if (!selection().isRange())
-        return false;
-    return true;
+    selectClosestWordFromHitTestResult<Strategy>(hitTestResult, AppendTrailingWhitespace::DontAppend);
+    return selection().isRange();
+}
+
+bool SelectionController::handleGestureLongPress(const PlatformGestureEvent& gestureEvent, const HitTestResult& hitTestResult)
+{
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return handleGestureLongPressAlgorithm<EditingInComposedTreeStrategy>(gestureEvent, hitTestResult);
+    return handleGestureLongPressAlgorithm<EditingStrategy>(gestureEvent, hitTestResult);
 }
 
 void SelectionController::sendContextMenuEvent(const MouseEventWithHitTestResults& mev, const LayoutPoint& position)
 {
     if (selection().contains(position)
         || mev.scrollbar()
         // FIXME: In the editable case, word selection sometimes selects content that isn't underneath the mouse.
         // If the selection is non-editable, we do word selection to make it easier to use the contextual menu items
         // available for text selections.  But only if we're above text.
         || !(selection().isContentEditable() || (mev.innerNode() && mev.innerNode()->isTextNode())))
         return;
 
     m_mouseDownMayStartSelect = true; // context menu events are always allowed to perform a selection
 
-    if (mev.hitTestResult().isMisspelled())
-        selectClosestMisspellingFromMouseEvent(mev);
-    else if (m_frame->editor().behavior().shouldSelectOnContextualMenuClick())
-        selectClosestWordOrLinkFromMouseEvent(mev);
+    if (mev.hitTestResult().isMisspelled()) {
+        if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+            return selectClosestMisspellingFromMouseEvent<EditingInComposedTreeStrategy>(mev);
+        return selectClosestMisspellingFromMouseEvent<EditingStrategy>(mev);
+    }
+
+    if (!m_frame->editor().behavior().shouldSelectOnContextualMenuClick())
+        return;
+
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return selectClosestWordOrLinkFromMouseEvent<EditingInComposedTreeStrategy>(mev);
+    selectClosestWordOrLinkFromMouseEvent<EditingStrategy>(mev);
 }
 
-void SelectionController::passMousePressEventToSubframe(const MouseEventWithHitTestResults& mev)
+template <typename Strategy>
+void SelectionController::passMousePressEventToSubframeAlgorithm(const MouseEventWithHitTestResults& mev)
 {
     // If we're clicking into a frame that is selected, the frame will appear
     // greyed out even though we're clicking on the selection.  This looks
     // really strange (having the whole frame be greyed out), so we deselect the
     // selection.
     IntPoint p = m_frame->view()->rootFrameToContents(mev.event().position());
     if (!selection().contains(p))
         return;
 
-    VisiblePosition visiblePos = createVisiblePosition(
-        mev.innerNode()->layoutObject()->positionForPoint(mev.localPoint()));
-    VisibleSelection newSelection(visiblePos);
+    const VisiblePositionTemplate<Strategy> visiblePos = createVisiblePosition(
+        fromPositionInDOMTree<Strategy>(mev.innerNode()->layoutObject()->positionForPoint(mev.localPoint())));
+    VisibleSelectionTemplate<Strategy> newSelection(visiblePos);
     selection().setSelection(newSelection);
 }
 
+void SelectionController::passMousePressEventToSubframe(const MouseEventWithHitTestResults& mev)
+{
+    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
+        return passMousePressEventToSubframeAlgorithm<EditingInComposedTreeStrategy>(mev);
+    passMousePressEventToSubframeAlgorithm<EditingStrategy>(mev);
+}
+
 void SelectionController::initializeSelectionState()
 {
     m_selectionState = SelectionState::HaveNotStartedSelection;
 }
 
 void SelectionController::setMouseDownMayStartSelect(bool mayStartSelect)
 {
     m_mouseDownMayStartSelect = mayStartSelect;
 }
 
@@ skipping 16 matching lines @@
     else
         m_selectionState = SelectionState::HaveNotStartedSelection;
 }
 
 FrameSelection& SelectionController::selection() const
 {
     return m_frame->selection();
 }
 
 } // namespace blink