Separate rAF aligned Touch and Mouse Input settings

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 {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
-bool isContinuousEvent(const std::unique_ptr<EventWithDispatchType>& event) {
+bool IsContinuousEvent(const std::unique_ptr<EventWithDispatchType>& event) {
   switch (event->event().type) {
     case blink::WebInputEvent::MouseMove:
     case blink::WebInputEvent::MouseWheel:
       return true;
     case blink::WebInputEvent::TouchMove:
       // TouchMoves that are blocking end up blocking scroll. Do not treat
       // them as continuous events otherwise we will end up waiting up to an
       // additional frame.
       return static_cast<const blink::WebTouchEvent&>(event->event())
                  .dispatchType != blink::WebInputEvent::Blocking;
@@ skipping 37 matching lines @@
     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)),
+      handle_raf_aligned_touch_input_(
+          base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)),
+      handle_raf_aligned_mouse_input_(
+          base::FeatureList::IsEnabled(features::kRafAlignedMouseInputEvents)),
       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 49 matching lines @@
 
   // send an ack when we are non-blocking.
   return non_blocking;
 }
 
 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_)) {
+    if (IsContinuousEvent(in_flight_event_)) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.MainThreadEventQueue.Continuous.QueueingTime",
           (now - in_flight_event_->creationTimestamp()).InMicroseconds(), 1,
           kTenSeconds, 50);
 
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.MainThreadEventQueue.Continuous.FreshnessTime",
           (now - in_flight_event_->lastCoalescedTimestamp()).InMicroseconds(),
           1, kTenSeconds, 50);
 
@@ skipping 14 matching lines @@
 
     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_)
+  if (IsRafAlignedInputDisabled())
     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())) {
+        IsRafAlignedEvent(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() {
   {
@@ skipping 15 matching lines @@
       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_)
+  if (IsRafAlignedInputDisabled())
     return;
 
   std::deque<std::unique_ptr<EventWithDispatchType>> events_to_process;
   {
     base::AutoLock lock(shared_state_lock_);
     shared_state_.sent_main_frame_request_ = false;
 
     while(!shared_state_.events_.empty()) {
-      if (!isContinuousEvent(shared_state_.events_.front()))
+      if (!IsRafAlignedEvent(shared_state_.events_.front()))
         break;
       events_to_process.emplace_back(shared_state_.events_.Pop());
     }
   }
 
   while(!events_to_process.empty()) {
     in_flight_event_ = std::move(events_to_process.front());
     events_to_process.pop_front();
     DispatchInFlightEvent();
   }
   PossiblyScheduleMainFrame();
 }
 
 void MainThreadEventQueue::SendEventNotificationToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::DispatchSingleEvent, this));
 }
 
 void MainThreadEventQueue::QueueEvent(
     std::unique_ptr<EventWithDispatchType> event) {
-  bool is_continuous = isContinuousEvent(event);
+  bool is_raf_aligned = IsRafAlignedEvent(event);
   size_t send_notification_count = 0;
   bool needs_main_frame = false;
   {
     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_) {
+      if (IsRafAlignedInputDisabled()) {
         send_notification_count = 1;
-      } else if (!is_continuous) {
+      } else if (!is_raf_aligned) {
         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)))
+          if (IsRafAlignedEvent(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;
       }
     }
   }
   for (size_t i = 0; i < send_notification_count; ++i)
     SendEventNotificationToMainThread();
   if (needs_main_frame)
     client_->NeedsMainFrame(routing_id_);
 }
 
+bool MainThreadEventQueue::IsRafAlignedInputDisabled() {
+  return !handle_raf_aligned_mouse_input_ && !handle_raf_aligned_touch_input_;
+}
+
+bool MainThreadEventQueue::IsRafAlignedEvent(
+    const std::unique_ptr<EventWithDispatchType>& event) {
+  switch (event->event().type) {
+    case blink::WebInputEvent::MouseMove:
+    case blink::WebInputEvent::MouseWheel:
+      return handle_raf_aligned_mouse_input_;
+    case blink::WebInputEvent::TouchMove:
+      // TouchMoves that are blocking end up blocking scroll. Do not treat
+      // them as continuous events otherwise we will end up waiting up to an
+      // additional frame.
+      return static_cast<const blink::WebTouchEvent&>(event->event())
+                     .dispatchType != blink::WebInputEvent::Blocking &&
+             handle_raf_aligned_touch_input_;
+    default:
+      return false;
+  }
+}
+
 }  // namespace content