Slop region check for multi-finger scroll

ui/events/gesture_detection/gesture_detector.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/gesture_detection/gesture_detector.h"
 
 #include <stddef.h>
@@ skipping 112 matching lines @@
       touch_slop_square_(0),
       double_tap_touch_slop_square_(0),
       double_tap_slop_square_(0),
       two_finger_tap_distance_square_(0),
       min_fling_velocity_(1),
       max_fling_velocity_(1),
       min_swipe_velocity_(0),
       min_swipe_direction_component_ratio_(0),
       still_down_(false),
       defer_confirm_single_tap_(false),
-      always_in_tap_region_(false),
+      all_pointers_always_in_tap_region_(false),
       always_in_bigger_tap_region_(false),
       two_finger_tap_allowed_for_gesture_(false),
       is_double_tapping_(false),
       is_down_candidate_for_repeated_single_tap_(false),
+      maximum_pointer_count_(0),
       current_single_tap_repeat_count_(0),
       single_tap_repeat_interval_(1),
       last_focus_x_(0),
       last_focus_y_(0),
       down_focus_x_(0),
       down_focus_y_(0),
       longpress_enabled_(true),
       showpress_enabled_(true),
       swipe_enabled_(false),
       two_finger_tap_enabled_(false),
@@ skipping 31 matching lines @@
     case MotionEvent::ACTION_NONE:
       NOTREACHED();
       return handled;
 
     case MotionEvent::ACTION_POINTER_DOWN: {
       down_focus_x_ = last_focus_x_ = focus_x;
       down_focus_y_ = last_focus_y_ = focus_y;
       // Cancel long press and taps.
       CancelTaps();
 
+      //Update maximum pointer count

[tdresser, 2016/06/10 19:34:57]

// Update maximum pointer count.

Note the space before "Update" and the period.

I'd say we can probably just get rid of this comment though, it should be clear
from the code.

[sahel, 2016/06/23 22:34:44]

Done.

+      int current_pointer_count = ev.GetPointerCount();
+      if(current_pointer_count > maximum_pointer_count_)
+        maximum_pointer_count_ = current_pointer_count;

[tdresser, 2016/06/10 19:34:57]

maximum_pointer_count_ = std::max(maximum_pointer_count_, ev.GetPointerCount());

[sahel, 2016/06/23 22:34:43]

Done.

+
+      // Even when two_finger_tap_allowed_for_gesture_ is false,
+      // second pointer down information must be stored to check
+      // the slop region in multi-finger scrolls.
+      if(ev.GetPointerCount() == 2)
+        secondary_pointer_down_event_ = ev.Clone();
+
       if (!two_finger_tap_allowed_for_gesture_)
         break;
 
       const int action_index = ev.GetActionIndex();
       const float dx = ev.GetX(action_index) - current_down_event_->GetX();
       const float dy = ev.GetY(action_index) - current_down_event_->GetY();
 
-      if (ev.GetPointerCount() == 2 &&
-          dx * dx + dy * dy < two_finger_tap_distance_square_) {
-        secondary_pointer_down_event_ = ev.Clone();
-      } else {
+      if (ev.GetPointerCount() != 2 || maximum_pointer_count_ > 2 ||

[tdresser, 2016/06/10 19:34:57]

Is the first part of this clause necessary? Couldn't we ignore the current
pointer count, and instead just look at the maximum?

[sahel, 2016/06/23 22:34:43]

You are right, if the current count is not two, the maximum has been  updated
and is greater than 2 as well. 

I left it like this, to make it easier to understand, I'll remove the first
phrase of the condition.

+          dx * dx + dy * dy >= two_finger_tap_distance_square_)
         two_finger_tap_allowed_for_gesture_ = false;
-      }
     } break;
 
     case MotionEvent::ACTION_POINTER_UP: {
       down_focus_x_ = last_focus_x_ = focus_x;
       down_focus_y_ = last_focus_y_ = focus_y;
 
       // Check the dot product of current velocities.
       // If the pointer that left was opposing another velocity vector, clear.
       velocity_tracker_.ComputeCurrentVelocity(1000, max_fling_velocity_);
       const int up_index = ev.GetActionIndex();
@@ skipping 53 matching lines @@
         }
       } else {
         is_down_candidate_for_repeated_single_tap_ = is_repeated_tap;
       }
 
       down_focus_x_ = last_focus_x_ = focus_x;
       down_focus_y_ = last_focus_y_ = focus_y;
       current_down_event_ = ev.Clone();
 
       secondary_pointer_down_event_.reset();
