Rename ComposedTree to FlatTree

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 334 matching lines @@
     updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
 }
 
 void SelectionController::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (!m_mouseDownMayStartSelect)
         return;
 
     AppendTrailingWhitespace appendTrailingWhitespace = (result.event().clickCount() == 2 && m_frame->editor().isSelectTrailingWhitespaceEnabled()) ? AppendTrailingWhitespace::ShouldAppend : AppendTrailingWhitespace::DontAppend;
 
-    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
-        return selectClosestWordFromHitTestResult<EditingInComposedTreeStrategy>(result.hitTestResult(), appendTrailingWhitespace);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return selectClosestWordFromHitTestResult<EditingInFlatTreeStrategy>(result.hitTestResult(), appendTrailingWhitespace);
     selectClosestWordFromHitTestResult<EditingStrategy>(result.hitTestResult(), appendTrailingWhitespace);
 }
 
 template <typename Strategy>
 void SelectionController::selectClosestMisspellingFromMouseEvent(const MouseEventWithHitTestResults& result)
 {
     if (!m_mouseDownMayStartSelect)
         return;
 
     selectClosestMisspellingFromHitTestResult<Strategy>(result.hitTestResult(),
@@ skipping 64 matching lines @@
     if (pos.isNotNull()) {
         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);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return handleMousePressEventTripleClickAlgorithm<EditingInFlatTreeStrategy>(event);
     return handleMousePressEventTripleClickAlgorithm<EditingStrategy>(event);
 }
 
 bool SelectionController::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event)
 {
-    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
-        return handleMousePressEventSingleClickAlgorithm<EditingInComposedTreeStrategy>(event);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return handleMousePressEventSingleClickAlgorithm<EditingInFlatTreeStrategy>(event);
     return handleMousePressEventSingleClickAlgorithm<EditingStrategy>(event);
 }
 
 void SelectionController::handleMousePressEvent(const MouseEventWithHitTestResults& event)
 {
     // If we got the event back, that must mean it wasn't prevented,
     // so it's allowed to start a drag or selection if it wasn't in a scrollbar.
     m_mouseDownMayStartSelect = canMouseDownStartSelect(event.innerNode()) && !event.scrollbar();
     m_mouseDownWasSingleClickInSelection = false;
     // Avoid double-tap touch gesture confusion by restricting multi-click side
@@ skipping 23 matching lines @@
         return;
 
     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::Move);
     HitTestResult result(request, view->rootFrameToContents(lastKnownMousePosition));
     layoutObject->hitTest(result);
     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);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return updateSelectionForMouseDragAlgorithm<EditingInFlatTreeStrategy>(hitTestResult, mousePressNode, dragStartPos, lastKnownMousePosition);
     updateSelectionForMouseDragAlgorithm<EditingStrategy>(hitTestResult, mousePressNode, dragStartPos, lastKnownMousePosition);
 }
 
 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
@@ skipping 23 matching lines @@
     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);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return handleMouseReleaseEventAlgorithm<EditingInFlatTreeStrategy>(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:
@@ skipping 35 matching lines @@
 #endif
     if (!innerNodeIsSelectable)
         return false;
 
     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);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return handleGestureLongPressAlgorithm<EditingInFlatTreeStrategy>(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()) {
-        if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
-            return selectClosestMisspellingFromMouseEvent<EditingInComposedTreeStrategy>(mev);
+        if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+            return selectClosestMisspellingFromMouseEvent<EditingInFlatTreeStrategy>(mev);
         return selectClosestMisspellingFromMouseEvent<EditingStrategy>(mev);
     }
 
     if (!m_frame->editor().behavior().shouldSelectOnContextualMenuClick())
         return;
 
-    if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
-        return selectClosestWordOrLinkFromMouseEvent<EditingInComposedTreeStrategy>(mev);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return selectClosestWordOrLinkFromMouseEvent<EditingInFlatTreeStrategy>(mev);
     selectClosestWordOrLinkFromMouseEvent<EditingStrategy>(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;
 
     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);
+    if (RuntimeEnabledFeatures::selectionForFlatTreeEnabled())
+        return passMousePressEventToSubframeAlgorithm<EditingInFlatTreeStrategy>(mev);
     passMousePressEventToSubframeAlgorithm<EditingStrategy>(mev);
 }
 
 void SelectionController::initializeSelectionState()
 {
     m_selectionState = SelectionState::HaveNotStartedSelection;
 }
 
 void SelectionController::setMouseDownMayStartSelect(bool mayStartSelect)
 {
@@ skipping 19 matching lines @@
     else
         m_selectionState = SelectionState::HaveNotStartedSelection;
 }
 
 FrameSelection& SelectionController::selection() const
 {
     return m_frame->selection();
 }
 
 } // namespace blink