Use new gesture event fields in more places

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 338 matching lines @@
 
   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);
   }
 
-  // Inject synthetic WebGestureEvent instances.
-  void SimulateGestureEvent(float dX, float dY, int modifiers,
-                            WebInputEvent::Type type) {
+  // Inject simple synthetic WebGestureEvent instances.
+  void SimulateGestureEvent(WebInputEvent::Type type) {
     WebGestureEvent gesture_event;
     gesture_event.type = type;
-    gesture_event.deltaX = dX;
-    gesture_event.deltaY = dY;
+    host_->ForwardGestureEvent(gesture_event);
+  }
+
+  void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) {

[rjkroege, 2012/08/31 00:39:35]

it might be conservative to preserve the setting of the delta* values until you
remove that code?

[Rick Byers, 2012/08/31 14:49:29]

Sure. I kind of liked the idea of showing that the unit tests passed without
writing to the obsolete fields, but there's no real harm.  Done.

+    WebGestureEvent gesture_event;
+    gesture_event.type = WebInputEvent::GestureScrollUpdate;
+    gesture_event.data.scrollUpdate.deltaX = dX;
+    gesture_event.data.scrollUpdate.deltaY = dY;
     gesture_event.modifiers = modifiers;
     host_->ForwardGestureEvent(gesture_event);
   }
 
+  // Inject simple synthetic WebGestureEvent instances.
+  void SimulateGestureFlingStartEvent(float velocityX, float velocityY) {
+    WebGestureEvent gesture_event;
+    gesture_event.type = WebInputEvent::GestureFlingStart;
+    gesture_event.data.flingStart.velocityX = velocityX;
+    gesture_event.data.flingStart.velocityY = velocityY;
+    host_->ForwardGestureEvent(gesture_event);
+  }
+
   MessageLoopForUI message_loop_;
 
   scoped_ptr<content::TestBrowserContext> browser_context_;
   RenderWidgetHostProcess* process_;  // Deleted automatically by the widget.
   scoped_ptr<MockRenderWidgetHostDelegate> delegate_;
   scoped_ptr<MockRenderWidgetHost> host_;
   scoped_ptr<TestView> view_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostTest);
 };
@@ skipping 419 matching lines @@
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0U, process_->sink().message_count());
 }
 
 TEST_F(RenderWidgetHostTest, CoalescesGesturesEvents) {
   process_->sink().ClearMessages();
   // Only GestureScrollUpdate events can be coalesced.
   // Simulate gesture events.
 
   // Sent.
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureScrollBegin);
+  SimulateGestureEvent(WebInputEvent::GestureScrollBegin);
 
   // Enqueued.
-  SimulateGestureEvent(8, -5, 0, WebInputEvent::GestureScrollUpdate);
+  SimulateGestureScrollUpdateEvent(8, -5, 0);
 
   // 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);
+  SimulateGestureScrollUpdateEvent(8, -6, 0);
 
   // 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);
-  EXPECT_EQ(-11, merged_event.deltaY);
+  EXPECT_EQ(16, merged_event.data.scrollUpdate.deltaX);
+  EXPECT_EQ(-11, merged_event.data.scrollUpdate.deltaY);
 
   // Enqueued.
-  SimulateGestureEvent(8, -7, 1, WebInputEvent::GestureScrollUpdate);
+  SimulateGestureScrollUpdateEvent(8, -7, 1);
 
   // Check that we didn't wrongly coalesce.
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type);
   EXPECT_EQ(1, merged_event.modifiers);
 
   // Different.
-  SimulateGestureEvent(9, -8, 0, WebInputEvent::GestureScrollEnd);
+  SimulateGestureEvent(WebInputEvent::GestureScrollEnd);
 
   // Check that only the first event was sent.
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
               ViewMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the ACK sends the second message.
   SendInputEventACK(WebInputEvent::GestureScrollBegin, true);
   MessageLoop::current()->RunAllPending();
@@ skipping 20 matching lines @@
 
   // After the final ack, the queue should be empty.
   SendInputEventACK(WebInputEvent::GestureScrollEnd, true);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0U, process_->sink().message_count());
 }
 
 TEST_F(RenderWidgetHostTest, GestureFlingCancelsFiltered) {
   process_->sink().ClearMessages();
   // GFC without previous GFS is dropped.
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(0U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
   // GFC after previous GFS is dispatched and acked.
   process_->sink().ClearMessages();
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
+  SimulateGestureFlingStartEvent(0, -10);
   EXPECT_TRUE(host_->FlingInProgress());
   SendInputEventACK(WebInputEvent::GestureFlingStart, true);
   MessageLoop::current()->RunAllPending();
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
   EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(2U, process_->sink().message_count());
   SendInputEventACK(WebInputEvent::GestureFlingCancel, true);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
   // GFC before previous GFS is acked.
   process_->sink().ClearMessages();
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
+  SimulateGestureFlingStartEvent(0, -10);
   EXPECT_TRUE(host_->FlingInProgress());
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
   EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(2U, host_->GestureEventLastQueueEventSize());
 
   // 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);
+  SimulateGestureScrollUpdateEvent(8, -7, 0);
+  SimulateGestureFlingStartEvent(0, -10);
   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_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);
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
   merged_event =host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
   EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
 
   // Adding a second GFC is dropped.
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
   EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(3U, host_->GestureEventLastQueueEventSize());
 
   // Adding another GFS will add it to the queue.
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingStart);
+  SimulateGestureFlingStartEvent(0, -10);
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type);
   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);
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
   EXPECT_FALSE(host_->FlingInProgress());
   EXPECT_EQ(5U, host_->GestureEventLastQueueEventSize());
 
   // Adding another GFC with a GFC already there is dropped.
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureFlingCancel);
+  SimulateGestureEvent(WebInputEvent::GestureFlingCancel);
   merged_event = host_->GestureEventLastQueueEvent();
   EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type);
   EXPECT_FALSE(host_->FlingInProgress());
   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);
+  SimulateGestureEvent(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);
+  SimulateGestureEvent(WebInputEvent::GestureTapDown);
   EXPECT_EQ(0U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureTap);
+  SimulateGestureEvent(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 sent 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);
+  SimulateGestureEvent(WebInputEvent::GestureTapDown);
   EXPECT_EQ(0U, process_->sink().message_count());
   EXPECT_EQ(0U, host_->GestureEventLastQueueEventSize());
 
-  SimulateGestureEvent(0, -10, 0, WebInputEvent::GestureScrollBegin);
+  SimulateGestureEvent(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_EQ(1U, host_->GestureEventLastQueueEventSize());
 
   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());
 }
@@ skipping 62 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());
 }