The helper functions for slop region check and subtraction are modified.

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 288 matching lines @@
         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 (all_pointers_within_slop_regions_) {
           if (!IsWithinTouchSlop(ev)) {
             handled = listener_->OnScroll(
                 *current_down_event_, ev,
-                (ev.GetPointerCount() > 1 ? *secondary_pointer_down_event_
-                                          : ev),
+                (maximum_pointer_count_ > 1 ? *secondary_pointer_down_event_
+                                            : ev),
                 scroll_x, scroll_y);
             last_focus_x_ = focus_x;
             last_focus_y_ = focus_y;
             all_pointers_within_slop_regions_ = 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) {
           handled = listener_->OnScroll(
               *current_down_event_, ev,
-              (ev.GetPointerCount() > 1 ? *secondary_pointer_down_event_ : ev),
+              (maximum_pointer_count_ > 1 ? *secondary_pointer_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.
@@ skipping 193 matching lines @@
     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)
+  // If there have been more than two down pointers in the touch sequence,
+  // tapping is not possible. Slop region check is not needed.
+  if (maximum_pointer_count_ > 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);
+  for (size_t i = 0; i < ev.GetPointerCount(); i++) {
+    const int pid = ev.GetPointerId(i);

[tdresser, 2016/07/22 15:57:45]

Throughout, let's use pointer_id instead of pid, for the sake of clarity.

[sahel, 2016/07/22 19:46:42]

Done.

+    const MotionEvent* source_pointer_down_event = GetSourcePointerDownEvent(
+        *current_down_event_,
+        maximum_pointer_count_ > 1 ? *secondary_pointer_down_event_
+                                   : *current_down_event_,
+        pid);
+    DCHECK(source_pointer_down_event);

[tdresser, 2016/07/22 15:57:45]

Return if source_pointer_down_event is nullptr.

[sahel, 2016/07/22 19:46:42]

Done.

+    int source_index = getPointerIndex(*source_pointer_down_event, pid);
+    DCHECK_GE(source_index, 0);
+    float dx = source_pointer_down_event->GetX(source_index) - ev.GetX(i);

[tdresser, 2016/07/22 15:57:45]

What happens if source_index is 0? Should we return before doing this?

[sahel, 2016/07/22 19:46:42]

I changed the code, an early return will happen if the source_index < 0,
otherwise it should be fine.

+    float dy = source_pointer_down_event->GetY(source_index) - ev.GetY(i);
     if (dx * dx + dy * dy > touch_slop_square_)
       return false;
   }
 
   return true;
 }
 
+const MotionEvent* GestureDetector::GetSourcePointerDownEvent(
+    const MotionEvent& current_down_event,
+    const MotionEvent& secondary_pointer_down_event,
+    const int pid) {
+  if (current_down_event.GetPointerId(0) == pid)
+    return &current_down_event;
+
+  for (size_t i = 0; i < secondary_pointer_down_event.GetPointerCount(); i++) {
+    if (secondary_pointer_down_event.GetPointerId(i) == pid)
+      return &secondary_pointer_down_event;
+  }
+
+  return NULL;

[tdresser, 2016/07/22 15:57:45]

Should this ever happen? If not, maybe we should have a DCHECK.
Return nullptr.

[sahel, 2016/07/22 19:46:42]

Done.

+}
+
+int GestureDetector::getPointerIndex(const MotionEvent& event, const int pid) {
+  for (size_t i = 0; i < event.GetPointerCount(); i++) {
+    if (event.GetPointerId(i) == pid)
+      return i;
+  }
+  return -1;

[tdresser, 2016/07/22 15:57:45]

Should this case ever happen? Should we have a DCHECK here (as well as the
caller)?

[sahel, 2016/07/22 19:46:42]

Done.

+}
+
 }  // namespace ui