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/histogram_macros.h"
+#include "base/strings/string_number_conversions.h"
+#include "components/variations/variations_associated_data.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 53 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 threshold = variations::GetVariationParamValueByFeature(
+        features::kMainThreadBusyScrollIntervention, "threshold");
+    int threshold_ms = 0;
+    base::StringToInt(threshold, &threshold_ms);
+    if (!threshold_ms) {
+      enable_non_blocking_due_to_main_thread_responsiveness_flag_ = false;

[dtapuska, 2016/12/16 19:59:46]

What about negative values? And StringToInt failing for overflow and underflow;
probably want it disabled in those cases no?

I'd expect this to be

if (!StringToInt(..) || threshold_ms <= 0)

[tdresser, 2016/12/16 20:12:08]

StringToInt saturates for overflow and underflow, which I think is fine. Added
handling for negative numbers.

+    } else {
+      main_thread_responsiveness_threshold_ =
+          base::TimeDelta::FromMilliseconds(threshold_ms);
+    }
+  }
+}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
     ui::ScopedWebInputEvent 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 34 matching lines @@
     }
 
     // If handling rAF aligned touch input ACK non-cancelable events right
     // away.
     if (!non_blocking && IsRafAlignedEvent(*touch_event))
       non_blocking = 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 (is_wheel && non_blocking) {
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
@@ skipping 198 matching lines @@
       // additional frame.
       return static_cast<const blink::WebTouchEvent&>(event).dispatchType !=
                  blink::WebInputEvent::Blocking &&
              handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content