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();
+  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_);

[Sami, 2016/08/24 14:56:01]

This makes us take two locks for every task we execute which seems high to me
(even if they should generally be uncontented). I wonder if there's a way to
avoid that? How stale an estimate would still work?

[tdresser, 2016/08/24 17:22:50]

I think there are basically two options here:

The problem case is when the main thread is running an extremely long task, and
then partway through that task, the compositor thread needs to know the
estimated queueing time. This requires knowing the start time of that extremely
long task.

Either we lock, and ask when the task started, or we get the main thread to post
over to the compositor when each task started.

An estimate whose staleness is bounded in milliseconds would be fine. An
estimate whose staleness is bounded in number of main thread tasks is not. 

I should be able to get us down to a single lock per task, instead of two, if we
think that's adequate.

Do you have any other ideas?

[Sami, 2016/08/25 12:48:44]

Do you think this happens often enough that we actually need to handle this
case? It feels like hitting a long task without also seeing other long tasks on
the page prior to that is pretty rare, and getting a jank in that case is
probably fine.
Another thought I had is to do an atomic store to a variable that is sampled by
the compositor thread. Much cheaper than a lock, but still not entirely free.

[tdresser, 2016/08/25 15:27:12]

One of the biggest cases we want to address with this intervention is the very
first scroll on a page. I think this does happen often enough that we need to
address it.

We could do an atomic store of the task start time.

What I really want here is an atomic base::TimeTicks – I'm not sure what atomics
look like in chromium, can you point me in the right direction?

+  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);