Don't process more than the queued events during rAF.

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;
-
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
 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
@@ skipping 192 matching lines @@
             in_flight_event_->event());
       }
     }
   }
 }
 
 void MainThreadEventQueue::DispatchRafAlignedInput() {
   if (!handle_raf_aligned_input_)
     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()))
+        break;
+      events_to_process.emplace_back(shared_state_.events_.Pop());
+    }
   }
 
-  for (size_t i = 0; i < kMaxEventsPerRafTask; ++i) {
-    {
-      base::AutoLock lock(shared_state_lock_);
-      if (shared_state_.events_.empty())
-        break;
-
-      if (!isContinuousEvent(shared_state_.events_.front()))
-        break;
-      in_flight_event_ = shared_state_.events_.Pop();
-    }
+  while(!events_to_process.empty()) {
+    in_flight_event_.reset(events_to_process.front().release());

[tdresser, 2016/09/14 16:33:26]

Can we use 
in_flight_event_ = std::move(events_to_process.front);
?

[dtapuska, 2016/09/14 17:19:31]

Done.

+    events_to_process.pop_front();
     DispatchInFlightEvent();
   }
   PossiblyScheduleMainFrame();
 }
 
 void MainThreadEventQueue::SendEventNotificationToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::DispatchSingleEvent, this));
 }
 
@@ skipping 26 matching lines @@
       }
     }
   }
   for (size_t i = 0; i < send_notification_count; ++i)
     SendEventNotificationToMainThread();
   if (needs_main_frame)
     client_->NeedsMainFrame(routing_id_);
 }
 
 }  // namespace content