Simplify the SelectionConroller class with selection() instead of frame->selection()

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 90 matching lines @@
     return expandSelectionToRespectUserSelectAllAlgorithm<VisibleSelection::InDOMTree>(targetNode, selection);
 }
 
 static bool expandSelectionUsingGranularity(VisibleSelection& selection, TextGranularity granularity)
 {
     if (RuntimeEnabledFeatures::selectionForComposedTreeEnabled())
         return selection.expandUsingGranularityInComposedTree(granularity);
     return selection.expandUsingGranularity(granularity);
 }
 
-bool SelectionController::updateSelectionForMouseDownDispatchingSelectStart(Node* targetNode, const VisibleSelection& selection, TextGranularity granularity)
+bool SelectionController::updateSelectionForMouseDownDispatchingSelectStart(Node* targetNode, const VisibleSelection& visibleSelection, TextGranularity granularity)

[yosin_UTC9, 2015/06/24 09:26:39]

We don't need to rename this parameter name, this function doesn't use both
|selection| and |selection()|.

If we need to use both |selection()| and |selection|, we usually write as
|selection = this->selection()|.

[Miyoung Shin(c), 2015/06/24 10:51:03]

Done. Thanks for your kind comment.

 {
     if (Position::nodeIsUserSelectNone(targetNode))
         return false;
 
     if (!dispatchSelectStart(targetNode))
         return false;
 
-    if (selection.isRange()) {
+    if (visibleSelection.isRange()) {
         m_selectionInitiationState = ExtendedSelection;
     } else {
         granularity = CharacterGranularity;
         m_selectionInitiationState = PlacedCaret;
     }
 
-    m_frame->selection().setNonDirectionalSelectionIfNeeded(selection, granularity);
+    selection().setNonDirectionalSelectionIfNeeded(visibleSelection, granularity);
 
     return true;
 }
 
 void SelectionController::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
 {
     Node* innerNode = result.innerNode();
     VisibleSelection newSelection;
 
     if (innerNode && innerNode->layoutObject()) {
@@ skipping 69 matching lines @@
     }
 }
 
 bool SelectionController::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event)
 {
     TRACE_EVENT0("blink", "SelectionController::handleMousePressEventDoubleClick");
 
     if (event.event().button() != LeftButton)
         return false;
 
-    if (m_frame->selection().isRange()) {
+    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_selectionInitiationState = ExtendedSelection;
     } else {
         selectClosestWordFromMouseEvent(event);
     }
     return true;
@@ skipping 44 matching lines @@
     if (!(innerNode && innerNode->layoutObject() && m_mouseDownMayStartSelect))
         return false;
 
     // Extend the selection if the Shift key is down, unless the click is in a link.
     bool extendSelection = event.event().shiftKey() && !event.isOverLink();
 
     // Don't restart the selection when the mouse is pressed on an
     // existing selection so we can allow for text dragging.
     if (FrameView* view = m_frame->view()) {
         LayoutPoint vPoint = view->rootFrameToContents(event.event().position());
-        if (!extendSelection && m_frame->selection().contains(vPoint)) {
+        if (!extendSelection && selection().contains(vPoint)) {
             m_mouseDownWasSingleClickInSelection = true;
             return false;
         }
     }
 
     PositionWithAffinity eventPos = innerNode->layoutObject()->positionForPoint(event.localPoint());
     VisiblePosition visiblePos(Strategy::toPositionType(eventPos.position()), eventPos.affinity());
     if (visiblePos.isNull())
         visiblePos = VisiblePosition(firstPositionInOrBeforeNode(innerNode), DOWNSTREAM);
     PositionType pos = Strategy::toPositionType(visiblePos.deepEquivalent());
 
-    VisibleSelection newSelection = m_frame->selection().selection();
+    VisibleSelection newSelection = selection().selection();
     TextGranularity granularity = CharacterGranularity;
 
     if (extendSelection && newSelection.isCaretOrRange()) {
         VisibleSelection selectionInUserSelectAll(expandSelectionToRespectUserSelectAll(innerNode, VisibleSelection(VisiblePosition(pos))));
         if (selectionInUserSelectAll.isRange()) {
             if (Strategy::selectionStart(selectionInUserSelectAll).compareTo(Strategy::selectionStart(newSelection)) < 0)
                 pos = Strategy::selectionStart(selectionInUserSelectAll);
             else if (Strategy::selectionEnd(newSelection).compareTo(Strategy::selectionEnd(selectionInUserSelectAll)) < 0)
                 pos = Strategy::selectionEnd(selectionInUserSelectAll);
         }
 
         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
                 PositionType start = Strategy::selectionStart(newSelection);
                 PositionType end = Strategy::selectionEnd(newSelection);
                 int distanceToStart = textDistance(start, pos);
                 int distanceToEnd = textDistance(pos, end);
                 if (distanceToStart <= distanceToEnd)
                     newSelection = VisibleSelection(end, pos);
                 else
                     newSelection = VisibleSelection(start, pos);
             }
         } else {
             newSelection.setExtent(pos);
         }
 
-        if (m_frame->selection().granularity() != CharacterGranularity) {
-            granularity = m_frame->selection().granularity();
-            expandSelectionUsingGranularity(newSelection, m_frame->selection().granularity());
+        if (selection().granularity() != CharacterGranularity) {
+            granularity = selection().granularity();
+            expandSelectionUsingGranularity(newSelection, selection().granularity());
         }
     } else {
         newSelection = expandSelectionToRespectUserSelectAll(innerNode, VisibleSelection(visiblePos));
     }
 
     // Updating the selection is considered side-effect of the event and so it doesn't impact the handled state.
     updateSelectionForMouseDownDispatchingSelectStart(innerNode, newSelection, granularity);
     return false;
 }
 
