Make touch-based synthetic gesture take touch slop into account.

content/browser/renderer_host/input/synthetic_gesture_controller_unittest.cc

 // Copyright 2013 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_ptr.h"
 #include "base/time/time.h"
 #include "content/browser/renderer_host/input/synthetic_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_controller.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 #include "content/browser/renderer_host/input/synthetic_pinch_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/common/input/input_event.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/point_f.h"
 
 namespace content {
 
 namespace {
 
 const int kFlushInputRateInMs = 16;
 const int kPointerAssumedStoppedTimeMs = 43;
+const int kTouchSlopInDips = 7;
 
 class MockSyntheticGesture : public SyntheticGesture {
  public:
   MockSyntheticGesture(bool* finished, int num_steps)
       : finished_(finished),
         num_steps_(num_steps),
         step_count_(0) {
     *finished_ = false;
   }
   virtual ~MockSyntheticGesture() {}
@@ skipping 55 matching lines @@
   }
 
   virtual base::TimeDelta PointerAssumedStoppedTime() const OVERRIDE {
     return base::TimeDelta::FromMilliseconds(pointer_assumed_stopped_time_ms_);
   }
 
   void set_pointer_assumed_stopped_time_ms(int time_ms) {
     pointer_assumed_stopped_time_ms_ = time_ms;
   }
 
+  virtual int GetTouchSlopInDips() const OVERRIDE {
+    return kTouchSlopInDips;
+  }
+
   int num_success() const { return num_success_; }
   int num_failure() const { return num_failure_; }
 
   bool flush_requested() const { return flush_requested_; }
   void ClearFlushRequest() { flush_requested_ = false; }
 
  private:
   int num_success_;
   int num_failure_;
 
@@ skipping 253 matching lines @@
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.distance = 123;
 
   scoped_ptr<SyntheticSmoothScrollGesture> gesture(
       new SyntheticSmoothScrollGesture(params));
   controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   FlushInputUntilComplete();
 
   EXPECT_EQ(1, target_->num_success());
   EXPECT_EQ(0, target_->num_failure());
-  EXPECT_FLOAT_EQ(params.distance,
+  EXPECT_FLOAT_EQ(params.distance + target_->GetTouchSlopInDips(),
                   static_cast<MockSyntheticSmoothScrollTouchTarget*>(target_)
                       ->scroll_distance());
 }
 
 TEST_F(SyntheticGestureControllerTest, SmoothScrollGestureTouchLongStop) {
   CreateControllerAndTarget<MockSyntheticSmoothScrollTouchTarget>();
 
   // Create a smooth scroll with a short distance and set the pointer assumed
   // stopped time high, so that the stopping should dominate the time the
   // gesture is active.
   SyntheticSmoothScrollGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.distance = 21;
 
   target_->set_pointer_assumed_stopped_time_ms(543);
 
   scoped_ptr<SyntheticSmoothScrollGesture> gesture(
       new SyntheticSmoothScrollGesture(params));
   controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   FlushInputUntilComplete();
 
   EXPECT_EQ(1, target_->num_success());
   EXPECT_EQ(0, target_->num_failure());
-  EXPECT_FLOAT_EQ(params.distance,
+  EXPECT_FLOAT_EQ(params.distance + target_->GetTouchSlopInDips(),
                   static_cast<MockSyntheticSmoothScrollTouchTarget*>(target_)
                       ->scroll_distance());
   EXPECT_GE(GetTotalTime(), target_->PointerAssumedStoppedTime());
 }
 
+TEST_F(SyntheticGestureControllerTest, SmoothScrollGestureTouchZeroDistance) {
+  CreateControllerAndTarget<MockSyntheticSmoothScrollTouchTarget>();
+
+  SyntheticSmoothScrollGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params.distance = 0;
+
+  scoped_ptr<SyntheticSmoothScrollGesture> gesture(
+      new SyntheticSmoothScrollGesture(params));
+  controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
+  FlushInputUntilComplete();
+
+  EXPECT_EQ(1, target_->num_success());
+  EXPECT_EQ(0, target_->num_failure());
+  EXPECT_FLOAT_EQ(0, static_cast<MockSyntheticSmoothScrollTouchTarget*>(target_)
+                         ->scroll_distance());
+}
+
 TEST_F(SyntheticGestureControllerTest, SmoothScrollGestureMouse) {
   CreateControllerAndTarget<MockSyntheticSmoothScrollMouseTarget>();
 
   SyntheticSmoothScrollGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
   params.distance = -234;
 
   scoped_ptr<SyntheticSmoothScrollGesture> gesture(
       new SyntheticSmoothScrollGesture(params));
   controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
@@ skipping 16 matching lines @@
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   FlushInputUntilComplete();
 
   EXPECT_EQ(1, target_->num_success());
   EXPECT_EQ(0, target_->num_failure());
   EXPECT_EQ(
       static_cast<MockSyntheticPinchTouchTarget*>(target_)->zoom_direction(),
       MockSyntheticPinchTouchTarget::ZOOM_IN);
-  EXPECT_FLOAT_EQ(params.total_num_pixels_covered,
-                  static_cast<MockSyntheticPinchTouchTarget*>(target_)
-                      ->total_num_pixels_covered());
+  EXPECT_FLOAT_EQ(
+      params.total_num_pixels_covered + 2 * target_->GetTouchSlopInDips(),
+      static_cast<MockSyntheticPinchTouchTarget*>(target_)
+          ->total_num_pixels_covered());
 }
 
 TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZoomOut) {
   CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
 
   SyntheticPinchGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
   params.zoom_in = false;
   params.total_num_pixels_covered = 456;
 
   scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
   controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   FlushInputUntilComplete();
 
   EXPECT_EQ(1, target_->num_success());
   EXPECT_EQ(0, target_->num_failure());
   EXPECT_EQ(
       static_cast<MockSyntheticPinchTouchTarget*>(target_)->zoom_direction(),
       MockSyntheticPinchTouchTarget::ZOOM_OUT);
-  EXPECT_FLOAT_EQ(params.total_num_pixels_covered,
-                  static_cast<MockSyntheticPinchTouchTarget*>(target_)
-                      ->total_num_pixels_covered());
+  EXPECT_FLOAT_EQ(
+      params.total_num_pixels_covered + 2 * target_->GetTouchSlopInDips(),
+      static_cast<MockSyntheticPinchTouchTarget*>(target_)
+          ->total_num_pixels_covered());
+}
+
+TEST_F(SyntheticGestureControllerTest, PinchGestureTouchZeroPixelsCovered) {
+  CreateControllerAndTarget<MockSyntheticPinchTouchTarget>();
+
+  SyntheticPinchGestureParams params;
+  params.gesture_source_type = SyntheticGestureParams::TOUCH_INPUT;
+  params.zoom_in = true;
+  params.total_num_pixels_covered = 0;
+
+  scoped_ptr<SyntheticPinchGesture> gesture(new SyntheticPinchGesture(params));
+  controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
+  FlushInputUntilComplete();
+
+  EXPECT_EQ(1, target_->num_success());
+  EXPECT_EQ(0, target_->num_failure());
+  EXPECT_EQ(
+      static_cast<MockSyntheticPinchTouchTarget*>(target_)->zoom_direction(),
+      MockSyntheticPinchTouchTarget::ZOOM_DIRECTION_UNKNOWN);
+  EXPECT_FLOAT_EQ(0, static_cast<MockSyntheticPinchTouchTarget*>(target_)
+                         ->total_num_pixels_covered());
 }
 
 }  // namespace
 
 }  // namespace content