Revert "Blink handle selection handle visibility"

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:
@@ skipping 149 matching lines @@
 
   DCHECK(!m_frame->document()->needsLayoutTreeUpdate());
   Node* innerNode = event.innerNode();
   if (!(innerNode && innerNode->layoutObject() && m_mouseDownMayStartSelect))
     return false;
 
   // Extend the selection if the Shift key is down, unless the click is in a
   // link or image.
   bool extendSelection = isExtendingSelection(event);
 
+  // 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 && selection().contains(vPoint)) {
+      m_mouseDownWasSingleClickInSelection = true;
+      return false;
+    }
+  }
+
   const VisiblePositionInFlatTree& visibleHitPos =
       visiblePositionOfHitTestResult(event.hitTestResult());
   const VisiblePositionInFlatTree& visiblePos =
       visibleHitPos.isNull()
           ? createVisiblePosition(
                 PositionInFlatTree::firstPositionInOrBeforeNode(innerNode))
           : visibleHitPos;
   const VisibleSelectionInFlatTree& selection =
       this->selection().visibleSelection<EditingInFlatTreeStrategy>();
 
-  // 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()) {
-    const LayoutPoint vPoint =
-        view->rootFrameToContents(event.event().position());
-    if (!extendSelection && this->selection().contains(vPoint)) {
-      m_mouseDownWasSingleClickInSelection = true;
-      if (!event.event().fromTouch())
-        return false;
-
-      if (!this->selection().isHandleVisible()) {
-        updateSelectionForMouseDownDispatchingSelectStart(
-            innerNode, selection, CharacterGranularity,
-            HandleVisibility::Visible);
-        return false;
-      }
-    }
-  }
-
   if (extendSelection && !selection.isNone()) {
     // Note: "fast/events/shift-click-user-select-none.html" makes
     // |pos.isNull()| true.
     const PositionInFlatTree& pos = adjustPositionRespectUserSelectAll(
         innerNode, selection.start(), selection.end(),
         visiblePos.deepEquivalent());
     SelectionInFlatTree::Builder builder;
     builder.setGranularity(this->selection().granularity());
     if (m_frame->editor().behavior().shouldConsiderSelectionAsDirectional()) {
       builder.setBaseAndExtent(selection.base(), pos);
     } else if (pos.isNull()) {
       builder.setBaseAndExtent(selection.base(), selection.extent());
     } else {
       // Shift+Click deselects when selection was created right-to-left
       const PositionInFlatTree& start = selection.start();
       const PositionInFlatTree& end = selection.end();
       const int distanceToStart = textDistance(start, pos);
       const int distanceToEnd = textDistance(pos, end);
       builder.setBaseAndExtent(distanceToStart <= distanceToEnd ? end : start,
                                pos);
     }
 
     updateSelectionForMouseDownDispatchingSelectStart(
         innerNode, createVisibleSelection(builder.build()),
-        this->selection().granularity(), HandleVisibility::NotVisible);
+        this->selection().granularity());
     return false;
   }
 
   if (m_selectionState == SelectionState::ExtendedSelection) {
-    updateSelectionForMouseDownDispatchingSelectStart(
-        innerNode, selection, CharacterGranularity,
-        HandleVisibility::NotVisible);
+    updateSelectionForMouseDownDispatchingSelectStart(innerNode, selection,
+                                                      CharacterGranularity);
     return false;
   }
 
   if (visiblePos.isNull()) {
     updateSelectionForMouseDownDispatchingSelectStart(
-        innerNode, VisibleSelectionInFlatTree(), CharacterGranularity,
-        HandleVisibility::NotVisible);
+        innerNode, VisibleSelectionInFlatTree(), CharacterGranularity);
     return false;
   }
 
