ash: Record some additional information about the gestures.

ui/base/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/base/gestures/gesture_sequence.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 533 matching lines @@
   gfx::Point p2 = GetPointByPointId(1)->last_touch_position();
   double max_distance =
       ui::GestureConfiguration::max_distance_for_two_finger_tap_in_pixels();
   double distance = (p1.x() - p2.x()) * (p1.x() - p2.x()) +
       (p1.y() - p2.y()) * (p1.y() - p2.y());
   if (distance < max_distance * max_distance)
     return true;
   return false;
 }
 
+GestureEvent* GestureSequence::CreateGestureEvent(
+    GestureEventDetails details,
+    const gfx::Point& location,
+    int flags,
+    base::Time timestamp,
+    unsigned int touch_id_bitmask) {
+  details.set_touch_points(point_count_);
+  return helper_->CreateGestureEvent(details, location, flags, timestamp,
+      touch_id_bitmask);
+}
+
 void GestureSequence::AppendTapDownGestureEvent(const GesturePoint& point,
                                                 Gestures* gestures) {
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_TAP_DOWN,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_TAP_DOWN, 0, 0),
       point.first_touch_position(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0, 0.f, 1 << point.touch_id()));
+      1 << point.touch_id()));
 }
 
 void GestureSequence::AppendBeginGestureEvent(const GesturePoint& point,
                                               Gestures* gestures) {
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_BEGIN,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_BEGIN, point_count_, 0),
       point.first_touch_position(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      point_count_, 0.f, 1 << point.touch_id()));
+      1 << point.touch_id()));
 }
 
 void GestureSequence::AppendEndGestureEvent(const GesturePoint& point,
                                               Gestures* gestures) {
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_END,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_END, point_count_, 0),
       point.first_touch_position(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      point_count_, 0.f, 1 << point.touch_id()));
+      1 << point.touch_id()));
 }
 
 void GestureSequence::AppendClickGestureEvent(const GesturePoint& point,
                                               Gestures* gestures) {
   gfx::Rect er = point.enclosing_rectangle();
   gfx::Point center = er.CenterPoint();
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_TAP,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_TAP, er.width() / 2, er.height() / 2),
       center,
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      er.width() / 2,
-      er.height() / 2,
       1 << point.touch_id()));
 }
 
 void GestureSequence::AppendDoubleClickGestureEvent(const GesturePoint& point,
                                                     Gestures* gestures) {
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_DOUBLE_TAP,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_DOUBLE_TAP, 0, 0),
       point.first_touch_position(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0.f, 0.f, 1 << point.touch_id()));
+      1 << point.touch_id()));
 }
 
 void GestureSequence::AppendScrollGestureBegin(const GesturePoint& point,
                                                const gfx::Point& location,
                                                Gestures* gestures) {
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_SCROLL_BEGIN,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN, 0, 0),
       location,
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0.f, 0.f, 1 << point.touch_id()));
+      1 << point.touch_id()));
 }
 
 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;
 
   // TODO(rjkroege): It is conceivable that we could suppress sending the
   // GestureScrollEnd if it is immediately followed by a GestureFlingStart.
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_SCROLL_END,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_SCROLL_END, 0, 0),
       location,
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      0., 0., 1 << point.touch_id()));
+      1 << point.touch_id()));
 
   if (railed_x_velocity != 0 || railed_y_velocity != 0) {
     // TODO(sad|rjkroege): fling-curve is currently configured to work well with
     // touchpad scroll-events. This curve needs to be adjusted to work correctly
     // with both touchpad and touchscreen. Until then, scale quadratically.
     // http://crbug.com/120154
     const float velocity_scaling  = 1.f / 900.f;
 
-    gestures->push_back(helper_->CreateGestureEvent(
-        ui::ET_SCROLL_FLING_START,
+    gestures->push_back(CreateGestureEvent(
+        GestureEventDetails(ui::ET_SCROLL_FLING_START,
+            velocity_scaling * railed_x_velocity * fabsf(railed_x_velocity),
+            velocity_scaling * railed_y_velocity * fabsf(railed_y_velocity)),
         location,
         flags_,
         base::Time::FromDoubleT(point.last_touch_time()),
-        velocity_scaling * railed_x_velocity * fabsf(railed_x_velocity),
-        velocity_scaling * railed_y_velocity * fabsf(railed_y_velocity),
         1 << point.touch_id()));
   }
 }
 
 void GestureSequence::AppendScrollGestureUpdate(const GesturePoint& point,
                                                 const gfx::Point& location,
                                                 Gestures* gestures) {
   int dx = location.x() - bounding_box_last_center_.x();
   int dy = location.y() - bounding_box_last_center_.y();
   if (dx == 0 && dy == 0)
     return;
   if (scroll_type_ == ST_HORIZONTAL)
     dy = 0;
   else if (scroll_type_ == ST_VERTICAL)
     dx = 0;
 
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_SCROLL_UPDATE,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_SCROLL_UPDATE, dx, dy),
       location,
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      dx, dy, ComputeTouchBitmask(points_)));
+      ComputeTouchBitmask(points_)));
 }
 
 void GestureSequence::AppendPinchGestureBegin(const GesturePoint& p1,
                                               const GesturePoint& p2,
                                               Gestures* gestures) {
   gfx::Point center = bounding_box_.CenterPoint();
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_PINCH_BEGIN,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_PINCH_BEGIN, 0, 0),
       center,
       flags_,
       base::Time::FromDoubleT(p1.last_touch_time()),