@@ skipping 55 matching lines @@
 {
     using PositionType = typename Strategy::PositionType;
 
     if (!m_mouseDownMayStartSelect)
         return;
 
     Node* target = hitTestResult.innerNode();
     if (!target)
         return;
 
-    PositionWithAffinity rawTargetPosition = m_frame->selection().selection().positionRespectingEditingBoundary(hitTestResult.localPoint(), target);
+    PositionWithAffinity rawTargetPosition = selection().selection().positionRespectingEditingBoundary(hitTestResult.localPoint(), target);
     VisiblePosition targetPosition = VisiblePosition(Strategy::toPositionType(rawTargetPosition.position()), rawTargetPosition.affinity());
     // 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.
-    VisibleSelection newSelection = m_frame->selection().selection();
+    VisibleSelection newSelection = selection().selection();
 
     // 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 = Strategy::selectionBase(newSelection).deprecatedNode()) {
         if (LayoutObject* selectionBaseLayoutObject = selectionBaseNode->layoutObject()) {
             if (selectionBaseLayoutObject->isSVGText()) {
                 if (target->layoutObject()->containingBlock() != selectionBaseLayoutObject->containingBlock())
                     return;
             }
         }
@@ skipping 27 matching lines @@
                 newSelection.setExtent(PositionType::beforeNode(rootUserSelectAllForTarget).upstream(CanCrossEditingBoundary));
             else if (rootUserSelectAllForTarget && mousePressNode->layoutObject())
                 newSelection.setExtent(PositionType::afterNode(rootUserSelectAllForTarget).downstream(CanCrossEditingBoundary));
             else
                 newSelection.setExtent(targetPosition);
         }
     } else {
         newSelection.setExtent(targetPosition);
     }
 
-    if (m_frame->selection().granularity() != CharacterGranularity)
-        expandSelectionUsingGranularity(newSelection, m_frame->selection().granularity());
+    if (selection().granularity() != CharacterGranularity)
+        expandSelectionUsingGranularity(newSelection, selection().granularity());
 
-    m_frame->selection().setNonDirectionalSelectionIfNeeded(newSelection, m_frame->selection().granularity(),
+    selection().setNonDirectionalSelectionIfNeeded(newSelection, selection().granularity(),
         FrameSelection::AdjustEndpointsAtBidiBoundary);
 }
 
 bool SelectionController::handleMouseReleaseEvent(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_selectionInitiationState != ExtendedSelection
         && dragStartPos == event.event().position()
-        && m_frame->selection().isRange()
+        && selection().isRange()
         && event.event().button() != RightButton) {
         VisibleSelection newSelection;
         Node* node = event.innerNode();
         bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
         if (node && node->layoutObject() && (caretBrowsing || node->hasEditableStyle())) {
             VisiblePosition pos = VisiblePosition(node->layoutObject()->positionForPoint(event.localPoint()));
             newSelection = VisibleSelection(pos);
         }
 
-        setSelectionIfNeeded(m_frame->selection(), newSelection);
+        setSelectionIfNeeded(selection(), newSelection);
 
         handled = true;
     }
 
-    m_frame->selection().notifyLayoutObjectOfSelectionChange(UserTriggered);
+    selection().notifyLayoutObjectOfSelectionChange(UserTriggered);
 
-    m_frame->selection().selectFrameElementInParentIfFullySelected();
+    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;
 }
 
 
@@ skipping 38 matching lines @@
     if (shouldLongPressSelectWord) {
 
 
         Node* innerNode = hitTestResult.innerNode();
         if (!hitTestResult.isLiveLink() && innerNode && (innerNode->isContentEditable() || innerNode->isTextNode()
 #if OS(ANDROID)
             || innerNode->canStartSelection()
 #endif
             )) {
             selectClosestWordFromHitTestResult(hitTestResult, DontAppendTrailingWhitespace);
-            if (m_frame->selection().isRange())
+            if (selection().isRange())
                 return true;
         }
     }
     return false;
 }
 
 void SelectionController::sendContextMenuEvent(const MouseEventWithHitTestResults& mev, const LayoutPoint& position)
 {
-    if (!m_frame->selection().contains(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.
-        && (m_frame->selection().isContentEditable() || (mev.innerNode() && mev.innerNode()->isTextNode()))) {
+        && (selection().isContentEditable() || (mev.innerNode() && mev.innerNode()->isTextNode()))) {
         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);
     }
 }
 
 void SelectionController::passMousePressEventToSubframe(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 (m_frame->selection().contains(p)) {
+    if (selection().contains(p)) {
         VisiblePosition visiblePos(
             mev.innerNode()->layoutObject()->positionForPoint(mev.localPoint()));
         VisibleSelection newSelection(visiblePos);
-        m_frame->selection().setSelection(newSelection);
+        selection().setSelection(newSelection);
     }
 }
 
 void SelectionController::initializeSelectionState()
 {
     m_selectionInitiationState = HaveNotStartedSelection;
 }
 
 void SelectionController::setMouseDownMayStartSelect(bool mayStartSelect)
 {
     m_mouseDownMayStartSelect = mayStartSelect;
 }
 
 bool SelectionController::mouseDownMayStartSelect() const
 {
     return m_mouseDownMayStartSelect;
 }
 
 bool SelectionController::mouseDownWasSingleClickInSelection() const
 {
     return m_mouseDownWasSingleClickInSelection;
 }
 
+FrameSelection& SelectionController::selection() const
+{
+    return m_frame->selection();
+}
+
 } // namespace blink