Revert "Blink handle selection handle visibility"

ui/touch_selection/touch_selection_controller.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/touch_selection/touch_selection_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
@@ skipping 38 matching lines @@
       enable_longpress_drag_selection(false) {}
 
 TouchSelectionController::Config::~Config() {
 }
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client,
     const Config& config)
     : client_(client),
       config_(config),
+      force_next_update_(false),
       response_pending_input_event_(INPUT_EVENT_TYPE_NONE),
       start_orientation_(TouchHandleOrientation::UNDEFINED),
       end_orientation_(TouchHandleOrientation::UNDEFINED),
       active_status_(INACTIVE),
+      activate_insertion_automatically_(false),
+      activate_selection_automatically_(false),
+      selection_empty_(false),
+      selection_editable_(false),
       temporarily_hidden_(false),
       anchor_drag_to_selection_start_(false),
       longpress_drag_selector_(this),
       selection_handle_dragged_(false),
-      consume_touch_sequence_(false),
-      show_touch_handles_(true)
-{
+      consume_touch_sequence_(false) {
   DCHECK(client_);
 }
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
     const gfx::SelectionBound& start,
     const gfx::SelectionBound& end) {
-  if (start == start_ && end_ == end)
+  if (!force_next_update_ && start == start_ && end_ == end)
     return;
 
-  if (start.type() == gfx::SelectionBound::EMPTY ||
-      end.type() == gfx::SelectionBound::EMPTY ||
-      !show_touch_handles_) {
-    HideHandles();
-    return;
+  // Notify if selection bounds have just been established or dissolved.
+  if (start.type() != gfx::SelectionBound::EMPTY &&
+      start_.type() == gfx::SelectionBound::EMPTY) {
+    client_->OnSelectionEvent(SELECTION_ESTABLISHED);
+  } else if (start.type() == gfx::SelectionBound::EMPTY &&
+             start_.type() != gfx::SelectionBound::EMPTY) {
+    client_->OnSelectionEvent(SELECTION_DISSOLVED);
   }
 
   // Swap the Handles when the start and end selection points cross each other.
   if (active_status_ == SELECTION_ACTIVE) {
     if ((start_selection_handle_->IsActive() &&
          end_.edge_bottom() == start.edge_bottom()) ||
         (end_selection_handle_->IsActive() &&
          end.edge_bottom() == start_.edge_bottom())) {
       start_selection_handle_.swap(end_selection_handle_);
     }
   }
 
   start_ = start;
   end_ = end;
   start_orientation_ = ToTouchHandleOrientation(start_.type());
   end_orientation_ = ToTouchHandleOrientation(end_.type());
+  force_next_update_ = false;
+
+  if (!activate_selection_automatically_ &&
+      !activate_insertion_automatically_) {
+    DCHECK_EQ(INACTIVE, active_status_);
+    DCHECK_EQ(INPUT_EVENT_TYPE_NONE, response_pending_input_event_);
+    return;
+  }
 
   // Ensure that |response_pending_input_event_| is cleared after the method
   // completes, while also making its current value available for the duration
   // of the call.
   InputEventType causal_input_event = response_pending_input_event_;
   response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
   base::AutoReset<InputEventType> auto_reset_response_pending_input_event(
       &response_pending_input_event_, causal_input_event);
 
   const bool is_selection_dragging = active_status_ == SELECTION_ACTIVE &&
@@ skipping 10 matching lines @@
   }
 
   if (GetStartPosition() != GetEndPosition() ||
       (is_selection_dragging &&
        start_orientation_ != TouchHandleOrientation::UNDEFINED &&
        end_orientation_ != TouchHandleOrientation::UNDEFINED)) {
     OnSelectionChanged();
     return;
   }
 
-  if (start_orientation_ == TouchHandleOrientation::CENTER) {
+  if (start_orientation_ == TouchHandleOrientation::CENTER &&
+      selection_editable_) {
     OnInsertionChanged();
     return;
   }
 
-  HideHandles();
+  HideAndDisallowShowingAutomatically();
 }
 
 void TouchSelectionController::OnViewportChanged(
     const gfx::RectF viewport_rect) {
   // Trigger a force update if the viewport is changed, so that
   // it triggers a call to change the mirror values if required.
   if (viewport_rect_ == viewport_rect)
     return;
 
   viewport_rect_ = viewport_rect;
@@ skipping 21 matching lines @@
   // too, regardless of value of |handled|.
   // TODO(mohsen): This will consume touch events until the next ACTION_DOWN.
   // Ideally we should consume until the final ACTION_UP/ACTION_CANCEL.
   // But, apparently, we can't reliably determine the final ACTION_CANCEL in a
   // multi-touch scenario. See https://crbug.com/653212.
   if (event.GetAction() == MotionEvent::ACTION_DOWN)
     consume_touch_sequence_ = handled;
   return handled || consume_touch_sequence_;
 }
 
-void TouchSelectionController::HandleTapEvent(const gfx::PointF& location,
+bool TouchSelectionController::WillHandleTapEvent(const gfx::PointF& location,
                                                   int tap_count) {
+  if (WillHandleTapOrLongPress(location))
+    return true;
+
   if (tap_count > 1) {
     response_pending_input_event_ = REPEATED_TAP;
+    ShowSelectionHandlesAutomatically();
   } else {
     response_pending_input_event_ = TAP;
+    if (active_status_ != SELECTION_ACTIVE)
+      activate_selection_automatically_ = false;
   }
+  ShowInsertionHandleAutomatically();
+  if (selection_empty_)
+    DeactivateInsertion();
+  ForceNextUpdateIfInactive();
+  return false;
 }
 
-void TouchSelectionController::HandleLongPressEvent(
+bool TouchSelectionController::WillHandleLongPressEvent(
     base::TimeTicks event_time,
     const gfx::PointF& location) {
+  if (WillHandleTapOrLongPress(location))
+    return true;
+
   longpress_drag_selector_.OnLongPressEvent(event_time, location);
   response_pending_input_event_ = LONG_PRESS;
+  ShowSelectionHandlesAutomatically();
+  ShowInsertionHandleAutomatically();
+  ForceNextUpdateIfInactive();
+  return false;
 }
 
 void TouchSelectionController::OnScrollBeginEvent() {
   // When there is an active selection, if the user performs a long-press that
   // does not trigger a new selection (e.g. a long-press on an empty area) and
   // then scrolls, the scroll will move the selection. In this case we will
   // think incorrectly that the selection change was due to the long-press and
   // will activate touch selection and start long-press drag gesture (see
   // ActivateInsertionIfNecessary()). To prevent this, we need to reset the
   // state of touch selection controller and long-press drag selector.
   // TODO(mohsen): Remove this workaround when we have enough information about
   // the cause of a selection change (see https://crbug.com/571897).
   longpress_drag_selector_.OnScrollBeginEvent();
   response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
+  if (active_status_ == INACTIVE) {
+    activate_insertion_automatically_ = false;
+    activate_selection_automatically_ = false;
+  }
 }
 
-void TouchSelectionController::HideHandles() {
+void TouchSelectionController::AllowShowingFromCurrentSelection() {
+  if (active_status_ != INACTIVE)
+    return;
+
+  activate_selection_automatically_ = true;
+  activate_insertion_automatically_ = true;
+  if (GetStartPosition() != GetEndPosition()) {
+    OnSelectionChanged();
+  } else if (start_orientation_ == TouchHandleOrientation::CENTER &&
+             selection_editable_) {
+    OnInsertionChanged();
+  }
+}
+
+void TouchSelectionController::HideAndDisallowShowingAutomatically() {
   response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
   DeactivateInsertion();
   DeactivateSelection();
-  start_ = gfx::SelectionBound();
-  end_ = gfx::SelectionBound();
-  start_orientation_ = ToTouchHandleOrientation(start_.type());
-  end_orientation_ = ToTouchHandleOrientation(end_.type());
-}
-
-void TouchSelectionController::HideAndDisallowShowingAutomatically() {
-  HideHandles();
-  show_touch_handles_ = false;
+  activate_insertion_automatically_ = false;
+  activate_selection_automatically_ = false;
 }
 
 void TouchSelectionController::SetTemporarilyHidden(bool hidden) {
   if (temporarily_hidden_ == hidden)
     return;
   temporarily_hidden_ = hidden;
   RefreshHandleVisibility();
 }
 
+void TouchSelectionController::OnSelectionEditable(bool editable) {
+  if (selection_editable_ == editable)
+    return;
+  selection_editable_ = editable;
+  ForceNextUpdateIfInactive();
+  if (!selection_editable_)
+    DeactivateInsertion();
+}
+
+void TouchSelectionController::OnSelectionEmpty(bool empty) {
+  if (selection_empty_ == empty)
+    return;
+  selection_empty_ = empty;
+  ForceNextUpdateIfInactive();
+}
+
 bool TouchSelectionController::Animate(base::TimeTicks frame_time) {
   if (active_status_ == INSERTION_ACTIVE)
     return insertion_handle_->Animate(frame_time);
 
   if (active_status_ == SELECTION_ACTIVE) {
     bool needs_animate = start_selection_handle_->Animate(frame_time);
     needs_animate |= end_selection_handle_->Animate(frame_time);
     return needs_animate;
   }
 
@@ skipping 34 matching lines @@
 const gfx::PointF& TouchSelectionController::GetStartPosition() const {
   return start_.edge_bottom();
 }
 
 const gfx::PointF& TouchSelectionController::GetEndPosition() const {
   return end_.edge_bottom();
 }
 
 bool TouchSelectionController::WillHandleTouchEventImpl(
     const MotionEvent& event) {
-  show_touch_handles_ = true;
   if (config_.enable_longpress_drag_selection &&
       longpress_drag_selector_.WillHandleTouchEvent(event)) {
     return true;
   }
 
   if (active_status_ == INSERTION_ACTIVE) {
     DCHECK(insertion_handle_);
     return insertion_handle_->WillHandleTouchEvent(event);
   }
 
@@ skipping 114 matching lines @@
 }
 
 gfx::PointF TouchSelectionController::GetSelectionStart() const {
   return GetStartPosition();
 }
 
 gfx::PointF TouchSelectionController::GetSelectionEnd() const {
   return GetEndPosition();
 }
 
+void TouchSelectionController::ShowInsertionHandleAutomatically() {
+  if (activate_insertion_automatically_)
+    return;
+  activate_insertion_automatically_ = true;
+  ForceNextUpdateIfInactive();
+}
+
+void TouchSelectionController::ShowSelectionHandlesAutomatically() {
+  if (activate_selection_automatically_)
+    return;
+  activate_selection_automatically_ = true;
+  ForceNextUpdateIfInactive();
+}
+
+bool TouchSelectionController::WillHandleTapOrLongPress(
+    const gfx::PointF& location) {
+  // If there is an active selection that was not triggered by a user gesture,
+  // allow showing the handles for that selection if a gesture occurs within
+  // the selection rect. Note that this hit test is at best a crude
+  // approximation, and may swallow taps that actually fall outside the
+  // real selection.
+  if (active_status_ == INACTIVE &&
+      GetStartPosition() != GetEndPosition() &&
+      RectFBetweenSelectionBounds(start_, end_).Contains(location)) {
+    AllowShowingFromCurrentSelection();
+    return true;
+  }
+  return false;
+}
+
 void TouchSelectionController::OnInsertionChanged() {
   DeactivateSelection();
 
+  if ((response_pending_input_event_ == TAP ||
+       response_pending_input_event_ == REPEATED_TAP) &&
+      selection_empty_) {
+    HideAndDisallowShowingAutomatically();
+    return;
+  }
+
+  if (!activate_insertion_automatically_)
+    return;
+
   const bool activated = ActivateInsertionIfNecessary();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(!activated);
   insertion_handle_->SetFocus(start_.edge_top(), start_.edge_bottom());
   insertion_handle_->SetVisible(GetStartVisible(), animation);
 
   UpdateHandleLayoutIfNecessary();
 
   client_->OnSelectionEvent(activated ? INSERTION_HANDLE_SHOWN
                                       : INSERTION_HANDLE_MOVED);
 }
 
 void TouchSelectionController::OnSelectionChanged() {
   DeactivateInsertion();
 
+  if (!activate_selection_automatically_)
+    return;
+
   const bool activated = ActivateSelectionIfNecessary();
 
   const TouchHandle::AnimationStyle animation = GetAnimationStyle(!activated);
 
   start_selection_handle_->SetFocus(start_.edge_top(), start_.edge_bottom());
   end_selection_handle_->SetFocus(end_.edge_top(), end_.edge_bottom());
 
   start_selection_handle_->SetOrientation(start_orientation_);
   end_selection_handle_->SetOrientation(end_orientation_);
 
@@ skipping 78 matching lines @@
   DCHECK(start_selection_handle_);
   DCHECK(end_selection_handle_);
   LogSelectionEnd();
   longpress_drag_selector_.OnSelectionDeactivated();
   start_selection_handle_->SetEnabled(false);
   end_selection_handle_->SetEnabled(false);
   active_status_ = INACTIVE;
   client_->OnSelectionEvent(SELECTION_HANDLES_CLEARED);
 }
 
+void TouchSelectionController::ForceNextUpdateIfInactive() {
+  // Only force the update if the reported selection is non-empty but still
+  // considered "inactive", i.e., it wasn't preceded by a user gesture or
+  // the handles have since been explicitly hidden.
+  if (active_status_ == INACTIVE &&
+      start_.type() != gfx::SelectionBound::EMPTY &&
+      end_.type() != gfx::SelectionBound::EMPTY) {
+    force_next_update_ = true;
+  }
+}
+
 void TouchSelectionController::UpdateHandleLayoutIfNecessary() {
   if (active_status_ == INSERTION_ACTIVE) {
     DCHECK(insertion_handle_);
     insertion_handle_->UpdateHandleLayout();
   } else if (active_status_ == SELECTION_ACTIVE) {
     DCHECK(start_selection_handle_);
     DCHECK(end_selection_handle_);
     start_selection_handle_->UpdateHandleLayout();
     end_selection_handle_->UpdateHandleLayout();
   }
@@ skipping 50 matching lines @@
     base::TimeDelta duration = base::TimeTicks::Now() - selection_start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES("Event.TouchSelection.WasDraggedDuration",
                                duration,
                                base::TimeDelta::FromMilliseconds(500),
                                base::TimeDelta::FromSeconds(60),
                                60);
   }
 }
 
 }  // namespace ui