-      always_in_tap_region_ = true;
+      all_pointers_always_in_tap_region_ = true;
       always_in_bigger_tap_region_ = true;
       still_down_ = true;
       defer_confirm_single_tap_ = false;
       two_finger_tap_allowed_for_gesture_ = two_finger_tap_enabled_;
+      maximum_pointer_count_ = 1;
 
       // Always start the SHOW_PRESS timer before the LONG_PRESS timer to ensure
       // proper timeout ordering.
       if (showpress_enabled_)
         timeout_handler_->StartTimeout(SHOW_PRESS);
       if (longpress_enabled_)
         timeout_handler_->StartTimeout(LONG_PRESS);
       handled |= listener_->OnDown(ev);
     } break;
 
     case MotionEvent::ACTION_MOVE:
       {
         const float scroll_x = last_focus_x_ - focus_x;
         const float scroll_y = last_focus_y_ - focus_y;
         if (is_double_tapping_) {
           // Give the move events of the double-tap.
           DCHECK(double_tap_listener_);
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
-        } else if (always_in_tap_region_) {
-          const float delta_x = focus_x - down_focus_x_;
-          const float delta_y = focus_y - down_focus_y_;
-          const float distance_square = delta_x * delta_x + delta_y * delta_y;
-          if (distance_square > touch_slop_square_) {
+        } else if (all_pointers_always_in_tap_region_) {
+          if (!IsWithinTouchSlop(ev)) {
             handled = listener_->OnScroll(
                 *current_down_event_, ev, scroll_x, scroll_y);
             last_focus_x_ = focus_x;
             last_focus_y_ = focus_y;
-            always_in_tap_region_ = false;
+            all_pointers_always_in_tap_region_ = false;
             timeout_handler_->Stop();
           }
+
+          const float delta_x = focus_x - down_focus_x_;
+          const float delta_y = focus_y - down_focus_y_;
+          const float distance_square = delta_x * delta_x + delta_y * delta_y;
           if (distance_square > double_tap_touch_slop_square_)
             always_in_bigger_tap_region_ = false;
         } else if (std::abs(scroll_x) > kScrollEpsilon ||
                    std::abs(scroll_y) > kScrollEpsilon) {
-          // We should eventually apply touch slop for multi-finger
-          // scrolls as well as single finger scrolls. See
-          // crbug.com/492185 for details.
           handled =
               listener_->OnScroll(*current_down_event_, ev, scroll_x, scroll_y);
           last_focus_x_ = focus_x;
           last_focus_y_ = focus_y;
         }
 
         if (!two_finger_tap_allowed_for_gesture_)
           break;
 
         // Two-finger tap should be prevented if either pointer exceeds its
         // (independent) slop region.
-        const int id0 = current_down_event_->GetPointerId(0);
-        const int ev_idx0 = ev.GetPointerId(0) == id0 ? 0 : 1;
-
-        // Check if the primary pointer exceeded the slop region.
-        float dx = current_down_event_->GetX() - ev.GetX(ev_idx0);
-        float dy = current_down_event_->GetY() - ev.GetY(ev_idx0);
-        if (dx * dx + dy * dy > touch_slop_square_) {
+        // If the event has had more than two pointers down at any time,
+        // two finger tap should be prevented.
+        if (maximum_pointer_count_ > 2 || !IsWithinTouchSlop(ev)) {
           two_finger_tap_allowed_for_gesture_ = false;
-          break;
-        }
-        if (ev.GetPointerCount() == 2) {
-          // Check if the secondary pointer exceeded the slop region.
-          const int ev_idx1 = ev_idx0 == 0 ? 1 : 0;
-          const int idx1 = secondary_pointer_down_event_->GetActionIndex();
-          dx = secondary_pointer_down_event_->GetX(idx1) - ev.GetX(ev_idx1);
-          dy = secondary_pointer_down_event_->GetY(idx1) - ev.GetY(ev_idx1);
-          if (dx * dx + dy * dy > touch_slop_square_)
-            two_finger_tap_allowed_for_gesture_ = false;
         }
       }
       break;
 
     case MotionEvent::ACTION_UP:
       still_down_ = false;
       {
         if (is_double_tapping_) {
           // Finally, give the up event of the double-tap.
           DCHECK(double_tap_listener_);
           handled |= double_tap_listener_->OnDoubleTapEvent(ev);
-        } else if (always_in_tap_region_) {
+        } else if (all_pointers_always_in_tap_region_ &&
+                   maximum_pointer_count_ == 1) {
           if (is_down_candidate_for_repeated_single_tap_) {
             current_single_tap_repeat_count_ =
                 (1 + current_single_tap_repeat_count_) %
                 single_tap_repeat_interval_;
           } else {
             current_single_tap_repeat_count_ = 0;
           }
           handled = listener_->OnSingleTapUp(
               ev, 1 + current_single_tap_repeat_count_);
           if (defer_confirm_single_tap_ && double_tap_listener_ != NULL) {
@@ skipping 17 matching lines @@
         }
 
         previous_up_event_ = ev.Clone();
 
         velocity_tracker_.Clear();
         is_double_tapping_ = false;
         defer_confirm_single_tap_ = false;
         timeout_handler_->StopTimeout(SHOW_PRESS);
         timeout_handler_->StopTimeout(LONG_PRESS);
       }
+      maximum_pointer_count_ = 0;
       break;
 
     case MotionEvent::ACTION_CANCEL:
       Cancel();
       break;
   }
 
   return handled;
 }
 
@@ skipping 65 matching lines @@
     CHECK(previous_up_event_);
     double_tap_listener_->OnSingleTapConfirmed(*previous_up_event_);
   } else {
     defer_confirm_single_tap_ = true;
   }
 }
 
 void GestureDetector::Cancel() {
   CancelTaps();
   velocity_tracker_.Clear();
+  all_pointers_always_in_tap_region_ = false;
   still_down_ = false;
 }
 
 void GestureDetector::CancelTaps() {
   timeout_handler_->Stop();
   is_double_tapping_ = false;
-  always_in_tap_region_ = false;
   always_in_bigger_tap_region_ = false;
   defer_confirm_single_tap_ = false;
   is_down_candidate_for_repeated_single_tap_ = false;
   current_single_tap_repeat_count_ = 0;
 }
 
 bool GestureDetector::IsRepeatedTap(const MotionEvent& first_down,
                                     const MotionEvent& first_up,
                                     const MotionEvent& second_down) const {
   if (!always_in_bigger_tap_region_)
@@ skipping 35 matching lines @@
   if (ratio < min_swipe_direction_component_ratio_)
     return false;
 
   if (vx_abs > vy_abs)
     vy = 0;
   else
     vx = 0;
   return listener_->OnSwipe(*current_down_event_, up, vx, vy);
 }
 
