Remove GestureEventFilter and clean up related bits assuming that we turn on

content/browser/renderer_host/input/gesture_event_filter_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 <vector>
 
 #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 "content/browser/renderer_host/input/gesture_event_filter.h"
+#include "content/browser/renderer_host/input/base_gesture_event_filter.h"
 #include "content/browser/renderer_host/input/mock_web_input_event_builders.h"
-#include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
 #include "content/port/common/input_event_ack_state.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 using base::TimeDelta;
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 
 namespace content {
 
 class GestureEventFilterTest : public testing::Test,
-                               public GestureEventFilterClient,
-                               public TouchpadTapSuppressionControllerClient {
+                               public GestureEventFilterClient {
  public:
   GestureEventFilterTest()
       : acked_gesture_event_count_(0),
         sent_gesture_event_count_(0) {}
 
   virtual ~GestureEventFilterTest() {}
 
   // testing::Test
   virtual void SetUp() OVERRIDE {
-    filter_.reset(new GestureEventFilter(this, this));
+    filter_.reset(new BaseGestureEventFilter(this));
   }
 
   virtual void TearDown() OVERRIDE {
     // Process all pending tasks to avoid leaks.
     RunUntilIdle();
     filter_.reset();
   }
 
   // GestureEventFilterClient
   virtual void SendGestureEventImmediately(
       const GestureEventWithLatencyInfo& event) OVERRIDE {
     ++sent_gesture_event_count_;
     last_immediately_sent_gesture_event_ = event.event;
   }
 
   virtual void OnGestureEventAck(
       const GestureEventWithLatencyInfo& event,
       InputEventAckState ack_result) OVERRIDE {
     ++acked_gesture_event_count_;
   }
 
-  // TouchpadTapSuppressionControllerClient
-  virtual void SendMouseEventImmediately(
-      const MouseEventWithLatencyInfo& event) OVERRIDE {
-  }
-
  protected:
 
   // Returns the result of |GestureEventFilter::ShouldForward()|.
   bool SimulateGestureEvent(const WebGestureEvent& gesture) {
     GestureEventWithLatencyInfo gesture_with_latency(gesture,
                                                      ui::LatencyInfo());
     if (filter()->ShouldForward(gesture_with_latency)) {
       ++sent_gesture_event_count_;
       return true;
     }
@@ skipping 78 matching lines @@
   }
 
   WebGestureEvent GestureEventQueueEventAt(int i) {
     return filter()->coalesced_gesture_events_.at(i).event;
   }
 
   bool ScrollingInProgress() {
     return filter()->scrolling_in_progress_;
   }
 
-  bool FlingInProgress() {
-    return filter()->fling_in_progress_;
-  }
-
   bool WillIgnoreNextACK() {
     return filter()->ignore_next_ack_;
   }
 
-  GestureEventFilter* filter() const {
+  BaseGestureEventFilter* filter() const {
     return filter_.get();
   }
 
  private:
-  scoped_ptr<GestureEventFilter> filter_;
+  scoped_ptr<BaseGestureEventFilter> filter_;
   size_t acked_gesture_event_count_;
   size_t sent_gesture_event_count_;
   WebGestureEvent last_immediately_sent_gesture_event_;
   base::MessageLoopForUI message_loop_;
 };
 
 #if GTEST_HAS_PARAM_TEST
 // This is for tests that are to be run for all source devices.
 class GestureEventFilterWithSourceTest
     : public GestureEventFilterTest,
@@ skipping 281 matching lines @@
 
   // Check that the queue is empty after ACK and no events get sent.
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   RunUntilIdle();
   EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
   EXPECT_EQ(0U, GestureEventLastQueueEventSize());
 }
 
 #if GTEST_HAS_PARAM_TEST
-TEST_P(GestureEventFilterWithSourceTest, GestureFlingCancelsFiltered) {
-  WebGestureEvent::SourceDevice source_device = GetParam();
-
-  // Turn off debounce handling for test isolation.
-  set_debounce_interval_time_ms(0);
-  // GFC without previous GFS is dropped.
-  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
-  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
-  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
-
-  // GFC after previous GFS is dispatched and acked.
-  SimulateGestureFlingStartEvent(0, -10, source_device);
-  EXPECT_TRUE(FlingInProgress());
-  SendInputEventACK(WebInputEvent::GestureFlingStart,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  RunUntilIdle();
-  EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
-  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
-  EXPECT_FALSE(FlingInProgress());
-  EXPECT_EQ(2U, GetAndResetSentGestureEventCount());
-  SendInputEventACK(WebInputEvent::GestureFlingCancel,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  RunUntilIdle();
-  EXPECT_EQ(1U, GetAndResetAckedGestureEventCount());
-  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
-
-  // GFC before previous GFS is acked.
-  SimulateGestureFlingStartEvent(0, -10, source_device);
-  EXPECT_TRUE(FlingInProgress());
-  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
-  EXPECT_FALSE(FlingInProgress());
-  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
-  EXPECT_EQ(2U, GestureEventLastQueueEventSize());
-
-  // Advance state realistically.
-  SendInputEventACK(WebInputEvent::GestureFlingStart,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  RunUntilIdle();
-  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
-  SendInputEventACK(WebInputEvent::GestureFlingCancel,
-                    INPUT_EVENT_ACK_STATE_CONSUMED);
-  RunUntilIdle();
-  EXPECT_EQ(2U, GetAndResetAckedGestureEventCount());
-  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
-  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
-
-  // GFS is added to the queue if another event is pending
-  SimulateGestureScrollUpdateEvent(8, -7, 0);
-  SimulateGestureFlingStartEvent(0, -10, source_device);
-  EXPECT_EQ(2U, GestureEventLastQueueEventSize());
-  EXPECT_EQ(1U, GetAndResetSentGestureEventCount());
-  WebGestureEvent merged_event = GestureEventLastQueueEvent();
-  EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
-  EXPECT_TRUE(FlingInProgress());
-  EXPECT_EQ(2U, GestureEventLastQueueEventSize());
-
-  // GFS in queue means that a GFC is added to the queue
-  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
-  merged_event =GestureEventLastQueueEvent();
-  EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
-  EXPECT_FALSE(FlingInProgress());
-  EXPECT_EQ(3U, GestureEventLastQueueEventSize());
-
-  // Adding a second GFC is dropped.
-  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
-  EXPECT_FALSE(FlingInProgress());
-  EXPECT_EQ(3U, GestureEventLastQueueEventSize());
-
-  // Adding another GFS will add it to the queue.
-  SimulateGestureFlingStartEvent(0, -10, source_device);
-  merged_event = GestureEventLastQueueEvent();
-  EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
-  EXPECT_TRUE(FlingInProgress());
-  EXPECT_EQ(4U, GestureEventLastQueueEventSize());
-
-  // GFS in queue means that a GFC is added to the queue
-  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
-  merged_event = GestureEventLastQueueEvent();
-  EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
-  EXPECT_FALSE(FlingInProgress());
-  EXPECT_EQ(5U, GestureEventLastQueueEventSize());
-
-  // Adding another GFC with a GFC already there is dropped.
-  SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device);
-  merged_event = GestureEventLastQueueEvent();
-  EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
-  EXPECT_FALSE(FlingInProgress());
-  EXPECT_EQ(5U, GestureEventLastQueueEventSize());
-}
-
 INSTANTIATE_TEST_CASE_P(AllSources,
                         GestureEventFilterWithSourceTest,
                         testing::Values(WebGestureEvent::Touchscreen,
                                         WebGestureEvent::Touchpad));
 #endif  // GTEST_HAS_PARAM_TEST
 
 // Test that GestureShowPress events don't wait for ACKs.
 TEST_F(GestureEventFilterTest, GestureShowPressIsAsync) {
   SimulateGestureEvent(WebInputEvent::GestureShowPress,
                        WebGestureEvent::Touchscreen);
@@ skipping 144 matching lines @@
       WebInputEvent::GestureScrollUpdate,
       WebInputEvent::GestureScrollUpdate};
 
   for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
       i++) {
     WebGestureEvent merged_event = GestureEventQueueEventAt(i);
     EXPECT_EQ(expected[i], merged_event.type);
   }
 }
 
-TEST_F(GestureEventFilterTest, DropZeroVelocityFlings) {
-  WebGestureEvent gesture_event;
-  gesture_event.type = WebInputEvent::GestureFlingStart;
-  gesture_event.sourceDevice = WebGestureEvent::Touchpad;
-  gesture_event.data.flingStart.velocityX = 0.f;
-  gesture_event.data.flingStart.velocityY = 0.f;
-  ASSERT_EQ(0U, GetAndResetSentGestureEventCount());
-  ASSERT_EQ(0U, GestureEventLastQueueEventSize());
-  EXPECT_FALSE(SimulateGestureEvent(gesture_event));
-  EXPECT_EQ(0U, GetAndResetSentGestureEventCount());
-  EXPECT_EQ(0U, GestureEventLastQueueEventSize());
-}
-
 }  // namespace content