-      0.f, 0.f, 1 << p1.touch_id() | 1 << p2.touch_id()));
+      1 << p1.touch_id() | 1 << p2.touch_id()));
 }
 
 void GestureSequence::AppendPinchGestureEnd(const GesturePoint& p1,
                                             const GesturePoint& p2,
                                             float scale,
                                             Gestures* gestures) {
   gfx::Point center = bounding_box_.CenterPoint();
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_PINCH_END,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_PINCH_END, 0, 0),
       center,
       flags_,
       base::Time::FromDoubleT(p1.last_touch_time()),
-      0.f, 0.f,
       1 << p1.touch_id() | 1 << p2.touch_id()));
 }
 
 void GestureSequence::AppendPinchGestureUpdate(const GesturePoint& point,
                                                float scale,
                                                Gestures* gestures) {
   // TODO(sad): Compute rotation and include it in delta_y.
   // http://crbug.com/113145
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_PINCH_UPDATE,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_PINCH_UPDATE, scale, 0),
       bounding_box_.CenterPoint(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      scale, 0.f,
       ComputeTouchBitmask(points_)));
 }
 
 void GestureSequence::AppendSwipeGesture(const GesturePoint& point,
                                          int swipe_x,
                                          int swipe_y,
                                          Gestures* gestures) {
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_MULTIFINGER_SWIPE,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_MULTIFINGER_SWIPE, swipe_x, swipe_y),
       bounding_box_.CenterPoint(),
       flags_,
       base::Time::FromDoubleT(point.last_touch_time()),
-      swipe_x, swipe_y, ComputeTouchBitmask(points_)));
+      ComputeTouchBitmask(points_)));
 }
 
 void GestureSequence::AppendTwoFingerTapGestureEvent(Gestures* gestures) {
   const GesturePoint* point = GetPointByPointId(0);
-  gestures->push_back(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_TWO_FINGER_TAP,
+  gestures->push_back(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_TWO_FINGER_TAP, 0, 0),
       point->enclosing_rectangle().CenterPoint(),
       flags_,
       base::Time::FromDoubleT(point->last_touch_time()),
-      0.f, 0.f, 1 << point->touch_id()));
+      1 << point->touch_id()));
 }
 
 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 88 matching lines @@
   base::TimeDelta time_delta = event.GetTimestamp() - second_touch_time_;
   base::TimeDelta max_delta = base::TimeDelta::FromMilliseconds(1000 *
       ui::GestureConfiguration::max_touch_down_duration_in_seconds_for_click());
   if (time_delta < max_delta && point.IsInsideManhattanSquare(event))
     AppendTwoFingerTapGestureEvent(gestures);
   return true;
 }
 
 void GestureSequence::AppendLongPressGestureEvent() {
   const GesturePoint* point = GetPointByPointId(0);
-  scoped_ptr<GestureEvent> gesture(helper_->CreateGestureEvent(
-      ui::ET_GESTURE_LONG_PRESS,
+  scoped_ptr<GestureEvent> gesture(CreateGestureEvent(
+      GestureEventDetails(ui::ET_GESTURE_LONG_PRESS, 0, 0),
       point->first_touch_position(),
       flags_,
       base::Time::FromDoubleT(point->last_touch_time()),
-      0.f, 0.f, 1 << point->touch_id()));
+      1 << point->touch_id()));
   helper_->DispatchLongPressGestureEvent(gesture.get());
 }
 
 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 136 matching lines @@
     return;
 
   // Since long press timer has been started, there should be a non-NULL point.
   const GesturePoint* point = GetPointByPointId(0);
   if (!ui::gestures::IsInsideManhattanSquare(point->first_touch_position(),
       event.GetLocation()))
     long_press_timer_->Stop();
 }
 
 }  // namespace ui