-  bool isHandleVisible = false;
-  if (hasEditableStyle(*innerNode)) {
-    const bool isTextBoxEmpty =
-        createVisibleSelection(SelectionInFlatTree::Builder()
-                                   .selectAllChildren(*innerNode)
-                                   .build())
-            .isCaret();
-    const bool notLeftClick = event.event().pointerProperties().button !=
-                              WebPointerProperties::Button::Left;
-    if (!isTextBoxEmpty || notLeftClick)
-      isHandleVisible = event.event().fromTouch();
-  }
-
   updateSelectionForMouseDownDispatchingSelectStart(
       innerNode,
       expandSelectionToRespectUserSelectAll(
           innerNode, createVisibleSelection(
                          SelectionInFlatTree::Builder()
                              .collapse(visiblePos.toPositionWithAffinity())
                              .build())),
-      CharacterGranularity, isHandleVisible ? HandleVisibility::Visible
-                                            : HandleVisibility::NotVisible);
+      CharacterGranularity);
   return false;
 }
 
 void SelectionController::updateSelectionForMouseDrag(
     const HitTestResult& hitTestResult,
     Node* mousePressNode,
     const LayoutPoint& dragStartPos,
     const IntPoint& lastKnownMousePosition) {
   if (!m_mouseDownMayStartSelect)
     return;
@@ skipping 109 matching lines @@
   // |newSelection|.
   if (selection().granularity() != CharacterGranularity) {
     newSelection = createVisibleSelection(
         SelectionInFlatTree::Builder()
             .setBaseAndExtent(newSelection.base(), newSelection.extent())
             .setGranularity(selection().granularity())
             .build());
   }
 
   setNonDirectionalSelectionIfNeeded(newSelection, selection().granularity(),
-                                     AdjustEndpointsAtBidiBoundary,
-                                     HandleVisibility::NotVisible);
+                                     AdjustEndpointsAtBidiBoundary);
 }
 
 bool SelectionController::updateSelectionForMouseDownDispatchingSelectStart(
     Node* targetNode,
     const VisibleSelectionInFlatTree& selection,
-    TextGranularity granularity,
-    HandleVisibility handleVisibility) {
+    TextGranularity granularity) {
   if (targetNode && targetNode->layoutObject() &&
       !targetNode->layoutObject()->isSelectable())
     return false;
 
   if (dispatchSelectStart(targetNode) != DispatchEventResult::NotCanceled)
     return false;
 
   // |dispatchSelectStart()| can change document hosted by |m_frame|.
   if (!this->selection().isAvailable())
     return false;
 
   if (!selection.isValidFor(this->selection().document()))
     return false;
 
   if (selection.isRange()) {
     m_selectionState = SelectionState::ExtendedSelection;
   } else {
     granularity = CharacterGranularity;
     m_selectionState = SelectionState::PlacedCaret;
   }
 
   setNonDirectionalSelectionIfNeeded(selection, granularity,
-                                     DoNotAdjustEndpoints, handleVisibility);
+                                     DoNotAdjustEndpoints);
 
   return true;
 }
 
 bool SelectionController::selectClosestWordFromHitTestResult(
     const HitTestResult& result,
     AppendTrailingWhitespace appendTrailingWhitespace,
     SelectInputEventType selectInputEventType) {
   Node* innerNode = result.innerNode();
   VisibleSelectionInFlatTree newSelection;
@@ skipping 13 matching lines @@
   const VisiblePositionInFlatTree& pos =
       visiblePositionOfHitTestResult(adjustedHitTestResult);
   if (pos.isNotNull()) {
     newSelection =
         createVisibleSelection(SelectionInFlatTree::Builder()
                                    .collapse(pos.toPositionWithAffinity())
                                    .setGranularity(WordGranularity)
                                    .build());
   }
 
-  HandleVisibility visibility = HandleVisibility::NotVisible;
   if (selectInputEventType == SelectInputEventType::Touch) {
     // If node doesn't have text except space, tab or line break, do not
     // select that 'empty' area.
     EphemeralRangeInFlatTree range(newSelection.start(), newSelection.end());
     const String& str =
         plainText(range, hasEditableStyle(*innerNode)
                              ? TextIteratorEmitsObjectReplacementCharacter
                              : TextIteratorDefaultBehavior);
     if (str.isEmpty() || str.simplifyWhiteSpace().containsOnlyWhitespace())
       return false;
 
     if (newSelection.rootEditableElement() &&
         pos.deepEquivalent() ==
             VisiblePositionInFlatTree::lastPositionInNode(
                 newSelection.rootEditableElement())
                 .deepEquivalent())
       return false;
-
-    visibility = HandleVisibility::Visible;
   }
 
   if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend)
     newSelection.appendTrailingWhitespace();
 
   return updateSelectionForMouseDownDispatchingSelectStart(
       innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection),
-      WordGranularity, visibility);
+      WordGranularity);
 }
 
 void SelectionController::selectClosestMisspellingFromHitTestResult(
     const HitTestResult& result,
     AppendTrailingWhitespace appendTrailingWhitespace) {
   Node* innerNode = result.innerNode();
   VisibleSelectionInFlatTree newSelection;
 
   if (!innerNode || !innerNode->layoutObject())
     return;
@@ skipping 13 matching lines @@
       newSelection = createVisibleSelection(
           SelectionInFlatTree::Builder().collapse(start).extend(end).build());
     }
   }
 
   if (appendTrailingWhitespace == AppendTrailingWhitespace::ShouldAppend)
     newSelection.appendTrailingWhitespace();
 
   updateSelectionForMouseDownDispatchingSelectStart(
       innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection),
