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 "base/metrics/histogram_macros.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
+namespace {
+
+// The maximum number of post-coalesced events processed per rAF task. 10 was
+// chosen because it really should never be hit yet prevents an infinite loop if
+// the compositor keeps delivering events faster than the main thread can
+// process them.
+const size_t kMaxEventsPerRafTask = 10;
+
+bool isContinuousEvent(const std::unique_ptr<EventWithDispatchType>& event) {
+  switch (event->event().type) {
+    case blink::WebInputEvent::MouseMove:
+    case blink::WebInputEvent::TouchMove:
+    case blink::WebInputEvent::MouseWheel:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace
+
 EventWithDispatchType::EventWithDispatchType(
     ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType dispatch_type)
     : ScopedWebInputEventWithLatencyInfo(std::move(event), latency),
-      dispatch_type_(dispatch_type) {}
+      dispatch_type_(dispatch_type),
+      creation_timestamp_(base::TimeTicks::Now()),
+      last_coalesced_timestamp_(creation_timestamp_) {}
 
 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) {
-    // We should only have blocking touch events that need coalescing.
-    eventsToAck_.push_back(
-        ui::WebInputEventTraits::GetUniqueTouchEventId(other.event()));
-  }
+  coalesced_event_ids_.push_back(
+      ui::WebInputEventTraits::GetUniqueTouchEventId(other.event()));
   ScopedWebInputEventWithLatencyInfo::CoalesceWith(other);
+  last_coalesced_timestamp_ = base::TimeTicks::Now();
 }
 
+MainThreadEventQueue::SharedState::SharedState()
+    : sent_main_frame_request_(false) {}
+
+MainThreadEventQueue::SharedState::~SharedState() {}
+
 MainThreadEventQueue::MainThreadEventQueue(
     int routing_id,
     MainThreadEventQueueClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     blink::scheduler::RendererScheduler* renderer_scheduler)
     : routing_id_(routing_id),
       client_(client),
       is_flinging_(false),
       last_touch_start_forced_nonblocking_due_to_fling_(false),
       enable_fling_passive_listener_flag_(base::FeatureList::IsEnabled(
           features::kPassiveEventListenersDueToFling)),
+      handle_raf_aligned_input_(
+          base::FeatureList::IsEnabled(features::kRafAlignedInputEvents)),
       main_task_runner_(main_task_runner),
       renderer_scheduler_(renderer_scheduler) {}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
     ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
@@ skipping 44 matching lines @@
       non_blocking ? DISPATCH_TYPE_NON_BLOCKING : DISPATCH_TYPE_BLOCKING;
   std::unique_ptr<EventWithDispatchType> event_with_dispatch_type(
       new EventWithDispatchType(std::move(event), latency, dispatch_type));
 
   QueueEvent(std::move(event_with_dispatch_type));
 
   // 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();
-  }
+void MainThreadEventQueue::DispatchInFlightEvent() {
+  if (in_flight_event_) {
+    // Report the coalesced count only for continuous events; otherwise
+    // the zero value would be dominated by non-continuous events.
+    base::TimeTicks now = base::TimeTicks::Now();
+    if (isContinuousEvent(in_flight_event_)) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.MainThreadEventQueue.Continuous.QueueingTime",
+          (now - in_flight_event_->creationTimestamp()).ToInternalValue(), 1,
+          10000000, 50);
 
-  if (in_flight_event_) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.MainThreadEventQueue.Continuous.FreshnessTime",
+          (now - in_flight_event_->lastCoalescedTimestamp()).ToInternalValue(),
+          1, 10000000, 50);
+
+      UMA_HISTOGRAM_COUNTS_100("Event.MainThreadEventQueue.CoalescedCount",
+                               in_flight_event_->coalescedEventIds().size());

[tdresser, 2016/08/25 15:16:43]

A 2 second jank will often leave us with > 100 coaesced events.

I'd be tempted to use a log scale, 50 buckets, with a max of 1000.

[dtapuska, 2016/08/25 15:30:06]

bumped to 1000.

+    } else {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.MainThreadEventQueue.NonContinuous.QueueingTime",
+          (now - in_flight_event_->creationTimestamp()).ToInternalValue(), 1,
+          10000000, 50);
+    }
+
     InputEventDispatchType dispatch_type = in_flight_event_->dispatchType();
