gesture: Include velocity in scroll-update gestures.

ui/aura/gestures/gesture_recognizer_unittest.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 "base/memory/scoped_vector.h"
 #include "base/string_number_conversions.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 32 matching lines @@
         scroll_update_(false),
         scroll_end_(false),
         pinch_begin_(false),
         pinch_update_(false),
         pinch_end_(false),
         long_press_(false),
         fling_(false),
         two_finger_tap_(false),
         scroll_x_(0),
         scroll_y_(0),
+        scroll_velocity_x_(0),
+        scroll_velocity_y_(0),
         velocity_x_(0),
         velocity_y_(0),
         tap_count_(0) {
   }
 
   virtual ~GestureEventConsumeDelegate() {}
 
   void Reset() {
     tap_ = false;
     tap_down_ = false;
     begin_ = false;
     end_ = false;
     double_tap_ = false;
     scroll_begin_ = false;
     scroll_update_ = false;
     scroll_end_ = false;
     pinch_begin_ = false;
     pinch_update_ = false;
     pinch_end_ = false;
     long_press_ = false;
     fling_ = false;
     two_finger_tap_ = false;
 
     scroll_begin_position_.SetPoint(0, 0);
     tap_location_.SetPoint(0, 0);
 
     scroll_x_ = 0;
     scroll_y_ = 0;
+    scroll_velocity_x_ = 0;
+    scroll_velocity_y_ = 0;
     velocity_x_ = 0;
     velocity_y_ = 0;
     tap_count_ = 0;
   }
 
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
   bool begin() const { return begin_; }
   bool end() const { return end_; }
   bool double_tap() const { return double_tap_; }
@@ skipping 10 matching lines @@
   const gfx::Point scroll_begin_position() const {
     return scroll_begin_position_;
   }
 
   const gfx::Point tap_location() const {
     return tap_location_;
   }
 
   float scroll_x() const { return scroll_x_; }
   float scroll_y() const { return scroll_y_; }