-      WordGranularity, HandleVisibility::NotVisible);
+      WordGranularity);
 }
 
 void SelectionController::selectClosestWordFromMouseEvent(
     const MouseEventWithHitTestResults& result) {
   if (!m_mouseDownMayStartSelect)
     return;
 
   AppendTrailingWhitespace appendTrailingWhitespace =
       (result.event().clickCount() == 2 &&
        m_frame->editor().isSelectTrailingWhitespaceEnabled())
@@ skipping 36 matching lines @@
   const VisiblePositionInFlatTree pos =
       visiblePositionOfHitTestResult(result.hitTestResult());
   if (pos.isNotNull() &&
       pos.deepEquivalent().anchorNode()->isDescendantOf(URLElement)) {
     newSelection = createVisibleSelection(
         SelectionInFlatTree::Builder().selectAllChildren(*URLElement).build());
   }
 
   updateSelectionForMouseDownDispatchingSelectStart(
       innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection),
-      WordGranularity, HandleVisibility::NotVisible);
+      WordGranularity);
 }
 
 // TODO(xiaochengh): We should not use reference to return value.
 static void adjustEndpointsAtBidiBoundary(
     VisiblePositionInFlatTree& visibleBase,
     VisiblePositionInFlatTree& visibleExtent) {
   DCHECK(visibleBase.isValid());
   DCHECK(visibleExtent.isValid());
 
   RenderedPosition base(visibleBase);
@@ skipping 37 matching lines @@
           base.rightBoundaryOfBidiRun(extent.bidiLevelOnLeft()))) {
     visibleExtent = createVisiblePosition(
         toPositionInFlatTree(extent.positionAtRightBoundaryOfBiDiRun()));
     return;
   }
 }
 
 void SelectionController::setNonDirectionalSelectionIfNeeded(
     const VisibleSelectionInFlatTree& passedNewSelection,
     TextGranularity granularity,
-    EndPointsAdjustmentMode endpointsAdjustmentMode,
-    HandleVisibility handleVisibility) {
+    EndPointsAdjustmentMode endpointsAdjustmentMode) {
   VisibleSelectionInFlatTree newSelection = passedNewSelection;
   bool isDirectional =
       m_frame->editor().behavior().shouldConsiderSelectionAsDirectional() ||
       newSelection.isDirectional();
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   const PositionInFlatTree& basePosition =
@@ skipping 19 matching lines @@
     newSelection.setExtent(newExtent);
   } else if (originalBase.isNotNull()) {
     if (selection().visibleSelection<EditingInFlatTreeStrategy>().base() ==
         newSelection.base())
       newSelection.setBase(originalBase);
     m_originalBaseInFlatTree = VisiblePositionInFlatTree();
   }
 
   // Adjusting base and extent will make newSelection always directional
   newSelection.setIsDirectional(isDirectional);
-  const bool isHandleVisible = handleVisibility == HandleVisibility::Visible;
-  if (selection().visibleSelection<EditingInFlatTreeStrategy>() ==
-          newSelection &&
-      selection().isHandleVisible() == isHandleVisible)
+  if (selection().visibleSelection<EditingInFlatTreeStrategy>() == newSelection)
     return;
 
   const FrameSelection::SetSelectionOptions options =
-      isHandleVisible
-          ? FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle |
-                FrameSelection::HandleVisible
-          : FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle;
-
+      FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle;
   selection().setSelection(newSelection, options, CursorAlignOnScroll::IfNeeded,
                            granularity);
 }
 
 void SelectionController::setCaretAtHitTestResult(
     const HitTestResult& hitTestResult) {
   Node* innerNode = hitTestResult.innerNode();
   const VisiblePositionInFlatTree& visibleHitPos =
       visiblePositionOfHitTestResult(hitTestResult);
   const VisiblePositionInFlatTree& visiblePos =
       visibleHitPos.isNull()
           ? createVisiblePosition(
                 PositionInFlatTree::firstPositionInOrBeforeNode(innerNode))
           : visibleHitPos;
 
   updateSelectionForMouseDownDispatchingSelectStart(
       innerNode,
       expandSelectionToRespectUserSelectAll(
           innerNode, createVisibleSelection(
                          SelectionInFlatTree::Builder()
                              .collapse(visiblePos.toPositionWithAffinity())
                              .build())),
-      CharacterGranularity, HandleVisibility::Visible);
+      CharacterGranularity);
 }
 
 bool SelectionController::handleMousePressEventDoubleClick(
     const MouseEventWithHitTestResults& event) {
   TRACE_EVENT0("blink",
                "SelectionController::handleMousePressEventDoubleClick");
 
   if (!selection().isAvailable())
     return false;
 
@@ skipping 42 matching lines @@
   const VisiblePositionInFlatTree& pos =
       visiblePositionOfHitTestResult(event.hitTestResult());
   if (pos.isNotNull()) {
     newSelection =
         createVisibleSelection(SelectionInFlatTree::Builder()
                                    .collapse(pos.toPositionWithAffinity())
                                    .setGranularity(ParagraphGranularity)
                                    .build());
   }
 
-  const bool isHandleVisible =
-      event.event().fromTouch() && newSelection.isRange();
-
   return updateSelectionForMouseDownDispatchingSelectStart(
       innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection),
-      ParagraphGranularity, isHandleVisible ? HandleVisibility::Visible
-                                            : HandleVisibility::NotVisible);
+      ParagraphGranularity);
 }
 
 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()) || isLinkSelection(event)) &&
       !event.scrollbar();
   m_mouseDownWasSingleClickInSelection = false;
@@ skipping 272 matching lines @@
   return event.event().altKey() && event.isOverLink();
 }
 
 bool isExtendingSelection(const MouseEventWithHitTestResults& event) {
   bool isMouseDownOnLinkOrImage =
       event.isOverLink() || event.hitTestResult().image();
   return event.event().shiftKey() && !isMouseDownOnLinkOrImage;
 }
 
 }  // namespace blink