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"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_detection/gesture_event_data.h"
 #include "ui/events/gesture_detection/motion_event.h"
+#include "ui/gfx/geometry/point_f.h"
 
 namespace ui {
 namespace {
 
 // Double-tap drag zoom sensitivity (speed).
 const float kDoubleTapDragZoomSpeed = 0.005f;
 
 const char* GetMotionEventActionName(MotionEvent::Action action) {
   switch (action) {
     case MotionEvent::ACTION_POINTER_DOWN:
       return "ACTION_POINTER_DOWN";
     case MotionEvent::ACTION_POINTER_UP:
       return "ACTION_POINTER_UP";
     case MotionEvent::ACTION_DOWN:
       return "ACTION_DOWN";
     case MotionEvent::ACTION_UP:
       return "ACTION_UP";
     case MotionEvent::ACTION_CANCEL:
       return "ACTION_CANCEL";
     case MotionEvent::ACTION_MOVE:
       return "ACTION_MOVE";
   }
   return "";
 }
 
-gfx::RectF GetBoundingBox(const MotionEvent& event) {
-  // Can't use gfx::RectF::Union, as it ignores touches with a radius of 0.
-  float left = std::numeric_limits<float>::max();
-  float top = std::numeric_limits<float>::max();
-  float right = -std::numeric_limits<float>::max();
-  float bottom = -std::numeric_limits<float>::max();
-  for (size_t i = 0; i < event.GetPointerCount(); ++i) {
-    float diameter = event.GetTouchMajor(i);
-    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);
-}
-
-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) {
-  return GestureEventData(details,
-                          motion_event_id,
-                          primary_tool_type,
-                          time,
-                          x,
-                          y,
-                          raw_x,
-                          raw_y,
-                          touch_point_count,
-                          bounding_box);
-}
-
-GestureEventData CreateGesture(EventType type,
-                               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) {
-  return GestureEventData(GestureEventDetails(type, 0, 0),
-                          motion_event_id,
-                          primary_tool_type,
-                          time,
-                          x,
-                          y,
-                          raw_x,
-                          raw_y,
-                          touch_point_count,
-                          bounding_box);
-}
-
-GestureEventData CreateGesture(const GestureEventDetails& details,
-                               const MotionEvent& event) {
-  return GestureEventData(details,
-                          event.GetId(),
-                          event.GetToolType(),
-                          event.GetEventTime(),
-                          event.GetX(),
-                          event.GetY(),
-                          event.GetRawX(),
-                          event.GetRawY(),
-                          event.GetPointerCount(),
-                          GetBoundingBox(event));
-}
-
-GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
-  return CreateGesture(GestureEventDetails(type, 0, 0), event);
-}
-
-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) {
   float width = bounds.width();
   float height = bounds.height();
   if (min_length) {
     width = std::max(min_length, width);
     height = std::max(min_length, height);
   }
   if (max_length) {
@@ skipping 30 matching lines @@
   GestureListenerImpl(const GestureProvider::Config& config,
                       GestureProviderClient* client)
       : config_(config),
         client_(client),
         gesture_detector_(config.gesture_detector_config, this, this),
         scale_gesture_detector_(config.scale_gesture_detector_config, this),
         snap_scroll_controller_(config.display),
         ignore_multitouch_zoom_events_(false),
         ignore_single_tap_(false),
         pinch_event_sent_(false),
-        scroll_event_sent_(false) {}
+        scroll_event_sent_(false),
+        max_diameter_before_show_press_(0),
+        show_press_event_sent_(false) {}
 
   void OnTouchEvent(const MotionEvent& event) {
     const bool in_scale_gesture = IsScaleGestureDetectionInProgress();
     snap_scroll_controller_.SetSnapScrollingMode(event, in_scale_gesture);
     if (in_scale_gesture)
       SetIgnoreSingleTap(true);
 
     const MotionEvent::Action action = event.GetAction();
     if (action == MotionEvent::ACTION_DOWN) {
       current_down_time_ = event.GetEventTime();
       current_longpress_time_ = base::TimeTicks();
       ignore_single_tap_ = false;
       scroll_event_sent_ = false;
       pinch_event_sent_ = false;
+      show_press_event_sent_ = false;
       gesture_detector_.set_longpress_enabled(true);
+      tap_down_point_ = gfx::PointF(event.GetX(), event.GetY());
+      max_diameter_before_show_press_ = event.GetTouchMajor();
     }
 
     gesture_detector_.OnTouchEvent(event);
     scale_gesture_detector_.OnTouchEvent(event);
 
     if (action == MotionEvent::ACTION_UP ||
         action == MotionEvent::ACTION_CANCEL) {
       // Note: This call will have no effect if a fling was just generated, as
       // |Fling()| will have already signalled an end to touch-scrolling.
       if (scroll_event_sent_)
         Send(CreateGesture(ET_GESTURE_SCROLL_END, event));
       current_down_time_ = base::TimeTicks();
+    } else if (action == MotionEvent::ACTION_MOVE) {
+      if (!show_press_event_sent_ && !scroll_event_sent_)

[tdresser, 2014/09/08 15:52:47]

I prefer adding {} when the body of a conditional is more than 1 line long.

[lanwei, 2014/09/08 16:14:52]

Done.

+        max_diameter_before_show_press_ =
+            std::max(max_diameter_before_show_press_, event.GetTouchMajor());
     }
   }
 
   void Send(GestureEventData gesture) {
     DCHECK(!gesture.time.is_null());
     // The only valid events that should be sent without an active touch
     // sequence are SHOW_PRESS and TAP, potentially triggered by the double-tap
     // delay timing out.
     DCHECK(!current_down_time_.is_null() || gesture.type() == ET_GESTURE_TAP ||
            gesture.type() == ET_GESTURE_SHOW_PRESS ||
@@ skipping 76 matching lines @@
     if (!pinch_event_sent_) {
       Send(CreateGesture(ET_GESTURE_PINCH_BEGIN,
                          e.GetId(),
                          e.GetToolType(),
                          detector.GetEventTime(),
                          detector.GetFocusX(),
                          detector.GetFocusY(),
                          detector.GetFocusX() + e.GetRawOffsetX(),
                          detector.GetFocusY() + e.GetRawOffsetY(),
                          e.GetPointerCount(),
-                         GetBoundingBox(e)));
+                         GetBoundingBox(e, ET_GESTURE_PINCH_BEGIN)));
     }
 
     if (std::abs(detector.GetCurrentSpan() - detector.GetPreviousSpan()) <
         config_.scale_gesture_detector_config.min_pinch_update_span_delta) {
       return false;
     }
 
     float scale = detector.GetScaleFactor();
     if (scale == 1)
       return true;
@@ skipping 13 matching lines @@
     GestureEventDetails pinch_details(ET_GESTURE_PINCH_UPDATE, scale, 0);
     Send(CreateGesture(pinch_details,
                        e.GetId(),
                        e.GetToolType(),
                        detector.GetEventTime(),
                        detector.GetFocusX(),
                        detector.GetFocusY(),
                        detector.GetFocusX() + e.GetRawOffsetX(),
                        detector.GetFocusY() + e.GetRawOffsetY(),
                        e.GetPointerCount(),
-                       GetBoundingBox(e)));
+                       GetBoundingBox(e, pinch_details.type())));
     return true;
   }
 
   // GestureDetector::GestureListener implementation.
   virtual bool OnDown(const MotionEvent& e) OVERRIDE {
     GestureEventDetails tap_details(ET_GESTURE_TAP_DOWN, 0, 0);
     Send(CreateGesture(tap_details, e));
 
     // Return true to indicate that we want to handle touch.
     return true;
@@ skipping 29 matching lines @@
       // used to determine which layer the scroll should affect.
       Send(CreateGesture(scroll_details,
                          e2.GetId(),
                          e2.GetToolType(),
                          e2.GetEventTime(),
                          e1.GetX(),
                          e1.GetY(),
                          e1.GetRawX(),
                          e1.GetRawY(),
                          e2.GetPointerCount(),
-                         GetBoundingBox(e2)));
+                         GetBoundingBox(e2, scroll_details.type())));
       DCHECK(scroll_event_sent_);
     }
 
     snap_scroll_controller_.UpdateSnapScrollMode(distance_x, distance_y);
     if (snap_scroll_controller_.IsSnappingScrolls()) {
       if (snap_scroll_controller_.IsSnapHorizontal())
         distance_y = 0;
       else
         distance_x = 0;
     }
 
     if (distance_x || distance_y) {
-      const gfx::RectF bounding_box = GetBoundingBox(e2);
+      GestureEventDetails scroll_details(
+          ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
+      const gfx::RectF bounding_box = GetBoundingBox(e2, scroll_details.type());
       const gfx::PointF center = bounding_box.CenterPoint();
       const gfx::PointF raw_center =
           center + gfx::Vector2dF(e2.GetRawOffsetX(), e2.GetRawOffsetY());
-      GestureEventDetails scroll_details(
-          ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
       Send(CreateGesture(scroll_details,
                          e2.GetId(),
                          e2.GetToolType(),
                          e2.GetEventTime(),
                          center.x(),
                          center.y(),
                          raw_center.x(),
                          raw_center.y(),
                          e2.GetPointerCount(),
                          bounding_box));
@@ skipping 49 matching lines @@
         ET_GESTURE_TWO_FINGER_TAP, e1.GetTouchMajor(), e1.GetTouchMajor());
     Send(CreateGesture(two_finger_tap_details,
                        e2.GetId(),
                        e2.GetToolType(),
                        e2.GetEventTime(),
                        e1.GetX(),
                        e1.GetY(),
                        e1.GetRawX(),
                        e1.GetRawY(),
                        e2.GetPointerCount(),
-                       GetBoundingBox(e2)));
+                       GetBoundingBox(e2, two_finger_tap_details.type())));
     return true;
   }
 
   virtual void OnShowPress(const MotionEvent& e) OVERRIDE {
     GestureEventDetails show_press_details(ET_GESTURE_SHOW_PRESS, 0, 0);
+    show_press_event_sent_ = true;
     Send(CreateGesture(show_press_details, e));
   }
 
   virtual bool OnSingleTapUp(const MotionEvent& e) 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.
