Changing the bounding box for show press and tap gesture

ui/events/gesture_detection/gesture_provider.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/events/gesture_detection/gesture_provider.h"
 
 #include <cmath>
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
@@ skipping 36 matching lines @@
     float x = event.GetX(i) - diameter / 2;
     float y = event.GetY(i) - diameter / 2;
     left = std::min(left, x);
     right = std::max(right, x + diameter);
     top = std::min(top, y);
     bottom = std::max(bottom, y + diameter);
   }
   return gfx::RectF(left, top, right - left, bottom - top);
 }
 
+gfx::RectF GetBoundingBox(float x, float y, float max_diameter) {
+  // Can't use gfx::RectF::Union, as it ignores touches with a radius of 0.
+  float left = x - max_diameter / 2;
+  float top = y - max_diameter / 2;
+  return gfx::RectF(left, top, max_diameter, max_diameter);
+}
+
 GestureEventData CreateGesture(const GestureEventDetails& details,
                                int motion_event_id,
                                MotionEvent::ToolType primary_tool_type,
                                base::TimeTicks time,
                                float x,
                                float y,
                                float raw_x,
                                float raw_y,
                                size_t touch_point_count,
                                const gfx::RectF& bounding_box) {
@@ skipping 42 matching lines @@
                           event.GetRawX(),
                           event.GetRawY(),
                           event.GetPointerCount(),
                           GetBoundingBox(event));
 }
 
 GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
   return CreateGesture(GestureEventDetails(type, 0, 0), event);
 }
 
+GestureEventData CreateGesture(const GestureEventDetails& details,

[tdresser, 2014/09/04 13:54:00]

Hmmm, I don't really like adding even more |CreateGesture| methods.

We need to figure out a way to clean these up.

One possibility is to have the GestureProvider tell the GestureListenerImpl
about the current max radius and current_down_event_.

Then if we moved CreateGesture and GetBoundingBox into the GestureListenerImpl,
and gave GetBoundingBox a parameter indicating the gesture type, then
GetBoundingBox could calculate the bounding box correctly for all gesture types.

That feels a little ugly though.

Any other ideas?

Jared, any thoughts?

+                               const MotionEvent& event,
+                               float max_diameter) {
+  return GestureEventData(
+      details,
+      event.GetId(),
+      event.GetToolType(),
+      event.GetEventTime(),
+      event.GetX(),
+      event.GetY(),
+      event.GetRawX(),
+      event.GetRawY(),
+      event.GetPointerCount(),
+      GetBoundingBox(event.GetX(), event.GetY(), max_diameter));
+}
+
+GestureEventData CreateGesture(const GestureEventDetails& details,
+                               const MotionEvent& event,
+                               float x,
+                               float y,
+                               float max_diameter) {
+  return GestureEventData(details,
+                          event.GetId(),
+                          event.GetToolType(),
+                          event.GetEventTime(),
+                          event.GetX(),
+                          event.GetY(),
+                          event.GetRawX(),
+                          event.GetRawY(),
+                          event.GetPointerCount(),
+                          GetBoundingBox(x, y, max_diameter));
+}
+
+GestureEventData CreateTapGesture(EventType type,
+                                  const MotionEvent& event,
+                                  float x,
+                                  float y,
+                                  float max_diameter) {
+  return CreateGesture(
+      GestureEventDetails(type, 1, 0), event, x, y, max_diameter);
+}
+
 GestureEventData CreateTapGesture(EventType type, const MotionEvent& event) {
   // Set the tap count to 1 even for ET_GESTURE_DOUBLE_TAP, in order to be
   // consistent with double tap behavior on a mobile viewport. See
   // crbug.com/234986 for context.
   return CreateGesture(GestureEventDetails(type, 1, 0), event);
 }
 
 gfx::RectF ClampBoundingBox(const gfx::RectF& bounds,
                             float min_length,
                             float max_length) {
@@ skipping 336 matching lines @@
                        e2.GetEventTime(),
                        e1.GetX(),
                        e1.GetY(),
                        e1.GetRawX(),
                        e1.GetRawY(),
                        e2.GetPointerCount(),
                        GetBoundingBox(e2)));
     return true;
   }
 
