Don't send touchcancel on touch scroll start

ui/events/gesture_detection/gesture_provider_unittest.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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 498 matching lines @@
   EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type);
   EXPECT_EQ(event_time + kFiveMilliseconds * 2, gesture.time);
   EXPECT_EQ(kFakeCoordX - delta_x, gesture.x);
   EXPECT_EQ(kFakeCoordY - delta_y, gesture.y);
 
   // No horizontal delta because of snapping.
   EXPECT_EQ(0, gesture.details.scroll_update.delta_x);
   EXPECT_EQ(-delta_y / 2, gesture.details.scroll_update.delta_y);
 }
 
+// Verify that fractional scroll deltas are rounded as expected and that
+// fractional scrolling doesn't break scroll snapping.
+TEST_F(GestureProviderTest, FractionalScroll) {

[Rick Byers, 2014/03/07 20:58:53]

This was a case I initially thought was broken but turned out to actually be OK.
 Since it's a scenario that's not really tested (and important to touchmove
absorption) I figured I'd leave the test in (even though it means I'll need to
merge with your in-flight change to this test before I land - or try to sqeak in
before you <grin>).

[jdduke (slow), 2014/03/07 21:07:32]

Yeah this is great.  I can hold off with the timing patch if you like.

+  const float delta_x = 0.4;
+  const float delta_y = 5.2;
+
+  const base::TimeTicks event_time = TimeTicks::Now();
+
+  MockMotionEvent event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Skip past the touch slop and move back.
+  event = ObtainMotionEvent(event_time,
+                            MotionEvent::ACTION_MOVE,
+                            kFakeCoordX,
+                            kFakeCoordY + 100);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  event = ObtainMotionEvent(event_time,
+                            MotionEvent::ACTION_MOVE);
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+  // Now move up slowly, mostly vertically but with a (fractional) bit of
+  // horizontal motion.
+  for(int i = 1; i <= 10; i++) {
+    event = ObtainMotionEvent(event_time + kFiveMilliseconds * i,
+                              MotionEvent::ACTION_MOVE,
+                              kFakeCoordX + delta_x * i,
+                              kFakeCoordY + delta_y * i);
+    EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+
+    ASSERT_LT(0U, GetReceivedGestureCount());
+    GestureEventData gesture = GetMostRecentGestureEvent();
+    EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, gesture.type);
+    EXPECT_EQ(event_time + kFiveMilliseconds * i, gesture.time);
+
+    // Verify that the event co-ordinates are still the precise values we
+    // supplied.
+    EXPECT_EQ(kFakeCoordX + delta_x * i, gesture.x);
+    EXPECT_EQ(kFakeCoordY + delta_y * i, gesture.y);
+
+    // Verify that we're scrolling vertically by the expected amount
+    // (modulo rounding).
+    EXPECT_GE(gesture.details.scroll_update.delta_y, (int)delta_y);
+    EXPECT_LE(gesture.details.scroll_update.delta_y, ((int)delta_y) + 1);
+
+    // And that there has been no horizontal motion at all.
+    EXPECT_EQ(0, gesture.details.scroll_update.delta_x);
+  }
+}
+
 // Generate a scroll gesture and verify that the resulting scroll begin event
 // has the expected hint values.
 TEST_F(GestureProviderTest, ScrollBeginValues) {
   const int delta_x = 13;
   const int delta_y = 89;
 
   const base::TimeTicks event_time = TimeTicks::Now();
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
@@ skipping 483 matching lines @@
                             MotionEvent::ACTION_UP);
   EXPECT_FALSE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + kFiveMilliseconds * 3,
                             MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 }
 
 }  // namespace ui