Don't use PostTask queueing between compositor and main thread.

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 {
 
 EventWithDispatchType::EventWithDispatchType(
     const blink::WebInputEvent& event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType dispatch_type)
     : ScopedWebInputEventWithLatencyInfo(event, latency),
       dispatch_type_(dispatch_type) {}
 
 EventWithDispatchType::~EventWithDispatchType() {}
 
 bool EventWithDispatchType::CanCoalesceWith(
     const EventWithDispatchType& other) const {
   return other.dispatch_type_ == dispatch_type_ &&
          ScopedWebInputEventWithLatencyInfo::CanCoalesceWith(other);
 }
 
 void EventWithDispatchType::CoalesceWith(const EventWithDispatchType& other) {
   // If we are blocking and are coalescing touch, make sure to keep
   // the touch ids that need to be acked.
-  if (dispatch_type_ == DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN) {
+  if (dispatch_type_ == DISPATCH_TYPE_BLOCKING) {
     // We should only have blocking touch events that need coalescing.
     DCHECK(blink::WebInputEvent::isTouchEventType(other.event().type));
     eventsToAck_.push_back(
         WebInputEventTraits::GetUniqueTouchEventId(other.event()));
   }
   ScopedWebInputEventWithLatencyInfo::CoalesceWith(other);
 }
 
-MainThreadEventQueue::MainThreadEventQueue(int routing_id,
-                                           MainThreadEventQueueClient* client)
+MainThreadEventQueue::MainThreadEventQueue(
+    int routing_id,
+    MainThreadEventQueueClient* client,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
     : routing_id_(routing_id),
       client_(client),
       is_flinging_(false),
-      sent_notification_to_main_(false) {}
+      sent_notification_to_main_(false),
+      main_task_runner_(main_task_runner) {}
 
 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_NOTIFY_MAIN
-                   : DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN;
+      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);
 
-  if (is_wheel || is_touch) {
-    std::unique_ptr<EventWithDispatchType> cloned_event(
-        new EventWithDispatchType(*event, latency, dispatch_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_;
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
     if (non_blocking) {
-      if (is_wheel) {
-        static_cast<blink::WebMouseWheelEvent&>(cloned_event->event())
-            .dispatchType = blink::WebInputEvent::ListenersNonBlockingPassive;
-      } else if (is_touch) {
-        static_cast<blink::WebTouchEvent&>(cloned_event->event()).dispatchType =
-            blink::WebInputEvent::ListenersNonBlockingPassive;
-      }
+      touch_event.dispatchType =
+          blink::WebInputEvent::ListenersNonBlockingPassive;
     }
+  }
+  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;
+  }
 
-    if (is_touch) {
-      static_cast<blink::WebTouchEvent&>(cloned_event->event())
-          .dispatchedDuringFling = is_flinging_;
-    }
-
-    if (sent_notification_to_main_) {
-      events_.Queue(std::move(cloned_event));
-    } else {
-      if (non_blocking) {
-        sent_notification_to_main_ = true;
-        client_->SendEventToMainThread(routing_id_, &cloned_event->event(),
-                                       latency, dispatch_type);
-      } else {
-        // If there is nothing in the event queue and the event is
-        // blocking pass the |original_dispatch_type| to avoid
-        // having the main thread call us back as an optimization.
-        client_->SendEventToMainThread(routing_id_, &cloned_event->event(),
-                                       latency, original_dispatch_type);
-      }
-    }
-  } else {
-    client_->SendEventToMainThread(routing_id_, event, latency,
-                                   original_dispatch_type);
-  }
+  QueueEvent(std::move(cloned_event));
 
   // send an ack when we are non-blocking.
   return non_blocking;
 }
 
+void MainThreadEventQueue::PopEventOnMainThread() {
+  {
+    base::AutoLock lock(event_queue_lock_);
+    if (!events_.empty())
+      in_flight_event_ = events_.Pop();
+  }
+
+  if (in_flight_event_) {
+    InputEventDispatchType dispatch_type = in_flight_event_->dispatchType();
+    if (!in_flight_event_->eventsToAck().empty() &&
+        dispatch_type == DISPATCH_TYPE_BLOCKING)

[tdresser, 2016/08/04 18:02:22]

I prefer {} when the condition or the body is multiline, though this isn't
technically required by the style guide.

Leave it if you prefer (but adding {} is definitely superior :) )

[dtapuska, 2016/08/08 15:34:03]

Done.

+      dispatch_type = DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN;
+
+    client_->HandleEventOnMainThread(routing_id_, &in_flight_event_->event(),
+                                     in_flight_event_->latencyInfo(),
+                                     dispatch_type);
+  }
+
+  in_flight_event_.reset();
+  bool send_notification = false;
+  {
+    base::AutoLock lock(event_queue_lock_);
+    if (!events_.empty())
+      send_notification = true;
+    else
+      sent_notification_to_main_ = false;
+  }
+
+  if (send_notification)
+    SendEventNotificationToMainThread();
+}
+
 void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type,
                                         InputEventAckState ack_result) {
   if (in_flight_event_) {
     // Send acks for blocking touch events.
     for (const auto id : in_flight_event_->eventsToAck())
       client_->SendInputEventAck(routing_id_, type, ack_result, id);
-    }
-    if (!events_.empty()) {
-      in_flight_event_ = events_.Pop();
-      client_->SendEventToMainThread(routing_id_, &in_flight_event_->event(),
-                                     in_flight_event_->latencyInfo(),
-                                     in_flight_event_->dispatchType());
-    } else {
-      in_flight_event_.reset();
-      sent_notification_to_main_ = false;
-    }
+  }
+}
+
+void MainThreadEventQueue::SendEventNotificationToMainThread() {

[tdresser, 2016/08/04 18:02:22]

I'm a bit confused here.

SendEventNotificationToMainThread posts a task to PopEventOnMainThread, which
then may call SendEventNotificationToMainThread.

Which threads do these methods run on?

Are we posting PopEventOnMainThread onto the main thread from the main thread?

[dtapuska, 2016/08/08 15:34:03]

In the currently (ToT) event processing we only process one event per message
loop iteration. 

This design is to  maintain that behavior. This runs on both threads; when an
event is enqueued it will run on the cc thread and when we have pop and event
from the main thread it will run if there is remaining work. I do change some of
this for rAF aligned input processing up to a number of events per iteration.

[tdresser, 2016/08/08 16:56:05]

Thanks. Maybe add a comment indicating in what context this runs on which
thread.

+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MainThreadEventQueue::PopEventOnMainThread,
+                            base::Unretained(this)));
+}
+
+void MainThreadEventQueue::QueueEvent(
+    std::unique_ptr<EventWithDispatchType>&& event) {
+  bool send_notification = false;
+  {
+    base::AutoLock lock(event_queue_lock_);
+    send_notification = events_.empty();
+    events_.Queue(std::move(event));
+    sent_notification_to_main_ |= send_notification;
+  }
+  if (send_notification)
+    SendEventNotificationToMainThread();
 }
 
 }  // namespace content