Defer GestureTapDown events briefly.

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 229 matching lines @@
   }
 
   unsigned GestureEventLastQueueEventSize() {
     return gesture_event_filter_->coalesced_gesture_events_.size();
   }
 
   bool FlingInProgress() {
     return gesture_event_filter_->fling_in_progress_;
   }
 
+  void set_maximum_tap_gap_time_ms(int delay_ms) {
+    gesture_event_filter_->maximum_tap_gap_time_ms_ = delay_ms;
+  }
+
  protected:
   virtual void NotifyRendererUnresponsive() OVERRIDE {
     unresponsive_timer_fired_ = true;
   }
 
  private:
   bool unresponsive_timer_fired_;
 };
 
 // MockPaintingObserver --------------------------------------------------------
@@ skipping 542 matching lines @@
   // Simulate gesture events.
 
   // Sent.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureScrollBegin);
 
   // Enqueued.
   SimulateGestureEvent(8, -5, 0, WebInputEvent::GestureScrollUpdate);
 
   // Make sure that the queue contains what we think it should.
   WebGestureEvent merged_event = host_->GestureEventLastQueueEvent();
+  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
 
   // Coalesced.
   SimulateGestureEvent(8, -6, 0, WebInputEvent::GestureScrollUpdate);
 
   // Check that coalescing updated the correct values.
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(0, merged_event.modifiers);
   EXPECT_EQ(16, merged_event.deltaX);
@@ skipping 66 matching lines @@
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
   // GFC before previous GFS is acked.
   process_->sink().ClearMessages();
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
   EXPECT_TRUE(host_->FlingInProgress());
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
   EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());

[rjkroege, 2012/08/16 15:07:15]

i keep the event being handled by the renderer in the queue instead of separate
from it.

 
   // Advance state realistically.
   SendInputEventACK(WebInputEvent::GestureFlingStart, true);
   MessageLoop::current()->RunAllPending();
   SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
   // GFS is added to the queue if another event is pending
   process_->sink().ClearMessages();
   SimulateGestureEvent(8, -7, 0, WebInputEvent::GestureScrollUpdate);
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
+  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
   EXPECT_EQ(1U, process_->sink().message_count());
   WebGestureEvent merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
-  EXPECT_FALSE(host_->FlingInProgress());
-  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
+  EXPECT_TRUE(host_->FlingInProgress());
+  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
 
   // GFS in queue means that a GFC is added to the queue
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
   merged_event =host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
   EXPECT_FALSE(host_->FlingInProgress());
-  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
-
+  EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
 
   // Adding a second GFC is dropped.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
   EXPECT_FALSE(host_->FlingInProgress());
-  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
 
   // Adding another GFS will add it to the queue.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
-  EXPECT_FALSE(host_->FlingInProgress());
-  EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
+  EXPECT_TRUE(host_->FlingInProgress());
+  EXPECT_EQ(4U, host_->GestureEventLastQueueEventSize());
 
   // GFS in queue means that a GFC is added to the queue
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
   EXPECT_FALSE(host_->FlingInProgress());
-  EXPECT_EQ(4U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(5U, host_->GestureEventLastQueueEventSize());
 
   // Adding another GFC with a GFC already there is dropped.
   SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
   EXPECT_FALSE(host_->FlingInProgress());
-  EXPECT_EQ(4U, host_->GestureEventLastQueueEventSize());
+  EXPECT_EQ(5U, host_->GestureEventLastQueueEventSize());
+}
+
+// Test that GestureTapDown events are deferred.
+TEST_F(RenderWidgetHostTest, DeferredGestureTapDown) {
+  process_->sink().ClearMessages();
+
+  // Set some sort of short deferral timeout
+  host_->set_maximum_tap_gap_time_ms(5);
+
+  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureTapDown);
+  EXPECT_EQ(0U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+
+  // Wait long enough for first timeout and see if it fired.
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, MessageLoop::QuitClosure(), TimeDelta::FromMilliseconds(10));
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
+}
+
+// Test that GestureTapDown events are sent immediately on GestureTap.
+TEST_F(RenderWidgetHostTest, DeferredGestureTapDownSentOnTap) {
+  process_->sink().ClearMessages();
+
+  // Set some sort of short deferral timeout
+  host_->set_maximum_tap_gap_time_ms(5);
+
+  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureTapDown);
+  EXPECT_EQ(0U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+
+  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureTap);
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
+
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, MessageLoop::QuitClosure(), TimeDelta::FromMilliseconds(10));
+  MessageLoop::current()->Run();
+
+  // If the deferral timer incorrectly fired, it send an extra message.
+  EXPECT_EQ(1U, process_->sink().message_count());
+}
+
+// Test that scroll events during the deferral internal drop the GestureTapDown.
+TEST_F(RenderWidgetHostTest, DeferredGestureTapDownAnulledOnScroll) {
+  process_->sink().ClearMessages();
+
+  // Set some sort of short deferral timeout
+  host_->set_maximum_tap_gap_time_ms(5);
+
+  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureTapDown);
+  EXPECT_EQ(0U, process_->sink().message_count());
+  EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
+
+  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureScrollBegin);
+  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
+  WebGestureEvent merged_event = host_->GestureEventLastQueueEvent();
+
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, MessageLoop::QuitClosure(), TimeDelta::FromMilliseconds(10));
+  MessageLoop::current()->Run();
+
+  // If the deferral timer incorrectly fired, it will send an extra message.
+  EXPECT_EQ(1U, process_->sink().message_count());
 }
 
 // Test that the hang monitor timer expires properly if a new timer is started
 // while one is in progress (see crbug.com/11007).
 TEST_F(RenderWidgetHostTest, DontPostponeHangMonitorTimeout) {
   // Start with a short timeout.
   host_->StartHangMonitorTimeout(TimeDelta::FromMilliseconds(10));
 
   // Immediately try to add a long 30 second timeout.
   EXPECT_FALSE(host_->unresponsive_timer_fired());
@@ skipping 53 matching lines @@
   SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
   SimulateKeyboardEvent(WebInputEvent::RawKeyDown);
   SendInputEventACK(WebInputEvent::RawKeyDown, true);
 
   // Wait long enough for first timeout and see if it fired.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, MessageLoop::QuitClosure(), TimeDelta::FromMilliseconds(40));
   MessageLoop::current()->Run();
   EXPECT_TRUE(host_->unresponsive_timer_fired());
 }