@@ skipping 61 matching lines @@
     return false;
   }
 
   virtual void OnLongPress(const MotionEvent& e) OVERRIDE {
     DCHECK(!IsDoubleTapInProgress());
     SetIgnoreSingleTap(true);
     GestureEventDetails long_press_details(ET_GESTURE_LONG_PRESS, 0, 0);
     Send(CreateGesture(long_press_details, e));
   }
 
+  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) {
+    return GestureEventData(details,
+                            motion_event_id,
+                            primary_tool_type,
+                            time,
+                            x,
+                            y,
+                            raw_x,
+                            raw_y,
+                            touch_point_count,
+                            bounding_box);
+  }
+
+  GestureEventData CreateGesture(EventType type,
+                                 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) {
+    return GestureEventData(GestureEventDetails(type, 0, 0),
+                            motion_event_id,
+                            primary_tool_type,
+                            time,
+                            x,
+                            y,
+                            raw_x,
+                            raw_y,
+                            touch_point_count,
+                            bounding_box);
+  }
+
+  GestureEventData CreateGesture(const GestureEventDetails& details,
+                                 const MotionEvent& event) {
+    return GestureEventData(details,
+                            event.GetId(),
+                            event.GetToolType(),
+                            event.GetEventTime(),
+                            event.GetX(),
+                            event.GetY(),
+                            event.GetRawX(),
+                            event.GetRawY(),
+                            event.GetPointerCount(),
+                            GetBoundingBox(event, details.type()));
+  }
+
+  GestureEventData CreateGesture(EventType type, const MotionEvent& event) {
+    return CreateGesture(GestureEventDetails(type, 0, 0), event);
+  }
+
+  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 GetBoundingBox(const MotionEvent& event, EventType type) {
+    // Can't use gfx::RectF::Union, as it ignores touches with a radius of 0.
+    float left = std::numeric_limits<float>::max();
+    float top = std::numeric_limits<float>::max();
+    float right = -std::numeric_limits<float>::max();
+    float bottom = -std::numeric_limits<float>::max();
+    for (size_t i = 0; i < event.GetPointerCount(); ++i) {
+      float x, y, diameter;
+      // Only for the show press and tap events, the bounding box is calculated
+      // based on the touch start point and the maximum diameter before the
+      // show press event is sent.
+      if (type == ET_GESTURE_SHOW_PRESS || type == ET_GESTURE_TAP ||
+          type == ET_GESTURE_TAP_UNCONFIRMED) {
+        DCHECK_EQ(0U, i);
+        diameter = max_diameter_before_show_press_;
+        x = tap_down_point_.x();
+        y = tap_down_point_.y();
+      } else {
+        diameter = event.GetTouchMajor(i);
+        x = event.GetX(i);
+        y = event.GetY(i);
+      }
+      x = x - diameter / 2;
+      y = y - 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);
+  }
+
   void SetDoubleTapEnabled(bool enabled) {
     DCHECK(!IsDoubleTapInProgress());
     gesture_detector_.SetDoubleTapListener(enabled ? this : NULL);
   }
 
   void SetMultiTouchZoomEnabled(bool enabled) {
     // Note that returning false from |OnScaleBegin()| or |OnScale()| prevents
     // the detector from emitting further scale updates for the current touch
     // sequence. Thus, if multitouch events are enabled in the middle of a
     // gesture, it will only take effect with the next gesture.
@@ skipping 45 matching lines @@
   // TODO(klobag): This is to avoid a bug in GestureDetector. With multi-touch,
   // always_in_tap_region_ is not reset. So when the last finger is up,
   // |OnSingleTapUp()| will be mistakenly fired.
   bool ignore_single_tap_;
 
   // Tracks whether {PINCH|SCROLL}_BEGIN events have been forwarded for the
   // current touch sequence.
   bool pinch_event_sent_;
   bool scroll_event_sent_;
 
+  // Only track the maximum diameter before the show press event has been
+  // sent and there must be a tap event happening afterwards.

[tdresser, 2014/09/08 15:52:47]

It isn't that a tap event must happen afterwards, its that a tap must still be
possible for this touch sequence.

[lanwei, 2014/09/08 16:14:52]

Thanks. 
Done.

+  float max_diameter_before_show_press_;
+
+  gfx::PointF tap_down_point_;
+
+  // Tracks whether an ET_GESTURE_SHOW_PRESS event has been sent for this touch
+  // sequence.
+  bool show_press_event_sent_;
+
   DISALLOW_COPY_AND_ASSIGN(GestureListenerImpl);
 };
 
 // GestureProvider
 
 GestureProvider::GestureProvider(const Config& config,
                                  GestureProviderClient* client)
     : double_tap_support_for_page_(true),
       double_tap_support_for_platform_(true),
       gesture_begin_end_types_enabled_(config.gesture_begin_end_types_enabled) {
@@ skipping 63 matching lines @@
   // events.
   return current_down_event_ || event.GetAction() == MotionEvent::ACTION_DOWN ||
          event.GetAction() == MotionEvent::ACTION_CANCEL;
 }
 
 void GestureProvider::OnTouchEventHandlingBegin(const MotionEvent& event) {
   switch (event.GetAction()) {
     case MotionEvent::ACTION_DOWN:
       current_down_event_ = event.Clone();
       if (gesture_begin_end_types_enabled_)
-        gesture_listener_->Send(CreateGesture(ET_GESTURE_BEGIN, event));
+        gesture_listener_->Send(
+            gesture_listener_->CreateGesture(ET_GESTURE_BEGIN, event));
       break;
     case MotionEvent::ACTION_POINTER_DOWN:
       if (gesture_begin_end_types_enabled_) {
         const int action_index = event.GetActionIndex();
-        gesture_listener_->Send(CreateGesture(ET_GESTURE_BEGIN,
-                                              event.GetId(),
-                                              event.GetToolType(),
-                                              event.GetEventTime(),
-                                              event.GetX(action_index),
-                                              event.GetY(action_index),
-                                              event.GetRawX(action_index),
-                                              event.GetRawY(action_index),
-                                              event.GetPointerCount(),
-                                              GetBoundingBox(event)));
+        gesture_listener_->Send(gesture_listener_->CreateGesture(
+            ET_GESTURE_BEGIN,
+            event.GetId(),
+            event.GetToolType(),
+            event.GetEventTime(),
+            event.GetX(action_index),
+            event.GetY(action_index),
+            event.GetRawX(action_index),
+            event.GetRawY(action_index),
+            event.GetPointerCount(),
+            gesture_listener_->GetBoundingBox(event, ET_GESTURE_BEGIN)));
       }
       break;
     case MotionEvent::ACTION_POINTER_UP:
     case MotionEvent::ACTION_UP:
     case MotionEvent::ACTION_CANCEL:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
 void GestureProvider::OnTouchEventHandlingEnd(const MotionEvent& event) {
   switch (event.GetAction()) {
     case MotionEvent::ACTION_UP:
     case MotionEvent::ACTION_CANCEL: {
       if (gesture_begin_end_types_enabled_)
-        gesture_listener_->Send(CreateGesture(ET_GESTURE_END, event));
+        gesture_listener_->Send(
+            gesture_listener_->CreateGesture(ET_GESTURE_END, event));
 
       current_down_event_.reset();
 
       UpdateDoubleTapDetectionSupport();
       break;
     }
     case MotionEvent::ACTION_POINTER_UP:
       if (gesture_begin_end_types_enabled_)
-        gesture_listener_->Send(CreateGesture(ET_GESTURE_END, event));
+        gesture_listener_->Send(
+            gesture_listener_->CreateGesture(ET_GESTURE_END, event));
       break;
     case MotionEvent::ACTION_DOWN:
     case MotionEvent::ACTION_POINTER_DOWN:
     case MotionEvent::ACTION_MOVE:
       break;
   }
 }
 
 void GestureProvider::UpdateDoubleTapDetectionSupport() {
   // The GestureDetector requires that any provided DoubleTapListener remain
   // attached to it for the duration of a touch sequence. Defer any potential
   // 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