Force events to be non blocking if main thread is unresponsive.

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"
 
@@ skipping 54 matching lines @@
     int routing_id,
     MainThreadEventQueueClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     blink::scheduler::RendererScheduler* renderer_scheduler)
     : routing_id_(routing_id),
       client_(client),
       is_flinging_(false),
       last_touch_start_forced_nonblocking_due_to_fling_(false),
       enable_fling_passive_listener_flag_(base::FeatureList::IsEnabled(
           features::kPassiveEventListenersDueToFling)),
+      enable_non_blocking_due_to_main_thread_responsiveness_flag_(
+          base::FeatureList::IsEnabled(
+              features::kMainThreadBusyScrollIntervention)),
       handle_raf_aligned_touch_input_(
           base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)),
       handle_raf_aligned_mouse_input_(
           base::FeatureList::IsEnabled(features::kRafAlignedMouseInputEvents)),
       main_task_runner_(main_task_runner),
       renderer_scheduler_(renderer_scheduler) {}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
@@ skipping 29 matching lines @@
         touch_event->dispatchType == blink::WebInputEvent::Blocking) {
       // If the touch start is forced to be passive due to fling, its following
       // touch move should also be passive.
       if (is_flinging_ || last_touch_start_forced_nonblocking_due_to_fling_) {
         touch_event->dispatchType =
             blink::WebInputEvent::ListenersForcedNonBlockingDueToFling;
         non_blocking = true;
         last_touch_start_forced_nonblocking_due_to_fling_ = true;
       }
     }
+
+    if (enable_non_blocking_due_to_main_thread_responsiveness_flag_ &&
+        touch_event->dispatchType == blink::WebInputEvent::Blocking) {
+      bool passive_due_to_unresponsive_main =
+          renderer_scheduler_
+              ->ShouldForceEventsNonBlockingForUnresponsiveMainThread();
+      if (passive_due_to_unresponsive_main) {
+        touch_event->dispatchType = blink::WebInputEvent::
+            ListenersForcedNonBlockingDueToMainThreadResponsiveness;
+        non_blocking = true;
+      }
+    }
   }
   if (is_wheel && non_blocking) {
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
     static_cast<blink::WebMouseWheelEvent*>(event.get())
         ->dispatchType = blink::WebInputEvent::ListenersNonBlockingPassive;
   }
 
   InputEventDispatchType dispatch_type =
       non_blocking ? DISPATCH_TYPE_NON_BLOCKING : DISPATCH_TYPE_BLOCKING;
@@ skipping 169 matching lines @@
       // additional frame.
       return static_cast<const blink::WebTouchEvent&>(event->event())
                      .dispatchType != blink::WebInputEvent::Blocking &&
              handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content