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

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

 // Copyright 2014 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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 24 matching lines @@
 const int kShortIdlePeriodDurationSampleCount = 10;
 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;
 constexpr base::TimeDelta kThreadLoadTrackerReportingInterval =
     base::TimeDelta::FromMinutes(1);
 constexpr base::TimeDelta kThreadLoadTrackerWaitingPeriodBeforeReporting =
     base::TimeDelta::FromMinutes(2);
 
+// Maximum task queueing time before the main thread is considered unresponsive.
+const base::TimeDelta kMainThreadUnresponsiveQueueingTime =

[Sami, 2016/11/02 19:01:42]

constexpr to avoid a global static initializer.

[tdresser, 2016/11/03 13:56:10]

Done.

+    base::TimeDelta::FromMilliseconds(200);
+
 void ReportForegroundRendererTaskLoad(base::TimeTicks time, double load) {
   int load_percentage = static_cast<int>(load * 100);
   UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.ForegroundRendererMainThreadLoad",
                            load_percentage);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.ForegroundRendererLoad", load_percentage);
 }
 
 void ReportBackgroundRendererTaskLoad(base::TimeTicks time, double load) {
   int load_percentage = static_cast<int>(load * 100);
@@ skipping 24 matching lines @@
                    base::TimeDelta()),
       render_widget_scheduler_signals_(this),
       control_task_runner_(helper_.ControlTaskRunner()),
       compositor_task_runner_(
           helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR)
                                    .SetShouldMonitorQuiescence(true))),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
+      seqlock_queueing_time_estimator_(
+          QueueingTimeEstimator(this, base::TimeDelta::FromSeconds(1))),
       main_thread_only_(this,
                         compositor_task_runner_,
                         helper_.scheduler_tqm_delegate().get(),
                         helper_.scheduler_tqm_delegate()->NowTicks()),
+      any_thread_(this),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   task_queue_throttler_.reset(
       new TaskQueueThrottler(this, "renderer.scheduler"));
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
   suspend_timers_when_backgrounded_closure_.Reset(
@@ skipping 42 matching lines @@
     RendererSchedulerImpl* renderer_scheduler_impl,
     const scoped_refptr<TaskQueue>& compositor_task_runner,
     base::TickClock* time_source,
     base::TimeTicks now)
     : loading_task_cost_estimator(time_source,
                                   kLoadingTaskEstimationSampleCount,
                                   kLoadingTaskEstimationPercentile),
       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,
                           kShortIdlePeriodDurationPercentile),
       background_main_thread_load_tracker(
           now,
           base::Bind(&ReportBackgroundRendererTaskLoad),
           kThreadLoadTrackerReportingInterval,
           kThreadLoadTrackerWaitingPeriodBeforeReporting),
       foreground_main_thread_load_tracker(
@@ skipping 18 matching lines @@
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       in_idle_period_for_testing(false),
       use_virtual_time(false),
       rail_mode_observer(nullptr) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
-RendererSchedulerImpl::AnyThread::AnyThread()
+RendererSchedulerImpl::AnyThread::AnyThread(
+    RendererSchedulerImpl* renderer_scheduler_impl)
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
       default_gesture_prevented(true),
       have_seen_touchstart(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
@@ skipping 1224 matching lines @@
   default_loading_task_runner_->SetBlameContext(blame_context);
   default_timer_task_runner_->SetBlameContext(blame_context);
   compositor_task_runner_->SetBlameContext(blame_context);
   idle_helper_.IdleTaskRunner()->SetBlameContext(blame_context);
 }
 
 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;
+
+  std::unique_ptr<QueueingTimeEstimator> queueing_time_estimator;
+  {
+    bool can_read = false;
+    base::subtle::Atomic32 version;
+    seqlock_queueing_time_estimator_.seqlock.ReadOrFail(&can_read, &version);
+
+    if (can_read) {
+      // TODO - is this copy okay? Use memcpy?

[Sami, 2016/11/02 19:01:42]

I'd need to think about this a bit more, but I think this is only safe for POD
data. If there are pointers or objects in the buffer, we might read their values
correctly but the objects they are pointing to (which live outside the buffer)
aren't safe to access. Would it be easy to just write numbers into the buffer?

[tdresser, 2016/11/03 13:56:10]

Done, though it's a bit ugly. This is probably a bit conservative (I suspect we
could safely copy base::TimeTicks/base::TimeDelta, but this is the clearest
approach, and should make the critical sections as short as possible).

[alex clarke (OOO till 29th), 2016/11/03 15:20:53]

I'm not sure what we gain by /not/ copying the base::TimeTicks/base::TimeDelta.

+      queueing_time_estimator.reset(
+          new QueueingTimeEstimator(seqlock_queueing_time_estimator_.data));
+    }
+
+    // If we didn't successfully read the first time, assume we aren't busy.
+    if (seqlock_queueing_time_estimator_.seqlock.ReadRetry(version))
+      queueing_time_estimator.reset();
+  }
+
+  if (queueing_time_estimator) {
+    estimated_queueing_time =
+        queueing_time_estimator->EstimateQueueingTimeIncludingCurrentTask(now);
+  }
+
+  return estimated_queueing_time > kMainThreadUnresponsiveQueueingTime;
+}
+
 void RendererSchedulerImpl::RegisterTimeDomain(TimeDomain* time_domain) {
   helper_.RegisterTimeDomain(time_domain);
 }
 
 void RendererSchedulerImpl::UnregisterTimeDomain(TimeDomain* time_domain) {
   helper_.UnregisterTimeDomain(time_domain);
 }
 
 base::TickClock* RendererSchedulerImpl::tick_clock() const {
   return helper_.scheduler_tqm_delegate().get();
@@ skipping 49 matching lines @@
         true;
     BroadcastIntervention(
         "Blink deferred a task in order to make scrolling smoother. "
         "Your timer and network tasks should take less than 50ms to run "
         "to avoid this. Please see "
         "https://developers.google.com/web/tools/chrome-devtools/profile/evaluate-performance/rail"
         " and https://crbug.com/574343#c40 for more information.");
   }
 }
 
