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 387 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;
+      needs_main_frame = true;
+      shared_state_.sent_main_frame_request_ = true;
     }
   }
   if (needs_main_frame)
     client_->NeedsMainFrame(routing_id_);
 }
 
 void MainThreadEventQueue::DispatchEvents() {
-  std::deque<std::unique_ptr<MainThreadEventQueueTask>> events_to_process;
+  size_t events_to_process;
+
+  // 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;
+    events_to_process = shared_state_.events_.size();
 
-    shared_state_.events_.swap(&events_to_process);
-
-    // 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()))
-        break;
-      shared_state_.events_.emplace_front(std::move(events_to_process.back()));
-      events_to_process.pop_back();
+    // Don't process rAF aligned events at tail of queue.
+    while (events_to_process > 0 &&
+           IsRafAlignedEvent(shared_state_.events_.at(events_to_process - 1))) {
+      --events_to_process;
     }
   }
-  while (!events_to_process.empty()) {
-    in_flight_event_ = std::move(events_to_process.front());
-    events_to_process.pop_front();
+
+  while (events_to_process--) {
+    {
+      base::AutoLock lock(shared_state_lock_);
+      if (shared_state_.events_.empty())
+        return;
+      in_flight_event_ = shared_state_.events_.Pop();
+    }
+
+    // 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