Revert of Consolidate all touch/gesture related constants in content

content/browser/renderer_host/input/gesture_event_queue_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 16 matching lines @@
                               public TouchpadTapSuppressionControllerClient {
  public:
   GestureEventQueueTest()
       : acked_gesture_event_count_(0),
         sent_gesture_event_count_(0) {}
 
   virtual ~GestureEventQueueTest() {}
 
   // testing::Test
   virtual void SetUp() OVERRIDE {
-    queue_.reset(new GestureEventQueue(this, this, DefaultConfig()));
+    queue_.reset(new GestureEventQueue(this, this));
   }
 
   virtual void TearDown() OVERRIDE {
     // Process all pending tasks to avoid leaks.
     RunUntilIdle();
     queue_.reset();
   }
 
   // GestureEventQueueClient
   virtual void SendGestureEventImmediately(
@@ skipping 13 matching lines @@
     if (sync_followup_event_)
       SimulateGestureEvent(*sync_followup_event_.Pass());
   }
 
   // TouchpadTapSuppressionControllerClient
   virtual void SendMouseEventImmediately(
       const MouseEventWithLatencyInfo& event) OVERRIDE {
   }
 
  protected:
-  static GestureEventQueue::Config DefaultConfig() {
-    return GestureEventQueue::Config();
-  }
-
-  void SetUpForDebounce(int interval_ms) {
-    queue()->set_debounce_interval_time_ms_for_testing(interval_ms);
-  }
 
   // Returns the result of |GestureEventQueue::ShouldForward()|.
   bool SimulateGestureEvent(const WebGestureEvent& gesture) {
     GestureEventWithLatencyInfo gesture_with_latency(gesture,
                                                      ui::LatencyInfo());
     if (queue()->ShouldForward(gesture_with_latency)) {
       SendGestureEventImmediately(gesture_with_latency);
       return true;
     }
     return false;
@@ skipping 49 matching lines @@
   size_t GetAndResetAckedGestureEventCount() {
     size_t count = acked_gesture_event_count_;
     acked_gesture_event_count_ = 0;
     return count;
   }
 
   const WebGestureEvent& last_acked_event() const {
     return last_acked_event_;
   }
 
+  void DisableDebounce() {
+    queue()->set_debounce_enabled_for_testing(false);
+  }
+
+  void set_debounce_interval_time_ms(int ms) {
+    queue()->set_debounce_interval_time_ms_for_testing(ms);
+  }
+
   void set_synchronous_ack(InputEventAckState ack_result) {
     sync_ack_result_.reset(new InputEventAckState(ack_result));
   }
 
   void set_sync_followup_event(WebInputEvent::Type type,
                                WebGestureEvent::SourceDevice sourceDevice) {
     sync_followup_event_.reset(new WebGestureEvent(
         SyntheticWebGestureEventBuilder::Build(type, sourceDevice)));
   }
 
@@ skipping 46 matching lines @@
 
 #if GTEST_HAS_PARAM_TEST
 // This is for tests that are to be run for all source devices.
 class GestureEventQueueWithSourceTest
     : public GestureEventQueueTest,
       public testing::WithParamInterface<WebGestureEvent::SourceDevice> {
 };
 #endif  // GTEST_HAS_PARAM_TEST
 
 TEST_F(GestureEventQueueTest, CoalescesScrollGestureEvents) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   // Test coalescing of only GestureScrollUpdate events.
   // Simulate gesture events.
 
   // Sent.
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 
   // Enqueued.
   SimulateGestureScrollUpdateEvent(8, -5, 0);
@@ skipping 55 matching lines @@
   // After the final ack, the queue should be empty.
   SendInputEventACK(WebInputEvent::GestureScrollEnd,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   RunUntilIdle();
   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 }
 
 TEST_F(GestureEventQueueTest,
        DoesNotCoalesceScrollGestureEventsFromDifferentDevices) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   // Test that GestureScrollUpdate events from Touchscreen and Touchpad do not
   // coalesce.
 
   // Sent.
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 
   // Enqueued.
   SimulateGestureScrollUpdateEvent(8, -5, 0);
@@ skipping 24 matching lines @@
             GestureEventLastQueueEvent().sourceDevice);
 
   // Enqueued.
   SimulateGestureScrollUpdateEvent(8, -7, 0);
   EXPECT_EQ(4U, GestureEventQueueSize());
   EXPECT_EQ(WebGestureEvent::Touchscreen,
             GestureEventLastQueueEvent().sourceDevice);
 }
 
 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEvents) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   // Test coalescing of only GestureScrollUpdate events.
   // Simulate gesture events.
 
   // Sent.
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        WebGestureEvent::Touchscreen);
 
   // Sent.
   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
                        WebGestureEvent::Touchscreen);
@@ skipping 212 matching lines @@
   // Check that the queue is empty after ACK and no events get sent.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type);
   RunUntilIdle();
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(0U, GestureEventQueueSize());
 }
 
 TEST_F(GestureEventQueueTest, CoalescesMultiplePinchEventSequences) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   // Simulate a pinch sequence.
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        WebGestureEvent::Touchscreen);
   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
                        WebGestureEvent::Touchscreen);
 
   SimulateGestureScrollUpdateEvent(8, -4, 1);
   // Make sure that the queue contains what we think it should.
   WebGestureEvent merged_event = GestureEventLastQueueEvent();
   size_t expected_events_in_queue = 3;
