Pass main thread responsiveness threshold via Finch

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"
 
 namespace content {
 
 namespace {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
 bool IsContinuousEvent(const std::unique_ptr<EventWithDispatchType>& event) {
@@ skipping 48 matching lines @@
       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) {}
+      renderer_scheduler_(renderer_scheduler) {
+  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);
+    }
+  }
+}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
     blink::WebScopedInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
          original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
@@ skipping 29 matching lines @@
         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_->MainThreadSeemsUnresponsive();
+          renderer_scheduler_->MainThreadSeemsUnresponsive(
+              main_thread_responsiveness_threshold_);
       if (passive_due_to_unresponsive_main) {
         touch_event->dispatchType = blink::WebInputEvent::
             ListenersForcedNonBlockingDueToMainThreadResponsiveness;
         non_blocking = true;
       }
     }
     // If the event is non-cancelable ACK it right away.
     if (!non_blocking &&
         touch_event->dispatchType != blink::WebInputEvent::Blocking)
       non_blocking = true;
@@ skipping 199 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