+  float scroll_velocity_x() const { return scroll_velocity_x_; }
+  float scroll_velocity_y() const { return scroll_velocity_y_; }
   int touch_id() const { return touch_id_; }
   float velocity_x() const { return velocity_x_; }
   float velocity_y() const { return velocity_y_; }
   const gfx::Rect& bounding_box() const { return bounding_box_; }
   int tap_count() const { return tap_count_; }
 
   virtual ui::GestureStatus OnGestureEvent(
       ui::GestureEvent* gesture) OVERRIDE {
     bounding_box_ = gesture->details().bounding_box();
     switch (gesture->type()) {
@@ skipping 15 matching lines @@
         double_tap_ = true;
         break;
       case ui::ET_GESTURE_SCROLL_BEGIN:
         scroll_begin_ = true;
         scroll_begin_position_ = gesture->location();
         break;
       case ui::ET_GESTURE_SCROLL_UPDATE:
         scroll_update_ = true;
         scroll_x_ += gesture->details().scroll_x();
         scroll_y_ += gesture->details().scroll_y();
+        scroll_velocity_x_ = gesture->details().velocity_x();
+        scroll_velocity_y_ = gesture->details().velocity_y();
         break;
       case ui::ET_GESTURE_SCROLL_END:
         EXPECT_TRUE(velocity_x_ == 0 && velocity_y_ == 0);
         scroll_end_ = true;
         break;
       case ui::ET_GESTURE_PINCH_BEGIN:
         pinch_begin_ = true;
         break;
       case ui::ET_GESTURE_PINCH_UPDATE:
         pinch_update_ = true;
@@ skipping 36 matching lines @@
   bool pinch_end_;
   bool long_press_;
   bool fling_;
   bool two_finger_tap_;
 
   gfx::Point scroll_begin_position_;
   gfx::Point tap_location_;
 
   float scroll_x_;
   float scroll_y_;
+  float scroll_velocity_x_;
+  float scroll_velocity_y_;
   float velocity_x_;
   float velocity_y_;
   int touch_id_;
   gfx::Rect bounding_box_;
   int tap_count_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
@@ skipping 513 matching lines @@
   SendScrollEvent(root_window(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(29, delegate->scroll_x());
   EXPECT_EQ(29, delegate->scroll_y());
+  EXPECT_EQ(0, delegate->scroll_velocity_x());
+  EXPECT_EQ(0, delegate->scroll_velocity_y());
   EXPECT_EQ(gfx::Point(1, 1).ToString(),
             delegate->scroll_begin_position().ToString());
 
   // When scrolling with a single finger, the bounding box of the gesture should
   // be empty, since it's a single point and the radius for testing is zero.
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Move some more to generate a few more scroll updates.
   SendScrollEvent(root_window(), 110, 211, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
@@ skipping 108 matching lines @@
   // horizontal scroll.
   SendScrollEvent(root_window(), 20, 1, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
   // Get a high x velocity, while still staying on the rail
   SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
                    100, 10, kTouchId, 1,
                    ui::GestureConfiguration::points_buffered_for_velocity(),
                    delegate.get());
+  // The y-velocity during the scroll should be 0 since this is in a horizontal
+  // rail scroll.
+  EXPECT_GT(delegate->scroll_velocity_x(), 0);
+  EXPECT_EQ(0, delegate->scroll_velocity_y());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_GT(delegate->velocity_x(), 0);
   EXPECT_EQ(0, delegate->velocity_y());
@@ skipping 11 matching lines @@
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                            kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
   SendScrollEvent(root_window(), 1, 20, kTouchId, delegate.get());
   EXPECT_EQ(20, delegate->scroll_y());
   EXPECT_EQ(0, delegate->scroll_x());
+  EXPECT_EQ(0, delegate->scroll_velocity_x());
+  EXPECT_EQ(0, delegate->scroll_velocity_y());
 
   // Get a high y velocity, while still staying on the rail
   SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
                    10, 100, kTouchId, 1,
                    ui::GestureConfiguration::points_buffered_for_velocity(),
                    delegate.get());
+  EXPECT_EQ(0, delegate->scroll_velocity_x());
+  EXPECT_GT(delegate->scroll_velocity_y(), 0);
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(0, delegate->velocity_x());
   EXPECT_GT(delegate->velocity_y(), 0);
@@ skipping 188 matching lines @@
   // horizontal scroll.
   SendScrollEvent(root_window(), 20, 1, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
   SendScrollEvent(root_window(), 25, 6, kTouchId, delegate.get());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_x());
   // y shouldn't change, as we're on a horizontal rail.
   EXPECT_EQ(0, delegate->scroll_y());
+  EXPECT_EQ(0, delegate->scroll_velocity_x());
+  EXPECT_EQ(0, delegate->scroll_velocity_y());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
   SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
                    1, 100, kTouchId, 1,
                    ui::GestureConfiguration::points_buffered_for_velocity(),
                    delegate.get());
+  // Since the scroll is not longer railing, the velocity should be set for both
+  // axis.
+  EXPECT_GT(delegate->scroll_velocity_x(), 0);
+  EXPECT_GT(delegate->scroll_velocity_y(), 0);
 
   SendScrollEvent(root_window(), 0, 0, kTouchId, delegate.get());
   SendScrollEvent(root_window(), 5, 5, kTouchId, delegate.get());
 
   // The rail should be broken
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_x());
   EXPECT_EQ(5, delegate->scroll_y());
 }
 
@@ skipping 15 matching lines @@
   // vertical scroll.
   SendScrollEvent(root_window(), 1, 20, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(20, delegate->scroll_y());
 
   SendScrollEvent(root_window(), 6, 25, kTouchId, delegate.get());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_y());
   // x shouldn't change, as we're on a vertical rail.
   EXPECT_EQ(0, delegate->scroll_x());
+  EXPECT_EQ(0, delegate->scroll_velocity_x());
+  EXPECT_EQ(0, delegate->scroll_velocity_y());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
   SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
                    100, 1, kTouchId, 1,
                    ui::GestureConfiguration::points_buffered_for_velocity(),
                    delegate.get());
+  EXPECT_GT(delegate->scroll_velocity_x(), 0);
+  EXPECT_GT(delegate->scroll_velocity_y(), 0);
 
   SendScrollEvent(root_window(), 0, 0, kTouchId, delegate.get());
   SendScrollEvent(root_window(), 5, 5, kTouchId, delegate.get());
 
   // The rail should be broken
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(5, delegate->scroll_x());
   EXPECT_EQ(5, delegate->scroll_y());
 }
 
@@ skipping 1566 matching lines @@
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->pinch_update());
 
   delegate->Reset();
 }
 
 }  // namespace test
 }  // namespace aura