This patch implements Chromium's Aura gesture recognizer in terms of utouch-grail and utouch-frame …

ui/aura/gestures/gesture_sequence.cc

 // Copyright (c) 2012 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/aura/gestures/gesture_sequence.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "ui/aura/event.h"
@@ skipping 291 matching lines @@
 }
 
 void GestureSequence::AppendTapDownGestureEvent(const GesturePoint& point,
                                                 Gestures* gestures) {
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_TAP_DOWN,
       point.first_touch_position().x(),
       point.first_touch_position().y(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0.f, 0.f)));
+      GestureEvent::Properties())));
 }
 
 void GestureSequence::AppendClickGestureEvent(const GesturePoint& point,
                                               Gestures* gestures) {
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_TAP,
       point.first_touch_position().x(),
       point.first_touch_position().y(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0.f, 0.f)));
+      GestureEvent::Properties())));
 }
 
 void GestureSequence::AppendDoubleClickGestureEvent(const GesturePoint& point,
                                                     Gestures* gestures) {
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_DOUBLE_TAP,
       point.first_touch_position().x(),
       point.first_touch_position().y(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0.f, 0.f)));
+      GestureEvent::Properties())));
 }
 
 void GestureSequence::AppendScrollGestureBegin(const GesturePoint& point,
                                                const gfx::Point& location,
                                                Gestures* gestures) {
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_SCROLL_BEGIN,
       location.x(),
       location.y(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0.f, 0.f)));
+      GestureEvent::Properties())));
 }
 
 void GestureSequence::AppendScrollGestureEnd(const GesturePoint& point,
                                              const gfx::Point& location,
                                              Gestures* gestures,
                                              float x_velocity,
                                              float y_velocity) {
   float railed_x_velocity = x_velocity;
   float railed_y_velocity = y_velocity;
 
   if (scroll_type_ == ST_HORIZONTAL)
     railed_y_velocity = 0;
   else if (scroll_type_ == ST_VERTICAL)
     railed_x_velocity = 0;
 
+  GestureEvent::Properties props;
+  props.delta_x = railed_x_velocity;
+  props.delta_y = railed_y_velocity;
+
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_SCROLL_END,
       location.x(),
       location.y(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      railed_x_velocity, railed_y_velocity)));
+      props)));
 }
 
 void GestureSequence::AppendScrollGestureUpdate(const GesturePoint& point,
                                                 const gfx::Point& location,
                                                 Gestures* gestures) {
   int dx = point.x_delta();
   int dy = point.y_delta();
 
   if (scroll_type_ == ST_HORIZONTAL)
     dy = 0;
   else if (scroll_type_ == ST_VERTICAL)
     dx = 0;
 
+  GestureEvent::Properties props;
+  props.delta_x = dx;
+  props.delta_y = dy;
+
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_SCROLL_UPDATE,
       location.x(),
       location.y(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      dx, dy)));
+      props)));
 }
 
 void GestureSequence::AppendPinchGestureBegin(const GesturePoint& p1,
                                               const GesturePoint& p2,
                                               Gestures* gestures) {
   gfx::Point center = p1.last_touch_position().Middle(p2.last_touch_position());
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_PINCH_BEGIN,
       center.x(),
       center.y(),
       flags_,
       base::Time::FromDoubleT(p1.last_touch_time()),
-      0.f, 0.f)));
+      GestureEvent::Properties())));
 }
 
 void GestureSequence::AppendPinchGestureEnd(const GesturePoint& p1,
                                             const GesturePoint& p2,
                                             float scale,
                                             Gestures* gestures) {
   gfx::Point center = p1.last_touch_position().Middle(p2.last_touch_position());
+  GestureEvent::Properties props;
+  props.delta_x = scale;
+  props.scale_x = scale;
+
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_PINCH_END,
       center.x(),
       center.y(),
       flags_,
       base::Time::FromDoubleT(p1.last_touch_time()),
-      scale, 0.f)));
+      props)));
 }
 
 void GestureSequence::AppendPinchGestureUpdate(const GesturePoint& p1,
                                                const GesturePoint& p2,
                                                float scale,
                                                Gestures* gestures) {
   // TODO(sad): Compute rotation and include it in delta_y.
   // http://crbug.com/113145
   gfx::Point center = p1.last_touch_position().Middle(p2.last_touch_position());
+
+  GestureEvent::Properties props;
+  props.delta_x = scale;
+  props.scale_x = scale;
+
   gestures->push_back(linked_ptr<GestureEvent>(new GestureEvent(
       ui::ET_GESTURE_PINCH_UPDATE,
       center.x(),
       center.y(),
       flags_,
       base::Time::FromDoubleT(p1.last_touch_time()),
-      scale, 0.f)));
+      props)));
 }
 
 bool GestureSequence::Click(const TouchEvent& event,
     const GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_PENDING_SYNTHETIC_CLICK);
   if (point.IsInClickWindow(event)) {
     AppendClickGestureEvent(point, gestures);
     if (point.IsInDoubleClickWindow(event))
       AppendDoubleClickGestureEvent(point, gestures);
     return true;
@@ skipping 51 matching lines @@
   long_press_timer_->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLongPressTimeInMilliseconds),
       this,
       &GestureSequence::AppendLongPressGestureEvent);
   return true;
 }
 
 void GestureSequence::AppendLongPressGestureEvent() {
   const GesturePoint* point = GetPointByPointId(0);
+  GestureEvent::Properties props;
+  props.point_id = point->point_id();
+
   GestureEvent gesture(
       ui::ET_GESTURE_LONG_PRESS,
       point->first_touch_position().x(),
       point->first_touch_position().y(),
       flags_,
       base::Time::FromDoubleT(point->last_touch_time()),
-      point->point_id(), 0.f);
+      props);
   root_window_->DispatchGestureEvent(&gesture);
 }
 
 bool GestureSequence::ScrollEnd(const TouchEvent& event,
     GesturePoint& point, Gestures* gestures) {
   DCHECK(state_ == GS_SCROLL);
   if (point.IsInFlickWindow(event)) {
     AppendScrollGestureEnd(point, point.last_touch_position(), gestures,
         point.XVelocity(), point.YVelocity());
   } else {
@@ skipping 65 matching lines @@
   float distance = point1->Distance(*point2);
   AppendPinchGestureEnd(*point1, *point2,
       distance / pinch_distance_start_, gestures);
 
   pinch_distance_start_ = 0;
   pinch_distance_current_ = 0;
   return true;
 }
 
 }  // namespace aura