Postpone rail application for touch scrolling - chrome side.

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/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 79 matching lines @@
         scroll_x_(0),
         scroll_y_(0),
         scroll_velocity_x_(0),
         scroll_velocity_y_(0),
         velocity_x_(0),
         velocity_y_(0),
         scroll_x_hint_(0),
         scroll_y_hint_(0),
         tap_count_(0),
         flags_(0),
+        scroll_rail_state_(ui::GestureEventDetails::ScrollRailState::Free),
         wait_until_event_(ui::ET_UNKNOWN) {}
 
   ~GestureEventConsumeDelegate() override {}
 
   void Reset() {
     events_.clear();
     tap_ = false;
     tap_down_ = false;
     tap_cancel_ = false;
     begin_ = false;
@@ skipping 21 matching lines @@
     scroll_y_ = 0;
     scroll_velocity_x_ = 0;
     scroll_velocity_y_ = 0;
     velocity_x_ = 0;
     velocity_y_ = 0;
     scroll_x_hint_ = 0;
     scroll_y_hint_ = 0;
     tap_count_ = 0;
     scale_ = 0;
     flags_ = 0;
+    scroll_rail_state_ = ui::GestureEventDetails::ScrollRailState::Free;
     latency_info_.Clear();
   }
 
   const std::vector<ui::EventType>& events() const { return events_; };
 
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
   bool tap_cancel() const { return tap_cancel_; }
   bool begin() const { return begin_; }
   bool end() const { return end_; }
@@ skipping 30 matching lines @@
   float scroll_velocity_x() const { return scroll_velocity_x_; }
   float scroll_velocity_y() const { return scroll_velocity_y_; }
   float velocity_x() const { return velocity_x_; }
   float velocity_y() const { return velocity_y_; }
   float scroll_x_hint() const { return scroll_x_hint_; }
   float scroll_y_hint() const { return scroll_y_hint_; }
   float scale() const { return scale_; }
   const gfx::Rect& bounding_box() const { return bounding_box_; }
   int tap_count() const { return tap_count_; }
   int flags() const { return flags_; }
+  ui::GestureEventDetails::ScrollRailState scroll_rail_state() const {
+    return scroll_rail_state_;
+  }
   const ui::LatencyInfo& latency_info() const { return latency_info_; }
 
   void WaitUntilReceivedGesture(ui::EventType type) {
     wait_until_event_ = type;
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
   void OnGestureEvent(ui::GestureEvent* gesture) override {
     events_.push_back(gesture->type());
@@ skipping 22 matching lines @@
       case ui::ET_GESTURE_SCROLL_BEGIN:
         scroll_begin_ = true;
         scroll_begin_position_ = gesture->location();
         scroll_x_hint_ = gesture->details().scroll_x_hint();
         scroll_y_hint_ = gesture->details().scroll_y_hint();
         break;
       case ui::ET_GESTURE_SCROLL_UPDATE:
         scroll_update_ = true;
         scroll_x_ += gesture->details().scroll_x();
         scroll_y_ += gesture->details().scroll_y();
+        scroll_rail_state_ = gesture->details().scroll_rail_state();
         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;
         scale_ = gesture->details().scale();
         break;
       case ui::ET_GESTURE_PINCH_END:
         pinch_end_ = true;
         break;
       case ui::ET_GESTURE_LONG_PRESS:
         long_press_ = true;
         break;
       case ui::ET_GESTURE_LONG_TAP:
         long_tap_ = true;
         break;
       case ui::ET_SCROLL_FLING_START:
         EXPECT_TRUE(gesture->details().velocity_x() != 0 ||
                     gesture->details().velocity_y() != 0);
+        scroll_rail_state_ = gesture->details().scroll_rail_state();
         EXPECT_FALSE(scroll_end_);
         fling_ = true;
         velocity_x_ = gesture->details().velocity_x();
         velocity_y_ = gesture->details().velocity_y();
         break;
       case ui::ET_GESTURE_TWO_FINGER_TAP:
         two_finger_tap_ = true;
         break;
       case ui::ET_GESTURE_SHOW_PRESS:
         show_press_ = true;
@@ skipping 51 matching lines @@
   float scroll_velocity_x_;
   float scroll_velocity_y_;
   float velocity_x_;
   float velocity_y_;
   float scroll_x_hint_;
   float scroll_y_hint_;
   float scale_;
   gfx::Rect bounding_box_;
   int tap_count_;
   int flags_;
+  ui::GestureEventDetails::ScrollRailState scroll_rail_state_;
   ui::LatencyInfo latency_info_;
 
   ui::EventType wait_until_event_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher)
@@ skipping 837 matching lines @@
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(10, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
   tes.SendScrollEvent(event_processor(), 30, 1, kTouchId, delegate.get());
-  EXPECT_FLOAT_EQ(0, delegate->scroll_y());
+  EXPECT_FLOAT_EQ(1, delegate->scroll_y());
   EXPECT_FLOAT_EQ(20, delegate->scroll_x());
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Horizontal,
+            delegate->scroll_rail_state());
 
   // Get a high x velocity, while still staying on the rail
   const int kScrollAmount = 8;
   tes.SendScrollEvents(event_processor(),
                        1,
                        1,
                        100,
                        10,
                        kTouchId,
                        1,
                        kScrollAmount,
                        delegate.get());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_GT(delegate->velocity_x(), 0);
-  EXPECT_EQ(0, delegate->velocity_y());
+  EXPECT_GT(delegate->velocity_y(), 0);
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Horizontal,
+            delegate->scroll_rail_state());
 }
 
 // Check Scroll End Events report correct velocities
 // if the user was on a vertical rail
 TEST_F(GestureRecognizerTest, GestureEventVerticalRailFling) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 10),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
   tes.SendScrollEvent(event_processor(), 1, 30, kTouchId, delegate.get());
   EXPECT_EQ(20, delegate->scroll_y());
