Changing the bounding box for show press and tap gesture

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 <cmath>
@@ skipping 43 matching lines @@
       two_finger_tap_max_separation(300),
       two_finger_tap_timeout(base::TimeDelta::FromMilliseconds(700)) {
 }
 
 GestureDetector::Config::~Config() {}
 
 bool GestureDetector::SimpleGestureListener::OnDown(const MotionEvent& e) {
   return false;
 }
 
-void GestureDetector::SimpleGestureListener::OnShowPress(const MotionEvent& e) {
+void GestureDetector::SimpleGestureListener::OnShowPress(const MotionEvent& e,
+                                                         float max_radius) {
 }
 
-bool GestureDetector::SimpleGestureListener::OnSingleTapUp(
-    const MotionEvent& e) {
+bool GestureDetector::SimpleGestureListener::OnSingleTapUp(const MotionEvent& e,
+                                                           float x,
+                                                           float y,
+                                                           float max_radius) {
   return false;
 }
 
 void GestureDetector::SimpleGestureListener::OnLongPress(const MotionEvent& e) {
 }
 
 bool GestureDetector::SimpleGestureListener::OnScroll(const MotionEvent& e1,
                                                       const MotionEvent& e2,
                                                       float distance_x,
                                                       float distance_y) {
@@ skipping 14 matching lines @@
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnTwoFingerTap(
     const MotionEvent& e1,
     const MotionEvent& e2) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnSingleTapConfirmed(
-    const MotionEvent& e) {
+    const MotionEvent& e,
+    float x,
+    float y,
+    float max_touch_diameter_) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnDoubleTap(const MotionEvent& e) {
   return false;
 }
 
 bool GestureDetector::SimpleGestureListener::OnDoubleTapEvent(
     const MotionEvent& e) {
   return false;
@@ skipping 76 matching lines @@
       swipe_enabled_(false),
       two_finger_tap_enabled_(false) {
   DCHECK(listener_);
   Init(config);
 }
 
 GestureDetector::~GestureDetector() {}
 
 bool GestureDetector::OnTouchEvent(const MotionEvent& ev) {
   const MotionEvent::Action action = ev.GetAction();
-
   velocity_tracker_.AddMovement(ev);
 
   const bool pointer_up = action == MotionEvent::ACTION_POINTER_UP;
   const int skip_index = pointer_up ? ev.GetActionIndex() : -1;
 
   // Determine focal point.
   float sum_x = 0, sum_y = 0;
   const int count = static_cast<int>(ev.GetPointerCount());
   for (int i = 0; i < count; i++) {
     if (skip_index == i)
@@ skipping 95 matching lines @@
       down_focus_y_ = last_focus_y_ = focus_y;
       current_down_event_ = ev.Clone();
 
       secondary_pointer_down_event_.reset();
       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_;
 
+      max_touch_diameter_ = ev.GetTouchMajor();
       // Always start the SHOW_PRESS timer before the LONG_PRESS timer to ensure
       // proper timeout ordering.
       timeout_handler_->StartTimeout(SHOW_PRESS);
       if (longpress_enabled_)
         timeout_handler_->StartTimeout(LONG_PRESS);
       handled |= listener_->OnDown(ev);
       break;
 
     case MotionEvent::ACTION_MOVE:
       {
@@ skipping 18 matching lines @@
           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, scroll_x, scroll_y);
           last_focus_x_ = focus_x;
           last_focus_y_ = focus_y;
         }
 
+        if (timeout_handler_->HasTimeout(SHOW_PRESS)) {
+          max_touch_diameter_ =
+              std::max(max_touch_diameter_, ev.GetTouchMajor());
+        }
+
         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_) {
           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_) {
-          handled = listener_->OnSingleTapUp(ev);
+          handled = listener_->OnSingleTapUp(ev,
+                                             current_down_event_->GetX(),
+                                             current_down_event_->GetY(),
+                                             max_touch_diameter_);
           if (defer_confirm_single_tap_ && double_tap_listener_ != NULL) {
-            double_tap_listener_->OnSingleTapConfirmed(ev);
+            double_tap_listener_->OnSingleTapConfirmed(
+                ev,
+                current_down_event_->GetX(),
+                current_down_event_->GetY(),
+                max_touch_diameter_);
           }
         } else {
 
           // A fling must travel the minimum tap distance.
           const int pointer_id = ev.GetPointerId(0);
           velocity_tracker_.ComputeCurrentVelocity(1000, max_fling_velocity_);
           const float velocity_y = velocity_tracker_.GetYVelocity(pointer_id);
           const float velocity_x = velocity_tracker_.GetXVelocity(pointer_id);
 
           if ((std::abs(velocity_y) > min_fling_velocity_) ||
@@ skipping 65 matching lines @@
   min_swipe_direction_component_ratio_ =
       1.f / tan(maximum_swipe_deviation_angle * kDegreesToRadians);
 
   two_finger_tap_enabled_ = config.two_finger_tap_enabled;
   two_finger_tap_distance_square_ = config.two_finger_tap_max_separation *
                                     config.two_finger_tap_max_separation;
   two_finger_tap_timeout_ = config.two_finger_tap_timeout;
 }
 
 void GestureDetector::OnShowPressTimeout() {
-  listener_->OnShowPress(*current_down_event_);
+  listener_->OnShowPress(*current_down_event_, max_touch_diameter_);
 }
 
 void GestureDetector::OnLongPressTimeout() {
   timeout_handler_->StopTimeout(TAP);
   defer_confirm_single_tap_ = false;
   listener_->OnLongPress(*current_down_event_);
 }
 
 void GestureDetector::OnTapTimeout() {
   if (!double_tap_listener_)
     return;
   if (!still_down_)
-    double_tap_listener_->OnSingleTapConfirmed(*current_down_event_);
+    double_tap_listener_->OnSingleTapConfirmed(*current_down_event_,
+                                               current_down_event_->GetX(),
+                                               current_down_event_->GetY(),
+                                               max_touch_diameter_);
   else
     defer_confirm_single_tap_ = true;
 }
 
 void GestureDetector::Cancel() {
   CancelTaps();
   velocity_tracker_.Clear();
   still_down_ = false;
 }
 
@@ skipping 43 matching lines @@
     return false;
 
   if (vx_abs > vy_abs)
     vy = 0;
   else
     vx = 0;
   return listener_->OnSwipe(*current_down_event_, up, vx, vy);
 }
 
 }  // namespace ui