Add a BeginMainFrame fallback to MainThreadEventQueue.

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"
 #include "content/common/input_messages.h"
 #include "content/renderer/render_widget.h"
 
 namespace content {
 
 namespace {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
+const base::TimeDelta kMaxRafDelay =
+    base::TimeDelta::FromMilliseconds(5 * 1000);
 
 class QueuedClosure : public MainThreadEventQueueTask {
  public:
   QueuedClosure(const base::Closure& closure) : closure_(closure) {}
 
   ~QueuedClosure() override {}
 
   FilterResult FilterNewEvent(
       const MainThreadEventQueueTask& other_task) override {
     return other_task.IsWebInputEvent() ? FilterResult::KeepIterating
@@ skipping 370 matching lines @@
     return false;
   const QueuedWebInputEvent* event =
       static_cast<const QueuedWebInputEvent*>(queued_item.get());
   if (event->event().GetType() != blink::WebInputEvent::kTouchMove)
     return false;
   const blink::WebTouchEvent& touch_event =
       static_cast<const blink::WebTouchEvent&>(event->event());
   return touch_event.moved_beyond_slop_region && !event->originallyCancelable();
 }
 
+void MainThreadEventQueue::RafFallbackTimerFired() {
+  UMA_HISTOGRAM_BOOLEAN("Event.MainThreadEventQueue.FlushQueueNoBeginMainFrame",
+                        true);
+  DispatchRafAlignedInput(base::TimeTicks::Now());
+}
+
 void MainThreadEventQueue::DispatchRafAlignedInput(base::TimeTicks frame_time) {
   if (IsRafAlignedInputDisabled())
     return;
 
+  raf_fallback_timer_.Stop();
   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();
   }
 
@@ skipping 99 matching lines @@
   if (renderer_scheduler_) {
     renderer_scheduler_->DidHandleInputEventOnMainThread(
         event, ack_result == INPUT_EVENT_ACK_STATE_CONSUMED
                    ? blink::WebInputEventResult::kHandledApplication
                    : blink::WebInputEventResult::kNotHandled);
   }
 }
 
 void MainThreadEventQueue::SetNeedsMainFrame() {
   if (main_task_runner_->BelongsToCurrentThread()) {
+    raf_fallback_timer_.Start(
+        FROM_HERE, kMaxRafDelay,
+        base::Bind(&MainThreadEventQueue::RafFallbackTimerFired, this));
     if (client_)
       client_->SetNeedsMainFrame();
     return;
   }
 
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::SetNeedsMainFrame, this));
 }
 
 void MainThreadEventQueue::ClearClient() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   client_ = nullptr;
 }
 
 }  // namespace content