Make first TouchStart and first TouchMove events on a flinging layer non-blocking

content/renderer/input/main_thread_event_queue.cc

 // Copyright 2016 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/renderer/input/main_thread_event_queue.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
@@ skipping 23 matching lines @@
   ScopedWebInputEventWithLatencyInfo::CoalesceWith(other);
 }
 
 MainThreadEventQueue::MainThreadEventQueue(
     int routing_id,
     MainThreadEventQueueClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
     : routing_id_(routing_id),
       client_(client),
       is_flinging_(false),
-      main_task_runner_(main_task_runner) {}
+      main_task_runner_(main_task_runner),
+      waiting_for_first_touch_move_(false) {}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
     const blink::WebInputEvent* event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
          original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
@@ skipping 15 matching lines @@
   if (is_touch) {
     blink::WebTouchEvent& touch_event =
         static_cast<blink::WebTouchEvent&>(cloned_event->event());
     touch_event.dispatchedDuringFling = is_flinging_;
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
     if (non_blocking) {
       touch_event.dispatchType =
           blink::WebInputEvent::ListenersNonBlockingPassive;
     }
+    if (is_flinging_ &&

[dtapuska, 2016/08/10 14:47:42]

does |is_flinging_| change after the touch start?

I'm not sure what buying the first touch move after touch start is buying us
here; as opposed to  checking if the event is cancelable which you are checking
if it is blocking.

Perhaps we should add is first touch move after start just to the web input
event and avoid all these states all over the place?

+        touch_event.dispatchType == blink::WebInputEvent::Blocking) {
+      bool touch_start_or_first_touch_move = false;
+      if (event->type == blink::WebInputEvent::TouchStart) {
+        waiting_for_first_touch_move_ = true;
+        touch_start_or_first_touch_move = true;
+      } else if (event->type == blink::WebInputEvent::TouchMove) {
+        touch_start_or_first_touch_move = waiting_for_first_touch_move_;
+        waiting_for_first_touch_move_ = false;
+      }
+      if (touch_start_or_first_touch_move) {
+        touch_event.dispatchType =
+            blink::WebInputEvent::ListenersForcedNonBlockingPassiveDueToFling;
+      }
+    }
   }
   if (is_wheel && non_blocking) {
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
     static_cast<blink::WebMouseWheelEvent&>(cloned_event->event())
         .dispatchType = blink::WebInputEvent::ListenersNonBlockingPassive;
   }
 
   QueueEvent(std::move(cloned_event));
 
@@ skipping 45 matching lines @@
     base::AutoLock lock(event_queue_lock_);
     size_t size_before = events_.size();
     events_.Queue(std::move(event));
     send_notification = events_.size() != size_before;
   }
   if (send_notification)
     SendEventNotificationToMainThread();
 }
 
 }  // namespace content