Prepare for Unified Gesture Recognizer landing in Aura

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 338 matching lines @@
                                     e2.GetId(),
                                     e2.GetEventTime(),
                                     e1.GetX(),
                                     e1.GetY(),
                                     e2.GetPointerCount(),
                                     GetBoundingBox(e2),
                                     scroll_details));
     }
 
     if (distance_x || distance_y) {
+      const gfx::RectF& bounding_box = GetBoundingBox(e2);

[jdduke (slow), 2014/05/29 16:25:40]

Wait, why are capturing a variable returned by value with a ref? What you had
looked OK.

[tdresser, 2014/05/30 14:05:37]

Done.

       GestureEventDetails scroll_details(
           ET_GESTURE_SCROLL_UPDATE, -distance_x, -distance_y);
-      provider_->Send(
-          CreateGesture(ET_GESTURE_SCROLL_UPDATE, e2, scroll_details));
+      provider_->Send(CreateGesture(ET_GESTURE_SCROLL_UPDATE,
+                                    e2.GetId(),
+                                    e2.GetEventTime(),
+                                    bounding_box.CenterPoint().x(),
+                                    bounding_box.CenterPoint().y(),
+                                    e2.GetPointerCount(),
+                                    bounding_box,
+                                    scroll_details));
     }
 
     return true;
   }
 
   virtual bool OnFling(const MotionEvent& e1,
                        const MotionEvent& e2,
                        float velocity_x,
                        float velocity_y) OVERRIDE {
     if (snap_scroll_controller_.IsSnappingScrolls()) {
@@ skipping 268 matching lines @@
   }
   EndTouchScrollIfNecessary(event, false);
 
   GestureEventDetails fling_details(
       ET_SCROLL_FLING_START, velocity_x, velocity_y);
   Send(CreateGesture(
       ET_SCROLL_FLING_START, event, fling_details));
 }
 
 void GestureProvider::Send(const 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_event_ || gesture.type == ET_GESTURE_TAP ||
          gesture.type == ET_GESTURE_SHOW_PRESS);
 
   switch (gesture.type) {
     case ET_GESTURE_LONG_PRESS:
       DCHECK(!scale_gesture_listener_->IsScaleGestureDetectionInProgress());
       current_longpress_time_ = gesture.time;
@@ skipping 70 matching lines @@
   switch (event.GetAction()) {
     case MotionEvent::ACTION_DOWN:
       current_down_event_ = event.Clone();
       touch_scroll_in_progress_ = false;
       pinch_in_progress_ = false;
       current_longpress_time_ = base::TimeTicks();
       if (gesture_begin_end_types_enabled_)
         Send(CreateGesture(ET_GESTURE_BEGIN, event));
       break;
     case MotionEvent::ACTION_POINTER_DOWN:
-      if (gesture_begin_end_types_enabled_)
-        Send(CreateGesture(ET_GESTURE_BEGIN, event));
+      if (gesture_begin_end_types_enabled_) {
+        Send(CreateGesture(ET_GESTURE_BEGIN,
+                           event.GetId(),
+                           event.GetEventTime(),
+                           event.GetX(event.GetActionIndex()),
+                           event.GetY(event.GetActionIndex()),
+                           event.GetPointerCount(),
+                           GetBoundingBox(event)));
+      }
       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:
+    case 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.
       EndTouchScrollIfNecessary(event, true);
 
-      if (gesture_begin_end_types_enabled_)
-        Send(CreateGesture(ET_GESTURE_END, event));
+      const gfx::RectF& bounding_box = GetBoundingBox(event);
+
+      if (gesture_begin_end_types_enabled_) {
+        for (size_t i = 0; i < event.GetPointerCount(); ++i) {
+          Send(CreateGesture(ET_GESTURE_END,
+                             event.GetId(),
+                             event.GetEventTime(),
+                             event.GetX(i),
+                             event.GetY(i),
+                             event.GetPointerCount() - i,
+                             bounding_box));
+        }
+      }
 
       current_down_event_.reset();
 
       UpdateDoubleTapDetectionSupport();
       break;
+    }
     case MotionEvent::ACTION_POINTER_UP:
       if (gesture_begin_end_types_enabled_)
         Send(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);
   scale_gesture_listener_->SetDoubleTapEnabled(double_tap_enabled);
 }
 
 }  //  namespace ui