-  EXPECT_EQ(0, delegate->scroll_x());
+  EXPECT_EQ(1, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Vertical,
+            delegate->scroll_rail_state());
 
   // Get a high y velocity, while still staying on the rail
   const int kScrollAmount = 8;
   tes.SendScrollEvents(event_processor(),
                        1,
                        6,
                        10,
                        100,
                        kTouchId,
                        1,
                        kScrollAmount,
                        delegate.get());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 206),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_EQ(0, delegate->velocity_x());
+  EXPECT_GT(delegate->velocity_x(), 0);
   EXPECT_GT(delegate->velocity_y(), 0);
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Vertical,
+            delegate->scroll_rail_state());
 }
 
 // Check Scroll End Events report non-zero velocities if the user is not on a
 // rail
 TEST_F(GestureRecognizerTest, GestureEventNonRailFling) {
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(0);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
@@ skipping 235 matching lines @@
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
   tes.SendScrollEvent(event_processor(), 25, 0, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
   tes.SendScrollEvent(event_processor(), 30, 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(6, delegate->scroll_y());
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Horizontal,
+            delegate->scroll_rail_state());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
   const int kScrollAmount = 8;
   tes.SendScrollEvents(event_processor(),
                        1,
                        1,
                        6,
                        100,
                        kTouchId,
                        1,
                        kScrollAmount,
                        delegate.get());
 
   tes.SendScrollEvent(event_processor(), 5, 0, kTouchId, delegate.get());
   tes.SendScrollEvent(event_processor(), 10, 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());
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Free,
+            delegate->scroll_rail_state());
 }
 
 // Check that vertical scroll gestures cause scrolls on vertical rails.
 // Also tests that vertical rails can be broken.
 TEST_F(GestureRecognizerTest, GestureEventVerticalRailScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
@@ skipping 12 matching lines @@
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
   tes.SendScrollEvent(event_processor(), 0, 25, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(20, delegate->scroll_y());
 
   tes.SendScrollEvent(event_processor(), 6, 30, 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(6, delegate->scroll_x());
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Vertical,
+            delegate->scroll_rail_state());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
   const int kScrollAmount = 8;
   tes.SendScrollEvents(event_processor(),
                        1,
                        6,
                        100,
                        1,
                        kTouchId,
                        1,
                        kScrollAmount,
                        delegate.get());
 
   tes.SendScrollEvent(event_processor(), 0, 5, kTouchId, delegate.get());
   tes.SendScrollEvent(event_processor(), 5, 10, 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());
+  EXPECT_EQ(ui::GestureEventDetails::ScrollRailState::Free,
+            delegate->scroll_rail_state());
 }
 
 TEST_F(GestureRecognizerTest, GestureTapFollowedByScroll) {
   // We'll start by moving the touch point by (5, 5). We want all of that
   // distance to be consumed by the slop, so we set the slop radius to
   // sqrt(5 * 5 + 5 * 5).
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(sqrt(5.f * 5 + 5 * 5));
 
   // First, tap. Then, do a scroll using the same touch-id.
@@ skipping 2811 matching lines @@
   // The synchronous ack is stuck behind the pending touch move.
   EXPECT_0_EVENTS(delegate->events());
 
   delegate->ReceivedAck();
   EXPECT_2_EVENTS(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
 }  // namespace test
 }  // namespace aura