Notify Blink about start of gesture scroll through a queued event.

content/browser/renderer_host/input/input_router_impl_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 256 matching lines @@
     touch_event_.SetTimestamp(timestamp);
   }
 
   uint32_t SendTouchEvent() {
     uint32_t touch_event_id = touch_event_.uniqueTouchEventId;
     input_router_->SendTouchEvent(TouchEventWithLatencyInfo(touch_event_));
     touch_event_.ResetPoints();
     return touch_event_id;
   }
 
+  void ProcessSyntheticInputEventAck(WebInputEvent::Type type) {

[tdresser, 2016/04/01 14:50:24]

Let's make this method more specific - something like
AckTouchScrollStartedNotification, and add a comment on why it's needed.

[mustaq, 2016/04/01 18:31:04]

Done.

+    ui::LatencyInfo latency_info;
+    input_router_->ProcessInputEventAck(type, INPUT_EVENT_ACK_STATE_IGNORED,
+        latency_info, 0, InputRouterImpl::IGNORING_DISPOSITION);
+  }
+
   int PressTouchPoint(int x, int y) {
     return touch_event_.PressPoint(x, y);
   }
 
   void MoveTouchPoint(int index, int x, int y) {
     touch_event_.MovePoint(index, x, y);
   }
 
   void ReleaseTouchPoint(int index) {
     touch_event_.ReleasePoint(index);
@@ skipping 809 matching lines @@
       EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
       EXPECT_EQ(0, client_->in_flight_event_count());
       EXPECT_FALSE(HasPendingEvents());
       continue;
     }
 
     SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen);
     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
     EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
     EXPECT_EQ(0, client_->in_flight_event_count());
+
+    if (type == WebInputEvent::GestureScrollBegin)
+      ProcessSyntheticInputEventAck(WebInputEvent::TouchScrollStarted);
     EXPECT_FALSE(HasPendingEvents());
   }
 }
 
 TEST_F(InputRouterImplTest, MouseTypesIgnoringAck) {
   int start_type = static_cast<int>(WebInputEvent::MouseDown);
   int end_type = static_cast<int>(WebInputEvent::ContextMenu);
   ASSERT_LT(start_type, end_type);
   for (int i = start_type; i <= end_type; ++i) {
     WebInputEvent::Type type = static_cast<WebInputEvent::Type>(i);
@@ skipping 110 matching lines @@
 }
 
 // Test that GestureShowPress events don't get out of order due to
 // ignoring their acks.
 TEST_F(InputRouterImplTest, GestureShowPressIsInOrder) {
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 
-
   // GesturePinchBegin ignores its ack.
   SimulateGestureEvent(WebInputEvent::GesturePinchBegin,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
 
   // GesturePinchUpdate waits for an ack.
   // This also verifies that GesturePinchUpdates for touchscreen are sent
   // to the renderer (in contrast to the TrackpadPinchUpdate test).
   SimulateGestureEvent(WebInputEvent::GesturePinchUpdate,
@@ skipping 438 matching lines @@
 // Test that the router will call the client's |DidFlush| after all fling
 // animations have completed.
 TEST_F(InputRouterImplTest, InputFlushAfterFling) {
   EXPECT_FALSE(HasPendingEvents());
 
   // Simulate a fling.
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        blink::WebGestureDeviceTouchscreen);
   SimulateGestureEvent(WebInputEvent::GestureFlingStart,
                        blink::WebGestureDeviceTouchscreen);
+  ProcessSyntheticInputEventAck(WebInputEvent::TouchScrollStarted);

[tdresser, 2016/04/01 14:50:24]

Shouldn't we assert somewhere that we output TouchScrollStarted events?

[mustaq, 2016/04/01 18:31:04]

The existing tests here only care about events passed upstream of
input_event_router, between RH & the router. The TouchScrollStarted event is
strictly downstream, and I have the check already in TouchEventQueueTest.

Testing TouchScrollStarted here would require pulling TouchEventQueueTest logic
into this file, which violates the "unittest" concept.

I added queue size checks below wherever we have only the new event in the
queue.

   EXPECT_TRUE(HasPendingEvents());
 
   // If the fling is unconsumed, the flush is complete.
   RequestNotificationWhenFlushed();
   EXPECT_EQ(0U, GetAndResetDidFlushCount());
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        blink::WebGestureDeviceTouchscreen);
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  ProcessSyntheticInputEventAck(WebInputEvent::TouchScrollStarted);
   EXPECT_FALSE(HasPendingEvents());
+
   EXPECT_EQ(1U, GetAndResetDidFlushCount());
 
   // Simulate a second fling.
   SimulateGestureEvent(WebInputEvent::GestureFlingStart,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_TRUE(HasPendingEvents());
 
   // If the fling is consumed, the flush is complete only when the renderer
   // reports that is has ended.
   RequestNotificationWhenFlushed();
   EXPECT_EQ(0U, GetAndResetDidFlushCount());
   SendInputEventACK(WebInputEvent::GestureFlingStart,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_TRUE(HasPendingEvents());
   EXPECT_EQ(0U, GetAndResetDidFlushCount());
 
   // The fling end notification should signal that the router is flushed.
   input_router()->OnMessageReceived(InputHostMsg_DidStopFlinging(0));
   EXPECT_EQ(1U, GetAndResetDidFlushCount());
 
   // Even flings consumed by the client require a fling-end notification.
   client_->set_filter_state(INPUT_EVENT_ACK_STATE_CONSUMED);
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        blink::WebGestureDeviceTouchscreen);
   SimulateGestureEvent(WebInputEvent::GestureFlingStart,
                        blink::WebGestureDeviceTouchscreen);
+  ProcessSyntheticInputEventAck(WebInputEvent::TouchScrollStarted);
   ASSERT_TRUE(HasPendingEvents());
   RequestNotificationWhenFlushed();
   EXPECT_EQ(0U, GetAndResetDidFlushCount());
   input_router()->OnMessageReceived(InputHostMsg_DidStopFlinging(0));
   EXPECT_EQ(1U, GetAndResetDidFlushCount());
 }
 
 // Test that GesturePinchUpdate is handled specially for trackpad
 TEST_F(InputRouterImplTest, TouchpadPinchUpdate) {
   // GesturePinchUpdate for trackpad sends synthetic wheel events.
@@ skipping 588 matching lines @@
   EXPECT_EQ(80, sent_event->data.flingStart.velocityY);
 
   const WebGestureEvent* filter_event =
       GetFilterWebInputEvent<WebGestureEvent>();
   TestLocationInFilterEvent(filter_event, orig);
   EXPECT_EQ(30, filter_event->data.flingStart.velocityX);
   EXPECT_EQ(40, filter_event->data.flingStart.velocityY);
 }
 
 }  // namespace content