Suppress touchscreen tap immediately after a GestureFlingCancel

content/browser/renderer_host/render_widget_host_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/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/backing_store.h"
@@ skipping 160 matching lines @@
   }
 
   bool FlingInProgress() {
     return gesture_event_filter_->fling_in_progress_;
   }
 
   bool WillIgnoreNextACK() {
     return gesture_event_filter_->ignore_next_ack_;
   }
 
-  TapSuppressionState TapSuppressionControllerState() {
+  TapSuppressionState TouchpadTapSuppressionControllerState() {
     TouchpadTapSuppressionController* tsc =
-        gesture_event_filter_->tap_suppression_controller_.get();
+        gesture_event_filter_->touchpad_tap_suppression_controller_.get();
     return static_cast<TapSuppressionState>(tsc->controller_->state_);
   }
 
   void SetupForOverscrollControllerTest() {
     SetOverscrollControllerEnabled(true);
     overscroll_delegate_.reset(new TestOverscrollDelegate);
     overscroll_controller_->set_delegate(overscroll_delegate_.get());
   }
 
   void set_maximum_tap_gap_time_ms(int delay_ms) {
@@ skipping 1675 matching lines @@
 TEST_F(RenderWidgetHostTest, GFCAckBeforeMouseFast) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());

[rjkroege, 2013/03/07 22:56:21]

a helper method on MockRenderWidgetHost might have made this a smaller change.

[mohsen, 2013/03/08 00:14:58]

These unit tests are going to be changed soon (because of the refactoring in
TSC). I'll consider this point then.

   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_LAST_CANCEL_STOPPED_FLING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when GestureFlingCancel Ack comes
 // before MouseDown, but there is a small delay between MouseDown and MouseUp.
 TEST_F(RenderWidgetHostTest, GFCAckBeforeMouseInsufficientlyLateMouseUp) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_LAST_CANCEL_STOPPED_FLING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Wait less than allowed delay between MouseDown and MouseUp, so they are
   // still considered a tap.
   // TODO(mohsen): The amounts used for delays are too much and will slow down
   // the tests. A better way is to reduce the allowed delays in TSC before each
   // test. So, they should be made accessible and configurable.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           MessageLoop::QuitClosure(),
                                           TimeDelta::FromMilliseconds(100));
   MessageLoop::current()->Run();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when GestureFlingCancel Ack comes
 // before MouseDown, but there is a long delay between MouseDown and MouseUp.
 TEST_F(RenderWidgetHostTest, GFCAckBeforeMouseSufficientlyLateMouseUp) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send processed GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_LAST_CANCEL_STOPPED_FLING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed, for now.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Wait more than allowed delay between MosueDown and MouseUp, so they are
   // not considered a tap. This should release the previously suppressed
   // MouseDown.
   // TODO(mohsen): The amounts used for delays are too much and will slow down
   // the tests. A better way is to reduce the allowed delays in TSC before each
   // test. So, they should be made configurable and accessible here.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           MessageLoop::QuitClosure(),
                                           TimeDelta::FromMilliseconds(300));
   MessageLoop::current()->Run();
   EXPECT_EQ(3U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should not be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(4U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when GestureFlingCancel Ack comes
 // before MouseDown, but there is a small delay between the Ack and MouseDown.
 TEST_F(RenderWidgetHostTest, GFCAckBeforeMouseInsufficientlyLateMouseDown) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_LAST_CANCEL_STOPPED_FLING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Wait less than allowed delay between GestureFlingCancel and MouseDown,
   // so the MouseDown is still considered associated with the
   // GestureFlingCancel.
   // TODO(mohsen): The amounts used for delays are too much and will slow down
   // the tests. A better way is to reduce the allowed delays in TSC before each
   // test. So, they should be made configurable and accessible here.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           MessageLoop::QuitClosure(),
                                           TimeDelta::FromMilliseconds(300));
   MessageLoop::current()->Run();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_LAST_CANCEL_STOPPED_FLING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when GestureFlingCancel Ack comes
 // before MouseDown, but there is a long delay between the Ack and MouseDown.
 TEST_F(RenderWidgetHostTest, GFCAckBeforeMouseSufficientlyLateMouseDown) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_LAST_CANCEL_STOPPED_FLING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Wait more than allowed delay between GestureFlingCancel and MouseDown,
   // so the MouseDown is not considered associated with the GestureFlingCancel.
   // TODO(mohsen): The amounts used for delays are too much and will slow down
   // the tests. A better way is to reduce the allowed delays in TSC before each
   // test. So, they should be made configurable and accessible here.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           MessageLoop::QuitClosure(),
                                           TimeDelta::FromMilliseconds(500));
   MessageLoop::current()->Run();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_LAST_CANCEL_STOPPED_FLING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should not be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(3U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should not be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(4U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when unprocessed GestureFlingCancel
 // Ack comes after MouseDown and everything happens without any delay.
 TEST_F(RenderWidgetHostTest, GFCAckUnprocessedAfterMouseFast) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed, for now.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send unprocessed GestureFlingCancel Ack. This should release the
   // previously suppressed MouseDown.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should not be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(4U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when processed GestureFlingCancel
 // Ack comes after MouseDown and everything happens without any delay.
 TEST_F(RenderWidgetHostTest, GFCAckProcessedAfterMouseFast) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when GestureFlingCancel Ack comes
 // after MouseDown and there is a small delay between the Ack and MouseUp.
 TEST_F(RenderWidgetHostTest, GFCAckAfterMouseInsufficientlyLateMouseUp) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Wait less than allowed delay between MouseDown and MouseUp, so they are
   // still considered as a tap.
   // TODO(mohsen): The amounts used for delays are too much and will slow down
   // the tests. A better way is to reduce the allowed delays in TSC before each
   // test. So, they should be made configurable and accessible here.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           MessageLoop::QuitClosure(),
                                           TimeDelta::FromMilliseconds(100));
   MessageLoop::current()->Run();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 
 // Test TouchpadTapSuppressionController for when GestureFlingCancel Ack comes
 // after MouseDown and there is a long delay between the Ack and MouseUp.
 TEST_F(RenderWidgetHostTest, GFCAckAfterMouseSufficientlyLateMouseUp) {
   process_->sink().ClearMessages();
 
   // Send GestureFlingStart.
   SimulateGestureFlingStartEvent(0, -10, WebGestureEvent::Touchpad);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingStart,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingStart Ack.
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_TRUE(host_->FlingInProgress());
 
   // Send GestureFlingCancel.
   SimulateGestureEvent(WebInputEvent::GestureFlingCancel,
                        WebGestureEvent::Touchpad);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_GFC_IN_PROGRESS,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseDown. This MouseDown should be suppressed, for now.
   SimulateMouseEvent(WebInputEvent::MouseDown);
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             host_->GestureEventLastQueueEvent().type);
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send GestureFlingCancel Ack.
   SendInputEventACK(WebInputEvent::GestureFlingCancel,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(2U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_TAP_DOWN_STASHED,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Wait more than allowed delay between MouseDown and MouseUp, so they are
   // not considered as a tap. This should release the previously suppressed
   // MouseDown.
   // TODO(mohsen): The amounts used for delays are too much and will slow down
   // the tests. A better way is to reduce the allowed delays in TSC before each
   // test. So, they should be made configurable and accessible here.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           MessageLoop::QuitClosure(),
                                           TimeDelta::FromMilliseconds(300));
   MessageLoop::current()->Run();
   EXPECT_EQ(3U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 
   // Send MouseUp. This MouseUp should not be suppressed.
   SimulateMouseEvent(WebInputEvent::MouseUp);
   EXPECT_EQ(4U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
-            host_->TapSuppressionControllerState());
+            host_->TouchpadTapSuppressionControllerState());
   EXPECT_FALSE(host_->FlingInProgress());
 }
 #endif  // defined(USE_AURA)
 
 // Tests that touch-events are queued properly.
 TEST_F(RenderWidgetHostTest, TouchEventQueue) {
   process_->sink().ClearMessages();
 
   PressTouchPoint(1, 1);
   SendTouchEvent();
@@ skipping 1386 matching lines @@
   EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
 
   // Since the overscroll mode has been reset, the next scroll update events
   // should reach the renderer.
   SimulateGestureScrollUpdateEvent(-20, 0, 0);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(OVERSCROLL_NONE, host_->overscroll_mode());
 }
 
 }  // namespace content