Consume entire touch sequence in touch selection controller

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 50 matching lines @@
       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) {
+      selection_handle_dragged_(false),
+      consume_touch_sequence_(false) {
   DCHECK(client_);
 }
 
 TouchSelectionController::~TouchSelectionController() {
 }
 
 void TouchSelectionController::OnSelectionBoundsChanged(
     const gfx::SelectionBound& start,
     const gfx::SelectionBound& end) {
   if (!force_next_update_ && start == start_ && end_ == end)
@@ skipping 89 matching lines @@
     DCHECK(end_selection_handle_);
     start_selection_handle_->SetViewportRect(viewport_rect);
     end_selection_handle_->SetViewportRect(viewport_rect);
   }
 
   // Update handle layout after setting the new Viewport size.
   UpdateHandleLayoutIfNecessary();
 }
 
 bool TouchSelectionController::WillHandleTouchEvent(const MotionEvent& event) {
-  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);
-  }
-
-  if (active_status_ == SELECTION_ACTIVE) {
-    DCHECK(start_selection_handle_);
-    DCHECK(end_selection_handle_);
-    if (start_selection_handle_->IsActive())
-      return start_selection_handle_->WillHandleTouchEvent(event);
-
-    if (end_selection_handle_->IsActive())
-      return end_selection_handle_->WillHandleTouchEvent(event);
-
-    const gfx::PointF event_pos(event.GetX(), event.GetY());
-    if ((event_pos - GetStartPosition()).LengthSquared() <=
-        (event_pos - GetEndPosition()).LengthSquared()) {
-      return start_selection_handle_->WillHandleTouchEvent(event);
-    }
-    return end_selection_handle_->WillHandleTouchEvent(event);
-  }
-
-  return false;
+  bool handled = WillHandleTouchEventImpl(event);
+  // If ACTION_DOWN is consumed, the rest of touch sequence should be consumed,
+  // 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_;
 }
 
 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();
@@ skipping 131 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) {
+  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);
+  }
+
+  if (active_status_ == SELECTION_ACTIVE) {
+    DCHECK(start_selection_handle_);
+    DCHECK(end_selection_handle_);
+    if (start_selection_handle_->IsActive())
+      return start_selection_handle_->WillHandleTouchEvent(event);
+
+    if (end_selection_handle_->IsActive())
+      return end_selection_handle_->WillHandleTouchEvent(event);
+
+    const gfx::PointF event_pos(event.GetX(), event.GetY());
+    if ((event_pos - GetStartPosition()).LengthSquared() <=
+        (event_pos - GetEndPosition()).LengthSquared()) {
+      return start_selection_handle_->WillHandleTouchEvent(event);
+    }
+    return end_selection_handle_->WillHandleTouchEvent(event);
+  }
+
+  return false;
+}
+
 void TouchSelectionController::OnDragBegin(
     const TouchSelectionDraggable& draggable,
     const gfx::PointF& drag_position) {
   if (&draggable == insertion_handle_.get()) {
     DCHECK_EQ(active_status_, INSERTION_ACTIVE);
     client_->OnSelectionEvent(INSERTION_HANDLE_DRAG_STARTED);
     anchor_drag_to_selection_start_ = true;
     return;
   }
 
@@ skipping 324 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