@@ skipping 70 matching lines @@
   EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale);
   EXPECT_EQ(1, merged_event.modifiers);
   merged_event = GestureEventSecondFromLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX);
   EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY);
   EXPECT_EQ(1, merged_event.modifiers);
 }
 
 TEST_F(GestureEventQueueTest, CoalescesPinchSequencesWithEarlyAck) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        WebGestureEvent::Touchscreen);
   SendInputEventACK(WebInputEvent::GestureScrollBegin,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
 
   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
                        WebGestureEvent::Touchscreen);
   SendInputEventACK(WebInputEvent::GesturePinchBegin,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   // ScrollBegin and PinchBegin have been sent
@@ skipping 43 matching lines @@
   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
   EXPECT_EQ(2.f * 3.f * 4.f, last_acked_event().data.pinchUpdate.scale);
 
   EXPECT_EQ(0U, GestureEventQueueSize());
 }
 
 TEST_F(GestureEventQueueTest,
        DoesNotCoalescePinchGestureEventsWithDifferentModifiers) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   // Insert an event to force queueing of gestures.
   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(1U, GestureEventQueueSize());
 
   SimulateGestureScrollUpdateEvent(5, 5, 1);
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(2U, GestureEventQueueSize());
 
@@ skipping 43 matching lines @@
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
 
   SendInputEventACK(WebInputEvent::GesturePinchUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
   EXPECT_EQ(6.f, last_acked_event().data.pinchUpdate.scale);
   EXPECT_EQ(0U, GestureEventQueueSize());
 }
 
 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEventsIdentity) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   // Insert an event to force queueing of gestures.
   SimulateGestureEvent(WebInputEvent::GestureTapCancel,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(1U, GestureEventQueueSize());
 
   // Ensure that coalescing yields an identity transform for any pinch/scroll
   // pair combined with its inverse.
   SimulateGestureScrollUpdateEvent(5, 5, 1);
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
@@ skipping 94 matching lines @@
 
   SendInputEventACK(WebInputEvent::GestureShowPress,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(0U, GestureEventQueueSize());
   EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
 }
 
 // Tests an event with an async ack followed by an event with a sync ack.
 TEST_F(GestureEventQueueTest, AsyncThenSyncAck) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   SimulateGestureEvent(WebInputEvent::GestureTapDown,
                        WebGestureEvent::Touchscreen);
 
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(1U, GestureEventQueueSize());
   EXPECT_EQ(0U, GetAndResetAckedGestureEventCount());
 
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        WebGestureEvent::Touchscreen);
   set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(2U, GestureEventQueueSize());
   EXPECT_EQ(0U, GetAndResetAckedGestureEventCount());
 
   SendInputEventACK(WebInputEvent::GestureTapDown,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(0U, GestureEventQueueSize());
   EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
 }
 
 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEventWithSyncAck) {
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
+
   // Simulate a pinch sequence.
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 
   SimulateGestureScrollUpdateEvent(8, -4, 1);
   // Make sure that the queue contains what we think it should.
@@ skipping 26 matching lines @@
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type);
   EXPECT_EQ(0U, GestureEventQueueSize());
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
 }
 
 #if GTEST_HAS_PARAM_TEST
 TEST_P(GestureEventQueueWithSourceTest, GestureFlingCancelsFiltered) {
   WebGestureEvent::SourceDevice source_device = GetParam();
 
+  // Turn off debounce handling for test isolation.
+  DisableDebounce();
   // GFC without previous GFS is dropped.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(0U, GestureEventQueueSize());
 
   // GFC after previous GFS is dispatched and acked.
   SimulateGestureFlingStartEvent(0, -10, source_device);
   EXPECT_TRUE(FlingInProgress());
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
@@ skipping 75 matching lines @@
 INSTANTIATE_TEST_CASE_P(AllSources,
                         GestureEventQueueWithSourceTest,
                         testing::Values(WebGestureEvent::Touchscreen,
                                         WebGestureEvent::Touchpad));
 #endif  // GTEST_HAS_PARAM_TEST
 
 // Test that a GestureScrollEnd | GestureFlingStart are deferred during the
 // debounce interval, that Scrolls are not and that the deferred events are
 // sent after that timer fires.
 TEST_F(GestureEventQueueTest, DebounceDefersFollowingGestureEvents) {
-  SetUpForDebounce(3);
+  set_debounce_interval_time_ms(3);
 
   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(1U, GestureEventQueueSize());
   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
   EXPECT_TRUE(ScrollingInProgress());
 
   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
                        WebGestureEvent::Touchscreen);
@@ skipping 42 matching lines @@
       i++) {
     WebGestureEvent merged_event = GestureEventQueueEventAt(i);
     EXPECT_EQ(expected[i], merged_event.type);
   }
 }
 
 // Test that non-scroll events are deferred while scrolling during the debounce
 // interval and are discarded if a GestureScrollUpdate event arrives before the
 // interval end.
 TEST_F(GestureEventQueueTest, DebounceDropsDeferredEvents) {
-  SetUpForDebounce(3);
-
+  set_debounce_interval_time_ms(3);
   EXPECT_FALSE(ScrollingInProgress());
 
   SimulateGestureEvent(WebInputEvent::GestureScrollUpdate,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(1U, GestureEventQueueSize());
   EXPECT_EQ(0U, GestureEventDebouncingQueueSize());
   EXPECT_TRUE(ScrollingInProgress());
 
   // This event should get discarded.
@@ skipping 29 matching lines @@
   gesture_event.data.flingStart.velocityX = 0.f;
   gesture_event.data.flingStart.velocityY = 0.f;
   ASSERT_EQ(0U, GetAndResetSentGestureEventCount());
   ASSERT_EQ(0U, GestureEventQueueSize());
   EXPECT_FALSE(SimulateGestureEvent(gesture_event));
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(0U, GestureEventQueueSize());
 }
 
 }  // namespace content