Implement Main Thread RAF Aligned Input

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 {
 
+namespace {
+const size_t kMaxEventsPerVSyncEvent = 10;

[tdresser, 2016/07/20 21:43:09]

Add a comment about this constant - why do we need a max here?

+bool isVSyncAlignedEvent(const std::unique_ptr<EventWithDispatchType>& event) {

[tdresser, 2016/07/20 21:43:09]

I'd name this something like eventCanBeRafAligned.

Or maybe something like "isContinousEvent", as opposed to discrete events?

+  switch (event->event().type) {
+    case blink::WebInputEvent::MouseMove:
+    case blink::WebInputEvent::TouchMove:
+    case blink::WebInputEvent::MouseWheel:
+      return true;
+    default:
+      return false;
+  }
+}
+}  // namespace
+
 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(
@@ skipping 14 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),
+      notification_sent_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 ||
@@ skipping 21 matching lines @@
       static_cast<blink::WebTouchEvent&>(cloned_event->event()).dispatchType =
           blink::WebInputEvent::ListenersNonBlockingPassive;
     }
   }
   QueueEvent(std::move(cloned_event));
 
   // send an ack when we are non-blocking.
   return non_blocking;
 }
 
-void MainThreadEventQueue::PopEventOnMainThread() {
-  {
-    base::AutoLock lock(event_queue_mutex_);
-    if (!events_.empty())
-      in_flight_event_ = events_.Pop();
-  }
-
+void MainThreadEventQueue::DispatchInFlightEvent() {
   if (in_flight_event_) {
     InputEventDispatchType dispatch_type = in_flight_event_->dispatchType();
     if (!in_flight_event_->eventsToAck().empty() &&
         dispatch_type == DISPATCH_TYPE_BLOCKING)
       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();
+}
+
+void MainThreadEventQueue::PopEventOnMainThread() {
   {
     base::AutoLock lock(event_queue_mutex_);
-    if (!events_.empty()) {
+    if (!events_.empty())
+      in_flight_event_ = events_.Pop();
+  }
+
+  DispatchInFlightEvent();
+
+  {
+    base::AutoLock lock(event_queue_mutex_);
+    if (!events_.empty())
       SendEventNotificationToMainThread();
-    }
+    else
+      notification_sent_to_main_ = false;
   }
 }
 
 void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type,
                                         InputEventAckState ack_result) {
   if (in_flight_event_) {
     DCHECK_EQ(in_flight_event_->event().type, type);
     // Send acks for blocking touch events.
     for (const auto id : in_flight_event_->eventsToAck())
       client_->SendInputEventAck(routing_id_, type, ack_result, id);
     }
 }
 
+void MainThreadEventQueue::DispatchVSyncAlignedInput() {
+  size_t i = 0;
+  for (; i < kMaxEventsPerVSyncEvent; ++i) {
+    {
+      base::AutoLock lock(event_queue_mutex_);
+      if (events_.empty())
+        break;
+      if (!isVSyncAlignedEvent(events_.Top()))
+        break;
+      in_flight_event_ = events_.Pop();
+    }
+    DispatchInFlightEvent();
+  }
+  LOG(ERROR) << "Processed " << i << " events in RAF";

[tdresser, 2016/07/20 21:43:08]

Remember to remove this before landing (and make the for loop more normal).

+}
+
 void MainThreadEventQueue::SendEventNotificationToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::PopEventOnMainThread,
                             base::Unretained(this)));
 }
 
 void MainThreadEventQueue::QueueEvent(
     std::unique_ptr<EventWithDispatchType>&& event) {
-  size_t pending;
+  bool isVsynced = isVSyncAlignedEvent(event);

[tdresser, 2016/07/20 21:43:08]

Inconsistent casing here.

+  bool send_notification = false;
   {
     base::AutoLock lock(event_queue_mutex_);
-    pending = events_.size();
     events_.Queue(std::move(event));
+    if (!isVsynced && !notification_sent_to_main_) {
+      send_notification = true;
+      notification_sent_to_main_ = true;
+    }
   }
-  if (pending == 0)
+  if (send_notification)
     SendEventNotificationToMainThread();
 }
 
 }  // namespace content