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);
   DCHECK(ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
          ack_result == INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   bool non_blocking = original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING ||
                       ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING;
 
   InputEventDispatchType dispatch_type =
       non_blocking ? DISPATCH_TYPE_NON_BLOCKING : DISPATCH_TYPE_BLOCKING;
 
   bool is_wheel = event->type == blink::WebInputEvent::MouseWheel;
   bool is_touch = blink::WebInputEvent::isTouchEventType(event->type);
 
   std::unique_ptr<EventWithDispatchType> cloned_event(
       new EventWithDispatchType(*event, latency, dispatch_type));
 
   if (is_touch) {
     blink::WebTouchEvent& touch_event =
         static_cast<blink::WebTouchEvent&>(cloned_event->event());
     touch_event.dispatchedDuringFling = is_flinging_;
+    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;
+    }
+    touch_event.touchStartOrFirstTouchMove = touch_start_or_first_touch_move;

[dtapuska, 2016/08/12 14:40:00]

Why is this populated here? Can't it be sent from the touch_event_queue? then it
will be correct when the compositor deals with the events.

     // 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_ && touch_start_or_first_touch_move &&
+        touch_event.dispatchType == blink::WebInputEvent::Blocking) {
+      touch_event.dispatchType =
+          blink::WebInputEvent::ListenersForcedNonBlockingPassiveDueToFling;
+      cloned_event->setDispatchType(DISPATCH_TYPE_NON_BLOCKING);
+      non_blocking = true;
+    }
   }
   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