-  virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
+  virtual void OnShowPress(const MotionEvent& e, float max_diameter) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
-    Send(CreateGesture(show_press_details, e));
+    Send(CreateGesture(show_press_details, e, max_diameter));
   }
 
-  virtual bool OnSingleTapUp(const MotionEvent& e) OVERRIDE {
+  virtual bool OnSingleTapUp(const MotionEvent& e,
+                             float x,
+                             float y,
+                             float max_diameter) OVERRIDE {
     // This is a hack to address the issue where user hovers
     // over a link for longer than double_tap_timeout_, then
     // OnSingleTapConfirmed() is not triggered. But we still
     // want to trigger the tap event at UP. So we override
     // OnSingleTapUp() in this case. This assumes singleTapUp
     // gets always called before singleTapConfirmed.
     if (!ignore_single_tap_) {
       if (e.GetEventTime() - current_down_time_ >
           config_.gesture_detector_config.double_tap_timeout) {
-        return OnSingleTapConfirmed(e);
+        return OnSingleTapConfirmed(e, x, y, max_diameter);
       } else if (!IsDoubleTapEnabled() || config_.disable_click_delay) {
         // If double-tap has been disabled, there is no need to wait
         // for the double-tap timeout.
-        return OnSingleTapConfirmed(e);
+        return OnSingleTapConfirmed(e, x, y, max_diameter);
       } else {
         // Notify Blink about this tapUp event anyway, when none of the above
         // conditions applied.
-        Send(CreateTapGesture(ET_GESTURE_TAP_UNCONFIRMED, e));
+        Send(CreateTapGesture(
+            ET_GESTURE_TAP_UNCONFIRMED, e, x, y, max_diameter));

[tdresser, 2014/09/04 13:54:01]

Add a space to line up with "Create"

       }
     }
 
     if (e.GetAction() == MotionEvent::ACTION_UP &&
         !current_longpress_time_.is_null() &&
         !IsScaleGestureDetectionInProgress()) {
       GestureEventDetails long_tap_details(ET_GESTURE_LONG_TAP, 0, 0);
       Send(CreateGesture(long_tap_details, e));
       return true;
     }
 
     return false;
   }
 
   // GestureDetector::DoubleTapListener implementation.
-  virtual bool OnSingleTapConfirmed(const MotionEvent& e) OVERRIDE {
+  virtual bool OnSingleTapConfirmed(const MotionEvent& e,
+                                    float x,
+                                    float y,
+                                    float max_diameter) OVERRIDE {
     // Long taps in the edges of the screen have their events delayed by
     // ContentViewHolder for tab swipe operations. As a consequence of the delay
     // this method might be called after receiving the up event.
     // These corner cases should be ignored.
     if (ignore_single_tap_)
       return true;
 
     ignore_single_tap_ = true;
 
-    Send(CreateTapGesture(ET_GESTURE_TAP, e));
+    Send(CreateTapGesture(ET_GESTURE_TAP, e, x, y, max_diameter));
     return true;
   }
 
   virtual bool OnDoubleTap(const MotionEvent& e) OVERRIDE {
     return scale_gesture_detector_.OnDoubleTap(e);
   }
 
   virtual bool OnDoubleTapEvent(const MotionEvent& e) OVERRIDE {
     switch (e.GetAction()) {
       case MotionEvent::ACTION_DOWN:
@@ skipping 221 matching lines @@
   // null'ing of the listener until the sequence has ended.
   if (current_down_event_)
     return;
 
   const bool double_tap_enabled =
       double_tap_support_for_page_ && double_tap_support_for_platform_;
   gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui