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

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
index 9c5e33a261fef355db3ff3399cc626aa9141ce70..b31b1e1f497e60d9eda632ad26bc55e9ca4533e5 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
@@ -36,6 +36,9 @@ const double kShortIdlePeriodDurationPercentile = 50;
 // Amount of idle time left in a frame (as a ratio of the vsync interval) above
 // which main thread compositing can be considered fast.
 const double kFastCompositingIdleTimeThreshold = .2;
+// Maximum task queueing time before the main thread is considered unresponsive.
+const base::TimeDelta kMainThreadUnresponsiveQueueingTime =
+    base::TimeDelta::FromMilliseconds(1000);
 }  // namespace
 
 RendererSchedulerImpl::RendererSchedulerImpl(
@@ -58,9 +61,9 @@ RendererSchedulerImpl::RendererSchedulerImpl(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
-      main_thread_only_(this,
-                        compositor_task_runner_,
+      main_thread_only_(compositor_task_runner_,
                         helper_.scheduler_tqm_delegate().get()),
+      any_thread_(this),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   throttling_helper_.reset(new ThrottlingHelper(this, "renderer.scheduler"));
@@ -108,7 +111,6 @@ RendererSchedulerImpl::~RendererSchedulerImpl() {
 }
 
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
-    RendererSchedulerImpl* renderer_scheduler_impl,
     const scoped_refptr<TaskQueue>& compositor_task_runner,
     base::TickClock* time_source)
     : loading_task_cost_estimator(time_source,
@@ -117,8 +119,6 @@ RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
       timer_task_cost_estimator(time_source,
                                 kTimerTaskEstimationSampleCount,
                                 kTimerTaskEstimationPercentile),
-      queueing_time_estimator(renderer_scheduler_impl,
-                              base::TimeDelta::FromSeconds(1)),
       idle_time_estimator(compositor_task_runner,
                           time_source,
                           kShortIdlePeriodDurationSampleCount,
@@ -147,8 +147,11 @@ RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
-RendererSchedulerImpl::AnyThread::AnyThread()
-    : awaiting_touch_start_response(false),
+RendererSchedulerImpl::AnyThread::AnyThread(
+    RendererSchedulerImpl* renderer_scheduler_impl)
+    : queueing_time_estimator(renderer_scheduler_impl,
+                              base::TimeDelta::FromSeconds(1)),
+      awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
@@ -1338,6 +1341,23 @@ void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) {
   MainThreadOnly().rail_mode_observer = observer;
 }
 
+bool RendererSchedulerImpl::
+    ShouldForceEventsNonBlockingForUnresponsiveMainThread() const {
+  base::TimeTicks now = base::TimeTicks::Now();

[dtapuska, 2016/08/23 16:18:29]

How does this code deal with non-high precision clocks?

ie; what is going to happen on those machines with high latency time.

[tdresser, 2016/08/23 17:25:33]

What's your concern, that we'll trigger too aggressively?

We're currently on activating if the expected queueing time is greater than a
full second, which is generous enough that I don't think there's any risk there.

+  base::TimeDelta estimated_queueing_time;
+
+  {
+    base::AutoLock lock(any_thread_lock_);
+
+    estimated_queueing_time =
+        AnyThread()
+            .queueing_time_estimator.EstimateQueueingTimeIncludingCurrentTask(
+                now);
+  }
+
+  return estimated_queueing_time > kMainThreadUnresponsiveQueueingTime;
+}
+
 void RendererSchedulerImpl::RegisterTimeDomain(TimeDomain* time_domain) {
   helper_.RegisterTimeDomain(time_domain);
 }
@@ -1407,12 +1427,21 @@ void RendererSchedulerImpl::OnTriedToExecuteBlockedTask(
   }
 }
 
+void RendererSchedulerImpl::ReportTaskStartTime(base::TimeTicks start_time) {
+  base::AutoLock lock(any_thread_lock_);
+  AnyThread().queueing_time_estimator.OnTopLevelTaskStarted(start_time);
+}
+
 void RendererSchedulerImpl::ReportTaskTime(base::TimeTicks start_time,
                                            base::TimeTicks end_time) {
-  MainThreadOnly().queueing_time_estimator.OnToplevelTaskCompleted(start_time,
-                                                                   end_time);
-  MainThreadOnly().long_task_tracker.RecordLongTask(
-      start_time, end_time - start_time);
+  {
+    base::AutoLock lock(any_thread_lock_);
+    AnyThread().queueing_time_estimator.OnTopLevelTaskCompleted(start_time,
+                                                                end_time);
+  }
+  MainThreadOnly().long_task_tracker.RecordLongTask(start_time,
+                                                    end_time - start_time);
+
   UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
                               (end_time - start_time).InMicroseconds(), 1,
                               1000000, 50);