+bool GestureDetector::IsWithinTouchSlop(const MotionEvent& ev) {
+  // If there are more than two down pointers, tapping is not possible.
+  // Slop region check is not needed.
+  if (ev.GetPointerCount() > 2)
+    return false;
+
+  const int id0 = current_down_event_->GetPointerId(0);
+  const int ev_idx0 = ev.GetPointerId(0) == id0 ? 0 : 1;
+
+  // Check if the primary pointer exceeded the slop region.
+  float dx = current_down_event_->GetX() - ev.GetX(ev_idx0);
+  float dy = current_down_event_->GetY() - ev.GetY(ev_idx0);
+  if (dx * dx + dy * dy > touch_slop_square_)
+    return false;
+
+  if (ev.GetPointerCount() == 2 ) {
+    // Check if the secondary pointer exceeded the slop region.
+    const int ev_idx1 = ev_idx0 == 0 ? 1 : 0;
+    const int idx1 = secondary_pointer_down_event_->GetActionIndex();
+    dx = secondary_pointer_down_event_->GetX(idx1) - ev.GetX(ev_idx1);
+    dy = secondary_pointer_down_event_->GetY(idx1) - ev.GetY(ev_idx1);
+    if (dx * dx + dy * dy > touch_slop_square_) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 }  // namespace ui