-void RendererSchedulerImpl::ReportTaskTime(TaskQueue* task_queue,
-                                           double start_time,
-                                           double end_time) {
+void RendererSchedulerImpl::ReportTaskStartTime(double start_time) {
+  base::TimeTicks start_time_ticks =
+      MonotonicTimeInSecondsToTimeTicks(start_time);
+  MainThreadOnly().current_task_start_time = start_time_ticks;
+
+  seqlock_queueing_time_estimator_.seqlock.WriteBegin();
+  seqlock_queueing_time_estimator_.data.OnTopLevelTaskStarted(start_time_ticks);
+  seqlock_queueing_time_estimator_.seqlock.WriteEnd();
+}
+
+void RendererSchedulerImpl::ReportTaskEndTime(TaskQueue* task_queue,
+                                              double start_time,
+                                              double end_time) {
   // TODO(scheduler-dev): Remove conversions when Blink starts using
   // base::TimeTicks instead of doubles for time.
   base::TimeTicks start_time_ticks =
       MonotonicTimeInSecondsToTimeTicks(start_time);
   base::TimeTicks end_time_ticks = MonotonicTimeInSecondsToTimeTicks(end_time);
 
-  MainThreadOnly().queueing_time_estimator.OnToplevelTaskCompleted(
-      start_time_ticks, end_time_ticks);
+  seqlock_queueing_time_estimator_.seqlock.WriteBegin();
+  seqlock_queueing_time_estimator_.data.OnTopLevelTaskCompleted(end_time_ticks);
+  seqlock_queueing_time_estimator_.seqlock.WriteEnd();
 
   task_queue_throttler()->OnTaskRunTimeReported(task_queue, start_time_ticks,
                                                 end_time_ticks);
 
   // We want to measure thread time here, but for efficiency reasons
   // we stick with wall time.
   MainThreadOnly().foreground_main_thread_load_tracker.RecordTaskTime(
       start_time_ticks, end_time_ticks);
   MainThreadOnly().background_main_thread_load_tracker.RecordTaskTime(
       start_time_ticks, end_time_ticks);
@@ skipping 82 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink