Remove unsupported parameters by the unified gesture detector from Gesture Configuration.

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 482 matching lines @@
                         float x_start,
                         float y_start,
                         int dx,
                         int dy,
                         int touch_id,
                         int time_step,
                         int num_steps,
                         GestureEventConsumeDelegate* delegate) {
     int x = x_start;
     int y = y_start;
-

[tdresser, 2014/09/12 18:39:57]

Might as well leave this space here.

[lanwei, 2014/09/12 18:47:49]

Done.

     for (int i = 0; i < num_steps; i++) {
       x += dx;
       y += dy;
       ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(x, y),
                           touch_id,
                           base::TimeDelta::FromMilliseconds(simulated_now_));
       ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move);
       ASSERT_FALSE(details.dispatcher_destroyed);
       simulated_now_ += time_step;
     }
@@ skipping 114 matching lines @@
 
 }  // namespace
 
 class GestureRecognizerTest : public AuraTestBase,
                               public ::testing::WithParamInterface<bool> {
  public:
   GestureRecognizerTest() {}
 
   virtual void SetUp() OVERRIDE {
     AuraTestBase::SetUp();
-    ui::GestureConfiguration::set_min_touch_down_duration_in_seconds_for_click(
-        0.001);
     ui::GestureConfiguration::set_show_press_delay_in_ms(2);
     ui::GestureConfiguration::set_long_press_time_in_seconds(0.003);
   }
 
   DISALLOW_COPY_AND_ASSIGN(GestureRecognizerTest);
 };
 
 // Check that appropriate touch events generate tap gesture events.
 TEST_F(GestureRecognizerTest, GestureEventTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
@@ skipping 351 matching lines @@
                          tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_SCROLL_FLING_START,
                   ui::ET_GESTURE_END);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 // Check that predicted scroll update positions are correct.
 TEST_F(GestureRecognizerTest, GestureEventScrollPrediction) {
-  const double prediction_interval = 0.03;
-  ui::GestureConfiguration::set_scroll_prediction_seconds(prediction_interval);
-   // We'll start by moving the touch point by (5, 5). We want all of that
+  // 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::set_max_touch_move_in_pixels_for_click(
       sqrt(static_cast<double>(5 * 5 + 5 * 5)));
 
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
@@ skipping 135 matching lines @@
   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(20, delegate->scroll_x());
 
   // Get a high x velocity, while still staying on the rail
-  tes.SendScrollEvents(event_processor(), 1, 1,
-                   100, 10, kTouchId, 1,
-                   ui::GestureConfiguration::points_buffered_for_velocity(),
-                   delegate.get());
+  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());
@@ skipping 21 matching lines @@
   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(0, delegate->scroll_velocity_x());
 
   // Get a high y velocity, while still staying on the rail
-  tes.SendScrollEvents(event_processor(), 1, 6,
-                       10, 100, kTouchId, 1,
-                       ui::GestureConfiguration::points_buffered_for_velocity(),
+  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());
@@ skipping 16 matching lines @@
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Move the touch-point such that a non-rail scroll begins, and we're outside
   // the snap channel for the unified GR.
   tes.SendScrollEvent(event_processor(), 50, 50, kTouchId, delegate.get());
   EXPECT_EQ(50, delegate->scroll_y());
   EXPECT_EQ(50, delegate->scroll_x());
 
-  tes.SendScrollEvents(event_processor(), 1, 1,
-                       10, 100, kTouchId, 1,
-                       ui::GestureConfiguration::points_buffered_for_velocity(),
+  const int kScrollAmount = 8;
+  tes.SendScrollEvents(event_processor(),
+                       1,
+                       1,
+                       10,
+                       100,
+                       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);
@@ skipping 206 matching lines @@
   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());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
-  tes.SendScrollEvents(event_processor(), 1, 1,
-                       6, 100, kTouchId, 1,
-                       ui::GestureConfiguration::points_buffered_for_velocity(),
+  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());
 }
@@ skipping 27 matching lines @@
 
   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());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
-  tes.SendScrollEvents(event_processor(), 1, 6,
-                       100, 1, kTouchId, 1,
-                       ui::GestureConfiguration::points_buffered_for_velocity(),
+  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());
 }
@@ skipping 1883 matching lines @@
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->pinch_update());
 
   delegate->Reset();
 }
 
 // Checks that slow scrolls deliver the correct deltas.
 // In particular, fix for http;//crbug.com/150573.
 TEST_F(GestureRecognizerTest, NoDriftInScroll) {
   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(3);
-  ui::GestureConfiguration::set_min_scroll_delta_squared(9);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 234;
   const int kWindowHeight = 345;
   const int kTouchId = 5;
   TimedEvents tes;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
@@ skipping 829 matching lines @@
   ui::TouchEvent move3(
       ui::ET_TOUCH_MOVED, gfx::Point(65, 202), kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move3);
 
   delegate->ReceivedAck();
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
 }  // namespace test
 }  // namespace aura