Coalesce async touch move events until the ack back from render

content/browser/renderer_host/render_widget_host_view_aura_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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
@@ skipping 425 matching lines @@
     // which uses ObserverListThreadSafe, which furthermore remembers the
     // message loop for the thread it was created in. Between tests, the
     // RendererFrameManager singleton survives and and the MessageLoop gets
     // destroyed. The correct fix would be to have ObserverListThreadSafe look
     // up the proper message loop every time (see crbug.com/443824.)
     RendererFrameManager::GetInstance()->OnMemoryPressure(level);
   }
 
   void SendInputEventACK(WebInputEvent::Type type,
       InputEventAckState ack_result) {
-    InputHostMsg_HandleInputEvent_ACK_Params ack;
-    ack.type = type;
-    ack.state = ack_result;
+    DCHECK(!WebInputEvent::isTouchEventType(type));
+    InputEventAck ack(type, ack_result);
     InputHostMsg_HandleInputEvent_ACK response(0, ack);
     widget_host_->OnMessageReceived(response);
   }
+
+  void SendTouchEventACK(WebInputEvent::Type type, uint32 event_id,
+      InputEventAckState ack_result) {
+    DCHECK(WebInputEvent::isTouchEventType(type));
+    InputEventAck ack(type, ack_result, event_id);
+    InputHostMsg_HandleInputEvent_ACK response(0, ack);
+    widget_host_->OnMessageReceived(response);
+  }
 
   size_t GetSentMessageCountAndResetSink() {
     size_t count = sink_->message_count();
     sink_->ClearMessages();
     return count;
   }
 
   void AckLastSentInputEventIfNecessary(InputEventAckState ack_result) {
     if (!sink_->message_count())
       return;
 
     InputMsg_HandleInputEvent::Param params;
     if (!InputMsg_HandleInputEvent::Read(
             sink_->GetMessageAt(sink_->message_count() - 1), &params)) {
       return;
     }
 
-    if (WebInputEventTraits::IgnoresAckDisposition(*get<0>(params)))
+    if (!WebInputEventTraits::WillReceiveAckFromRenderer(*get<0>(params)))
       return;
 
-    SendInputEventACK(get<0>(params)->type, ack_result);
+    SendTouchEventACK(get<0>(params)->type, LastSentEventID(), ack_result);
+  }
+
+  uint32 LastSentEventID() {
+    uint32 last_sent_event_id = 0;

[jdduke (slow), 2015/05/12 16:07:11]

Again, I don't think we should use this logic. Let's either cache the id when we
send it, or make it available somehow each time we send the event.

[lanwei, 2015/05/13 21:01:53]

Done.

+    size_t count = sink_->message_count();
+    DCHECK_GT(count, 0U);
+    for (size_t i = 0; i < count; ++i) {
+      const WebInputEvent* input_event =
+          GetInputEventFromMessage(*sink_->GetMessageAt(i));
+      last_sent_event_id =
+          WebInputEventTraits::GetUniqueTouchEventId(*input_event);
+    }
+    return last_sent_event_id;
   }
 
  protected:
   // If true, then calls RWH::Shutdown() instead of deleting RWH.
   bool widget_host_uses_shutdown_to_destroy_;
 
   bool is_guest_view_hack_;
 
   base::MessageLoopForUI message_loop_;
   BrowserThreadImpl browser_thread_for_ui_;
@@ skipping 612 matching lines @@
   view_->OnTouchEvent(&press);
   EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchStart, view_->touch_event_->type);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StatePressed,
             view_->touch_event_->touches[0].state);
 
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
 
   // Ack'ing the outstanding event should flush the pending touch queue.
-  InputHostMsg_HandleInputEvent_ACK_Params ack;
-  ack.type = blink::WebInputEvent::TouchStart;
-  ack.state = INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
+  InputEventAck ack(blink::WebInputEvent::TouchStart,
+                    INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS,
+                    press.unique_event_id());
   widget_host_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 0,
       base::Time::NowFromSystemTime() - base::Time());
   view_->OnTouchEvent(&move2);
   EXPECT_TRUE(press.synchronous_handling_disabled());
   EXPECT_EQ(blink::WebInputEvent::TouchMove, view_->touch_event_->type);
   EXPECT_EQ(1U, view_->touch_event_->touchesLength);
   EXPECT_EQ(blink::WebTouchPoint::StateMoved,
@@ skipping 1654 matching lines @@
 }
 
 // Tests that when touch-events are dispatched to the renderer, the overscroll
 // gesture deals with them correctly.
 TEST_F(RenderWidgetHostViewAuraOverscrollTest, OverscrollWithTouchEvents) {
   SetUpOverscrollEnvironmentWithDebounce(10);
   widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
   sink_->ClearMessages();
 
   // The test sends an intermingled sequence of touch and gesture events.
   PressTouchPoint(0, 1);

[jdduke (slow), 2015/05/12 16:07:11]

Looks like only 2 methods use the |PressTouchPoint| helper methods. I'd be OK
getting rid of them entirely and just storing the SyntheticWebTochEvent here, or
have the helper methods return the id (you'll need to cache it before the points
are reset).

[lanwei, 2015/05/13 21:01:53]

Done.

-  SendInputEventACK(WebInputEvent::TouchStart,
+  SendTouchEventACK(WebInputEvent::TouchStart, LastSentEventID(),
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   MoveTouchPoint(0, 20, 5);
+  SendTouchEventACK(WebInputEvent::TouchMove, LastSentEventID(),
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
-  SendInputEventACK(WebInputEvent::TouchMove,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_delegate()->current_mode());
 
   SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SimulateGestureScrollUpdateEvent(20, 0, 0);
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
@@ skipping 504 matching lines @@
 // lose track of the number of acks required.
 TEST_F(RenderWidgetHostViewAuraTest, CorrectNumberOfAcksAreDispatched) {
   view_->InitAsFullscreen(parent_view_);
   view_->Show();
   view_->UseFakeDispatcher();
 
   ui::TouchEvent press1(
       ui::ET_TOUCH_PRESSED, gfx::Point(30, 30), 0, ui::EventTimeForNow());
 
   view_->OnTouchEvent(&press1);
-  SendInputEventACK(blink::WebInputEvent::TouchStart,
+  SendTouchEventACK(blink::WebInputEvent::TouchStart, press1.unique_event_id(),
                     INPUT_EVENT_ACK_STATE_CONSUMED);
 
   ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(20, 20), 1, ui::EventTimeForNow());
   view_->OnTouchEvent(&press2);
-  SendInputEventACK(blink::WebInputEvent::TouchStart,
+  SendTouchEventACK(blink::WebInputEvent::TouchStart, press2.unique_event_id(),
                     INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(2U, view_->dispatcher_->processed_touch_event_count());
 }
 
 // Tests that the scroll deltas stored within the overscroll controller get
 // reset at the end of the overscroll gesture even if the overscroll threshold
 // isn't surpassed and the overscroll mode stays OVERSCROLL_NONE.
 TEST_F(RenderWidgetHostViewAuraOverscrollTest, ScrollDeltasResetOnEnd) {
   SetUpOverscrollEnvironment();
@@ skipping 31 matching lines @@
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(OVERSCROLL_NONE, overscroll_mode());
   EXPECT_EQ(15.f, overscroll_delta_x());
   EXPECT_EQ(-5.f, overscroll_delta_y());
   SimulateGestureFlingStartEvent(0.f, 0.1f, blink::WebGestureDeviceTouchpad);
   EXPECT_EQ(0.f, overscroll_delta_x());
   EXPECT_EQ(0.f, overscroll_delta_y());
 }
 
 }  // namespace content