Allow events in queue to coalesce while executing other events.

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/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/input/event_with_latency_info.h"
@@ skipping 388 matching lines @@
 void MainThreadEventQueue::PossiblyScheduleMainFrame() {
   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() &&
         IsRafAlignedEvent(shared_state_.events_.front())) {
       needs_main_frame = !shared_state_.sent_main_frame_request_;
       shared_state_.sent_main_frame_request_ = false;

[mustaq, 2017/04/04 14:59:22]

Just spotted this nit from before: |shared_state_.sent_main_frame_reuqest_| is
always false here, so Lines 408~409 could be replaced by |needs_main_frame =
true;|;

[dtapuska, 2017/04/04 15:27:45]

Done.

     }
   }
   if (needs_main_frame)
     client_->NeedsMainFrame(routing_id_);
 }
 
 void MainThreadEventQueue::DispatchEvents() {
-  std::deque<std::unique_ptr<MainThreadEventQueueTask>> events_to_process;
+  size_t queue_size_at_start;
+
+  // Record the queue size so that we only process
+  // that maximum number of events.
   {
     base::AutoLock lock(shared_state_lock_);
     shared_state_.sent_post_task_ = false;
+    queue_size_at_start = shared_state_.events_.size();
+  }
 
-    shared_state_.events_.swap(&events_to_process);
+  while (queue_size_at_start--) {
+    {
+      base::AutoLock lock(shared_state_lock_);
 
-    // Now take any raf aligned events that are at the tail of the queue
-    // and put them back.
-    while (!events_to_process.empty()) {
-      if (!IsRafAlignedEvent(events_to_process.back()))
+      // If all the events are rAF aligned we won't process them
+      // now, wait until the rAF signal.
+      bool all_raf_aligned = true;
+      for (size_t i = 0; i < shared_state_.events_.size(); ++i) {

[mustaq, 2017/04/04 14:59:22]

The use of .size() here seems suspicious: since we only care about first
n=|queue_size_at_start| events, events queued after the locked state shouldn't
trigger early bail out from the |while| loop. Am I right?

If so, shouldn't we compute |all_raf_aligned| in locked state above?

[dtapuska, 2017/04/04 15:27:45]

Done.

+        if (!IsRafAlignedEvent(shared_state_.events_.at(i))) {
+          all_raf_aligned = false;
+          break;
+        }
+      }
+      if (all_raf_aligned)
         break;
-      shared_state_.events_.emplace_front(std::move(events_to_process.back()));
-      events_to_process.pop_back();
+
+      in_flight_event_ = shared_state_.events_.Pop();
     }
-  }
-  while (!events_to_process.empty()) {
-    in_flight_event_ = std::move(events_to_process.front());
-    events_to_process.pop_front();
+
+    // Dispatching the event is outside of critical section.
     DispatchInFlightEvent();
   }
   PossiblyScheduleMainFrame();
 }
 
 void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type,
                                         blink::WebInputEventResult result,
                                         InputEventAckState ack_result) {
   if (in_flight_event_) {
     in_flight_event_->EventHandled(routing_id_, renderer_scheduler_, client_,
                                    type, result, ack_result);
   }
 }
 
 void MainThreadEventQueue::DispatchRafAlignedInput(base::TimeTicks frame_time) {
   if (IsRafAlignedInputDisabled())
     return;
 
-  std::deque<std::unique_ptr<MainThreadEventQueueTask>> events_to_process;
+  size_t queue_size_at_start;
+
+  // Record the queue size so that we only process
+  // that maximum number of events.
   {
     base::AutoLock lock(shared_state_lock_);
     shared_state_.sent_main_frame_request_ = false;
+    queue_size_at_start = shared_state_.events_.size();
+  }
 
-    while (!shared_state_.events_.empty()) {
+  while (queue_size_at_start--) {
+    {
+      base::AutoLock lock(shared_state_lock_);
+
+      if (shared_state_.events_.empty())
+        return;
+
       if (IsRafAlignedEvent(shared_state_.events_.front())) {
         // Throttle touchmoves that are async.
         if (handle_raf_aligned_touch_input_ &&
             IsAsyncTouchMove(shared_state_.events_.front())) {
           if (shared_state_.events_.size() == 1 &&
               frame_time < shared_state_.last_async_touch_move_timestamp_ +
                                kAsyncTouchMoveInterval) {
             break;
           }
           shared_state_.last_async_touch_move_timestamp_ = frame_time;
         }
       }
-      events_to_process.emplace_back(shared_state_.events_.Pop());
+      in_flight_event_ = shared_state_.events_.Pop();
     }
+
+    // Dispatching the event is outside of critical section.
+    DispatchInFlightEvent();
   }
 
-  while(!events_to_process.empty()) {
-    in_flight_event_ = std::move(events_to_process.front());
-    events_to_process.pop_front();
-    DispatchInFlightEvent();
-  }
   PossiblyScheduleMainFrame();
 }
 
 void MainThreadEventQueue::PostTaskToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::DispatchEvents, this));
 }
 
 void MainThreadEventQueue::QueueEvent(
     std::unique_ptr<MainThreadEventQueueTask> event) {
@@ skipping 38 matching lines @@
     case blink::WebInputEvent::MouseWheel:
       return handle_raf_aligned_mouse_input_;
     case blink::WebInputEvent::TouchMove:
       return handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content