[Android] Perform haptic feedback after long press when appropriate

content/browser/renderer_host/input/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 "content/browser/renderer_host/input/touch_selection_controller.h"
 
+#include "base/auto_reset.h"
 #include "base/logging.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 namespace content {
 
 TouchSelectionController::TouchSelectionController(
     TouchSelectionControllerClient* client)
     : client_(client),
-      last_input_event_type_(INPUT_EVENT_TYPE_NONE),
+      response_pending_input_event_(INPUT_EVENT_TYPE_NONE),
       start_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
       start_visible_(false),
       end_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
       end_visible_(false),
       is_insertion_active_(false),
       activate_insertion_automatically_(false),
       is_selection_active_(false),
       activate_selection_automatically_(false),
       selection_empty_(false),
       selection_editable_(false),
       temporarily_hidden_(false) {
   DCHECK(client_);
   HideAndDisallowShowingAutomatically();
 }
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
     const gfx::RectF& start_rect,
     TouchHandleOrientation start_orientation,
     bool start_visible,
     const gfx::RectF& end_rect,
     TouchHandleOrientation end_orientation,
     bool end_visible) {
-  if (!activate_selection_automatically_ && !activate_insertion_automatically_)
+  if (!activate_selection_automatically_ &&
+      !activate_insertion_automatically_) {
+    DCHECK_EQ(INPUT_EVENT_TYPE_NONE, response_pending_input_event_);
     return;
+  }
 
   if (start_rect_ == start_rect && end_rect_ == end_rect &&
       start_orientation_ == start_orientation &&
       end_orientation_ == end_orientation && start_visible_ == start_visible &&
       end_visible_ == end_visible)
     return;
 
   start_rect_ = start_rect;
   start_orientation_ = start_orientation;
   start_visible_ = start_visible;
   end_rect_ = end_rect;
   end_orientation_ = end_orientation;
   end_visible_ = end_visible;
 
+  // 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 =
       is_selection_active_ && (start_selection_handle_->is_dragging() ||
                                end_selection_handle_->is_dragging());
 
   // It's possible that the bounds temporarily overlap while a selection handle
   // is being dragged, incorrectly reporting a CENTER orientation.
   // TODO(jdduke): This safeguard is racy, as it's possible the delayed response
   // from handle positioning occurs *after* the handle dragging has ceased.
   // Instead, prevent selection -> insertion transitions without an intervening
   // action or selection clearing of some sort, crbug.com/392696.
@@ skipping 43 matching lines @@
         (event_pos - GetEndPosition()).LengthSquared())
       return start_selection_handle_->WillHandleTouchEvent(event);
     else
       return end_selection_handle_->WillHandleTouchEvent(event);
   }
 
   return false;
 }
 
 void TouchSelectionController::OnLongPressEvent() {
-  last_input_event_type_ = LONG_PRESS;
+  response_pending_input_event_ = LONG_PRESS;
   ShowSelectionHandlesAutomatically();
   ShowInsertionHandleAutomatically();
   ResetCachedValuesIfInactive();
 }
 
 void TouchSelectionController::OnTapEvent() {
-  last_input_event_type_ = TAP;
+  response_pending_input_event_ = TAP;
   activate_selection_automatically_ = false;
   DeactivateSelection();
   ShowInsertionHandleAutomatically();
   ResetCachedValuesIfInactive();
 }
 
 void TouchSelectionController::HideAndDisallowShowingAutomatically() {
-  last_input_event_type_ = INPUT_EVENT_TYPE_NONE;
+  response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
   DeactivateInsertion();
   DeactivateSelection();
   activate_insertion_automatically_ = false;
   activate_selection_automatically_ = false;
 }
 
 void TouchSelectionController::SetTemporarilyHidden(bool hidden) {
   if (temporarily_hidden_ == hidden)
     return;
   temporarily_hidden_ = hidden;
@@ skipping 95 matching lines @@
 void TouchSelectionController::ShowSelectionHandlesAutomatically() {
   if (activate_selection_automatically_)
     return;
   activate_selection_automatically_ = true;
   ResetCachedValuesIfInactive();
 }
 
 void TouchSelectionController::OnInsertionChanged() {
   DeactivateSelection();
 
-  if (last_input_event_type_ == TAP && selection_empty_) {
+  if (response_pending_input_event_ == TAP && selection_empty_) {
     HideAndDisallowShowingAutomatically();
     return;
   }
 
   if (!activate_insertion_automatically_)
     return;
 
   const bool was_active = is_insertion_active_;
   const gfx::PointF position = GetStartPosition();
   if (!is_insertion_active_)
@@ skipping 55 matching lines @@
     start_selection_handle_->SetOrientation(start_orientation_);
   }
 
   if (!end_selection_handle_) {
     end_selection_handle_.reset(new TouchHandle(this, end_orientation_));
   } else {
     end_selection_handle_->SetEnabled(true);
     end_selection_handle_->SetOrientation(end_orientation_);
   }
 
-  if (!is_selection_active_) {
+  // As a long press received while a selection is already active may trigger
+  // an entirely new selection, notify the client but avoid sending an
+  // intervening SELECTION_CLEARED update to avoid unnecessary state changes.
+  if (!is_selection_active_ || response_pending_input_event_ == LONG_PRESS) {
     is_selection_active_ = true;
+    response_pending_input_event_ = INPUT_EVENT_TYPE_NONE;
     client_->OnSelectionEvent(SELECTION_SHOWN, GetStartPosition());
   }
 }
 
 void TouchSelectionController::DeactivateSelection() {
   if (!is_selection_active_)
     return;
   DCHECK(start_selection_handle_);
   DCHECK(end_selection_handle_);
   start_selection_handle_->SetEnabled(false);
@@ skipping 38 matching lines @@
 }
 
 TouchHandle::AnimationStyle TouchSelectionController::GetAnimationStyle(
     bool was_active) const {
   return was_active && client_->SupportsAnimation()
              ? TouchHandle::ANIMATION_SMOOTH
              : TouchHandle::ANIMATION_NONE;
 }
 
 }  // namespace content