-    if (!in_flight_event_->eventsToAck().empty() &&
+    if (!in_flight_event_->coalescedEventIds().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::PossiblyScheduleMainFrame() {
+  if (!handle_raf_aligned_input_)
+    return;
+  bool needs_main_frame = false;
+  {
+    base::AutoLock lock(shared_state_lock_);
+    if (!shared_state_.sent_main_frame_request_ &&
+        !shared_state_.events_.empty() &&
+        isContinuousEvent(shared_state_.events_.front())) {
+      needs_main_frame = !shared_state_.sent_main_frame_request_;
+      shared_state_.sent_main_frame_request_ = false;
+    }
+  }
+  if (needs_main_frame)
+    client_->NeedsMainFrame(routing_id_);
+}
+
+void MainThreadEventQueue::DispatchSingleEvent() {
+  {
+    base::AutoLock lock(shared_state_lock_);
+    if (shared_state_.events_.empty())
+      return;
+
+    in_flight_event_ = shared_state_.events_.Pop();
+  }
+  DispatchInFlightEvent();
+  PossiblyScheduleMainFrame();
+}
+
 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()) {
+  if (in_flight_event_ &&
+      in_flight_event_->dispatchType() == DISPATCH_TYPE_BLOCKING) {
+    for (const auto id : in_flight_event_->coalescedEventIds()) {
       client_->SendInputEventAck(routing_id_, type, ack_result, id);
       if (renderer_scheduler_) {
         renderer_scheduler_->DidHandleInputEventOnMainThread(
             in_flight_event_->event());
       }
     }
   }
 }
 
+void MainThreadEventQueue::DispatchRafAlignedInput() {
+  if (!handle_raf_aligned_input_)
+    return;
+
+  {
+    base::AutoLock lock(shared_state_lock_);
+    shared_state_.sent_main_frame_request_ = false;
+  }
+
+  for (size_t i = 0; i < kMaxEventsPerRafTask; ++i) {
+    {
+      base::AutoLock lock(shared_state_lock_);

[tdresser, 2016/08/25 15:16:43]

Is it worth dropping and reacquiring this lock every iteration?

Feels like it adds more complexity than it's worth (risk of the compositor
feeding us events too quickly).

We could get the full list of events to send, release the lock, and then
dispatch them all.

[dtapuska, 2016/08/25 15:30:06]

Its a toss up. The expected size is always 1. Do we always want to ensure there
is only one input per frame essentially or not. With Rick's event timing example
it is possible that you can get two if the timing is right in that an event is
removed from the queue; you invoke the main thread callback while another one
was just put into the queue. This design we will run it right away instead of
waiting around for another main frame callback.

+      if (shared_state_.events_.empty())
+        break;
+
+      if (!isContinuousEvent(shared_state_.events_.front()))
+        break;
+      in_flight_event_ = shared_state_.events_.Pop();
+    }
+    DispatchInFlightEvent();
+  }
+  PossiblyScheduleMainFrame();
+}
+
 void MainThreadEventQueue::SendEventNotificationToMainThread() {
   main_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&MainThreadEventQueue::PopEventOnMainThread,
-                            this));
+      FROM_HERE, base::Bind(&MainThreadEventQueue::DispatchSingleEvent, this));
 }
 
 void MainThreadEventQueue::QueueEvent(
     std::unique_ptr<EventWithDispatchType> event) {
-  bool send_notification = false;
+  bool is_continuous = isContinuousEvent(event);
+  size_t send_notification_count = 0;
+  bool needs_main_frame = false;
   {
-    base::AutoLock lock(event_queue_lock_);
-    size_t size_before = events_.size();
-    events_.Queue(std::move(event));
-    send_notification = events_.size() != size_before;
+    base::AutoLock lock(shared_state_lock_);
+    size_t size_before = shared_state_.events_.size();
+    shared_state_.events_.Queue(std::move(event));
+    size_t size_after = shared_state_.events_.size();
+    if (size_before != size_after) {
+      if (!handle_raf_aligned_input_) {
+        send_notification_count = 1;
+      } else if (!is_continuous) {
+        send_notification_count = 1;
+        // If we had just enqueued a non-rAF input event we will send a series
+        // of normal post messages to ensure they are all handled right away.
+        for (size_t pos = size_after - 1; pos >= 1; --pos) {
+          if (isContinuousEvent(shared_state_.events_.at(pos - 1)))
+            send_notification_count++;
+          else
+            break;
+        }
+      } else {
+        needs_main_frame = !shared_state_.sent_main_frame_request_;
+        shared_state_.sent_main_frame_request_ = true;
+      }
+    }
   }
-  if (send_notification)
+  for (size_t i = 0; i < send_notification_count; ++i)
     SendEventNotificationToMainThread();
+  if (needs_main_frame)
+    client_->NeedsMainFrame(routing_id_);
 }
 
 }  // namespace content