Suppress sending mousedown / mouseup when in fling

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"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/browser/renderer_host/overscroll_controller_delegate.h"
+#include "content/browser/renderer_host/tap_suppression_controller.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/renderer_host/touch_event_queue.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/test/mock_render_process_host.h"
@@ skipping 85 matching lines @@
   using RenderWidgetHostImpl::OnMsgPaintAtSizeAck;
   using RenderWidgetHostImpl::OnMsgUpdateRect;
   using RenderWidgetHostImpl::RendererExited;
   using RenderWidgetHostImpl::in_flight_size_;
   using RenderWidgetHostImpl::is_hidden_;
   using RenderWidgetHostImpl::resize_ack_pending_;
   using RenderWidgetHostImpl::gesture_event_filter_;
   using RenderWidgetHostImpl::touch_event_queue_;
   using RenderWidgetHostImpl::overscroll_controller_;
 
+  enum TapSuppressionState {
+    TSC_NOTHING = TapSuppressionController::NOTHING,
+    TSC_GFC_IN_PROGRESS = TapSuppressionController::GFC_IN_PROGRESS,
+    TSC_MD_STASHED = TapSuppressionController::MD_STASHED,
+    TSC_LAST_CANCEL_STOPPED_FLING =
+      TapSuppressionController::LAST_CANCEL_STOPPED_FLING,
+  };
+
   bool unresponsive_timer_fired() const {
     return unresponsive_timer_fired_;
   }
 
   void set_hung_renderer_delay_ms(int delay_ms) {
     hung_renderer_delay_ms_ = delay_ms;
   }
 
   WebGestureEvent GestureEventLastQueueEvent() {
     return gesture_event_filter_->coalesced_gesture_events_.back();
@@ skipping 16 matching lines @@
   }
 
   bool ScrollingInProgress() {
     return gesture_event_filter_->scrolling_in_progress_;
   }
 
   bool FlingInProgress() {
     return gesture_event_filter_->fling_in_progress_;
   }
 
+  TapSuppressionState TapSuppressionControllerState() {
+    return static_cast<TapSuppressionState>(
+        gesture_event_filter_->tap_suppression_controller_->state_);
+  }
+
   void SetupForOverscrollControllerTest() {
     InitializeOverscrollController();
     overscroll_delegate_.reset(new TestOverscrollDelegate);
     overscroll_controller_->set_delegate(overscroll_delegate_.get());
   }
 
   void set_maximum_tap_gap_time_ms(int delay_ms) {
     gesture_event_filter_->maximum_tap_gap_time_ms_ = delay_ms;
   }
 
@@ skipping 338 matching lines @@
     host_->OnMessageReceived(*response);
   }
 
   void SimulateKeyboardEvent(WebInputEvent::Type type) {
     NativeWebKeyboardEvent key_event;
     key_event.type = type;
     key_event.windowsKeyCode = ui::VKEY_L;  // non-null made up value.
     host_->ForwardKeyboardEvent(key_event);
   }
 
+  void SimulateMouseEvent(WebInputEvent::Type type) {
+    WebMouseWheelEvent mouse_event;
+    mouse_event.type = type;
+    host_->ForwardMouseEvent(mouse_event);
+  }
+
   void SimulateWheelEvent(float dX, float dY, int modifiers) {
     WebMouseWheelEvent wheel_event;
     wheel_event.type = WebInputEvent::MouseWheel;
     wheel_event.deltaX = dX;
     wheel_event.deltaY = dY;
     wheel_event.modifiers = modifiers;
     host_->ForwardWheelEvent(wheel_event);
   }
 
   void SimulateMouseMove(int x, int y, int modifiers) {
@@ skipping 979 matching lines @@
       WebInputEvent::GestureScrollUpdate,
       WebInputEvent::GestureScrollUpdate};
 
   for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type);
       i++) {
     WebGestureEvent merged_event = host_->GestureEventQueueEventAt(i);
     EXPECT_EQ(expected[i], merged_event.type);
   }
 }
 
+#if defined(USE_AURA)
+// Test TapSuppressionController for when GestureFlingCancel Ack comes before
+// MouseDown and everything happens without any delays.
+TEST_F(RenderWidgetHostTest, GFCAckBeforeMouseFast) {
+  process_->sink().ClearMessages();
+
+  // Send GestureFlingStart.
+  SimulateGestureFlingStartEvent(0, -10);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send processed GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  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());
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  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());
+  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());
+  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());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send unprocessed GestureFlingCancel Ack. This should release the
+  // previously suppressed MouseDown.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, false);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(3U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(2U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(2U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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());
+  EXPECT_FALSE(host_->FlingInProgress());
+}
+
+// Test TapSuppressionController 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);
+  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());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingStart Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingStart, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_NOTHING,
+            host_->TapSuppressionControllerState());
+  EXPECT_TRUE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel.
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
+  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());
+  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_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  EXPECT_FALSE(host_->FlingInProgress());
+
+  // Send GestureFlingCancel Ack.
+  SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
+  MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(2U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(MockRenderWidgetHost::TSC_MD_STASHED,
+            host_->TapSuppressionControllerState());
+  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());
+  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());
+  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();
   EXPECT_EQ(1U, process_->sink().message_count());
   process_->sink().ClearMessages();
 
   // The second touch should not be sent since one is already in queue.
@@ skipping 914 matching lines @@
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
 
   SendInputEventACK(WebKit::WebInputEvent::GestureScrollEnd, false);
   EXPECT_EQ(0U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(0U, host_->GestureEventDebouncingQueueSize());
 }
 
 }  // namespace content