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 181 matching lines @@
       enable_non_blocking_due_to_main_thread_responsiveness_flag_(
           base::FeatureList::IsEnabled(
               features::kMainThreadBusyScrollIntervention)),
       handle_raf_aligned_touch_input_(
           allow_raf_aligned_input &&
           base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)),
       handle_raf_aligned_mouse_input_(
           allow_raf_aligned_input &&
           base::FeatureList::IsEnabled(features::kRafAlignedMouseInputEvents)),
       main_task_runner_(main_task_runner),
-      renderer_scheduler_(renderer_scheduler) {
+      renderer_scheduler_(renderer_scheduler),
+      use_raf_fallback_timer_(true) {
   if (enable_non_blocking_due_to_main_thread_responsiveness_flag_) {
     std::string group = base::FieldTrialList::FindFullName(
         "MainThreadResponsivenessScrollIntervention");
 
     // The group name will be of the form Enabled$THRESHOLD_MS. Trim the prefix
     // "Enabled", and parse the threshold.
     int threshold_ms = 0;
     std::string prefix = "Enabled";
     group.erase(0, prefix.length());
     base::StringToInt(group, &threshold_ms);
 
     if (threshold_ms <= 0) {
       enable_non_blocking_due_to_main_thread_responsiveness_flag_ = false;
     } else {
       main_thread_responsiveness_threshold_ =
           base::TimeDelta::FromMilliseconds(threshold_ms);
     }
   }
+  raf_fallback_timer_.SetTaskRunner(main_task_runner);
 }
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
     ui::WebScopedInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
@@ skipping 150 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()) {
+    if (use_raf_fallback_timer_) {
+      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