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

content/renderer/input/main_thread_event_queue.h

 // 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.
 
 #ifndef CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_
 #define CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_
 
 #include <deque>
 #include "content/common/content_export.h"
 #include "content/common/input/event_with_latency_info.h"
@@ skipping 24 matching lines @@
 
   // |eventsToAck_| contains the unique touch event id to be acked. If
   // the events are TouchEvents the value will be 0. More importantly for
   // those cases the deque ends up containing how many additional ACKs
   // need to be sent.
   std::deque<uint32_t> eventsToAck_;
 };
 
 class CONTENT_EXPORT MainThreadEventQueueClient {
  public:
-  // Send an |event| that was previously queued (possibly
+  // Handle an |event| that was previously queued (possibly
   // coalesced with another event) to the |routing_id|'s
   // channel. Implementors must implement this callback.
-  virtual void SendEventToMainThread(int routing_id,
-                                     const blink::WebInputEvent* event,
-                                     const ui::LatencyInfo& latency,
-                                     InputEventDispatchType dispatch_type) = 0;
+  virtual void HandleEventOnMainThread(
+      int routing_id,
+      const blink::WebInputEvent* event,
+      const ui::LatencyInfo& latency,
+      InputEventDispatchType dispatch_type) = 0;
 
   virtual void SendInputEventAck(int routing_id,
                                  blink::WebInputEvent::Type type,
                                  InputEventAckState ack_result,
                                  uint32_t touch_event_id) = 0;
 };
 
 // MainThreadEventQueue implements a series of queues (one touch
 // and one mouse wheel) for events that need to be queued between
 // the compositor and main threads. When an event is sent
@@ skipping 21 matching lines @@
 //            <--(PT)---
 //
 // Non-blocking followed by blocking event sent to main thread.
 //   B        C        M
 //   ---(NB)-->
 //            ---(PT)-->
 //   ---(BL)-->
 //            <--(PT)---     // Notify from NB event.
 //            ---(PT)-->     // Release blocking event.
 //            <--(PT)---     // Notify from BL event.
 //   <-------(ACK)------

[tdresser, 2016/07/27 13:51:51]

This comment needs updating, doesn't it?

[dtapuska, 2016/08/03 20:20:54]

Done.

 //
-class CONTENT_EXPORT MainThreadEventQueue {
+class CONTENT_EXPORT MainThreadEventQueue
+    : public base::RefCountedThreadSafe<MainThreadEventQueue> {
  public:
-  MainThreadEventQueue(int routing_id, MainThreadEventQueueClient* client);
-  ~MainThreadEventQueue();
+  MainThreadEventQueue(
+      int routing_id,
+      MainThreadEventQueueClient* client,
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner);
 
   // Called once the compositor has handled |event| and indicated that it is
   // a non-blocking event to be queued to the main thread.
   bool HandleEvent(const blink::WebInputEvent* event,
                    const ui::LatencyInfo& latency,
                    InputEventDispatchType dispatch_type,
                    InputEventAckState ack_result);
 
   // Call once the main thread has handled an outstanding |type| event
   // in flight.
   void EventHandled(blink::WebInputEvent::Type type,
                     InputEventAckState ack_result);
 
   void set_is_flinging(bool is_flinging) { is_flinging_ = is_flinging; }
 
  private:
+  friend class base::RefCountedThreadSafe<MainThreadEventQueue>;
+  ~MainThreadEventQueue();
+  void QueueEvent(std::unique_ptr<EventWithDispatchType>&& event);
+  void SendEventNotificationToMainThread();
+  void PopEventOnMainThread();
+  void SendEventToMainThread(const blink::WebInputEvent* event,
+                             const ui::LatencyInfo& latency,
+                             InputEventDispatchType original_dispatch_type);
+
   friend class MainThreadEventQueueTest;
   int routing_id_;
   MainThreadEventQueueClient* client_;
   WebInputEventQueue<EventWithDispatchType> events_;
   std::unique_ptr<EventWithDispatchType> in_flight_event_;
   bool is_flinging_;
   bool sent_notification_to_main_;
 
+  base::Lock event_queue_mutex_;

[tdresser, 2016/07/27 13:51:51]

Looks like event_queue_lock_ would be better in line with other lock naming.

[dtapuska, 2016/08/03 20:20:54]

Done.

+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(MainThreadEventQueue);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_INPUT_MAIN_THREAD_EVENT_QUEUE_H_