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 29 matching lines @@
 // 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);
 // We do not throttle anything while audio is played and shortly after that.
 constexpr base::TimeDelta kThrottlingDelayAfterAudioIsPlayed =
     base::TimeDelta::FromSeconds(5);
+// Maximum task queueing time before the main thread is considered unresponsive.
+constexpr base::TimeDelta kMainThreadResponsivenessThreshold =
+    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);
   UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.BackgroundRendererMainThreadLoad",
                            load_percentage);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.BackgroundRendererLoad", load_percentage);
 }
 
 base::TimeTicks MonotonicTimeInSecondsToTimeTicks(
     double monotonicTimeInSeconds) {
-  return base::TimeTicks() + base::TimeDelta::FromSecondsD(
-      monotonicTimeInSeconds);
+  return base::TimeTicks() +
+         base::TimeDelta::FromSecondsD(monotonicTimeInSeconds);
 }
 
 std::string PointerToId(void* pointer) {
   return base::StringPrintf(
       "0x%" PRIx64,
       static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pointer)));
 }
 
 }  // namespace
 
@@ skipping 13 matching lines @@
       control_task_runner_(helper_.ControlTaskRunner()),
       compositor_task_runner_(
           helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR)
                                    .SetShouldMonitorQuiescence(true))),
       compositor_task_runner_enabled_voter_(
           compositor_task_runner_->CreateQueueEnabledVoter()),
       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()),
       policy_may_need_update_(&any_thread_lock_),
+      main_thread_responsiveness_threshold_(kMainThreadResponsivenessThreshold),
       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(
       base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded,
@@ skipping 50 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 32 matching lines @@
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
       default_gesture_prevented(true),
       have_seen_touchstart(false),
       waiting_for_meaningful_paint(false),
       have_seen_input_since_navigation(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
-    : last_input_type(blink::WebInputEvent::Undefined) {}
+    : last_input_type(blink::WebInputEvent::Undefined),
+      main_thread_seems_unresponsive(false) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
   base::TimeTicks now = tick_clock()->NowTicks();
   MainThreadOnly().background_main_thread_load_tracker.RecordIdle(now);
   MainThreadOnly().foreground_main_thread_load_tracker.RecordIdle(now);
 
   task_queue_throttler_.reset();
   helper_.Shutdown();
@@ skipping 1350 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::MainThreadSeemsUnresponsive() {
+  base::TimeTicks now = tick_clock()->NowTicks();
+  base::TimeDelta estimated_queueing_time;
+
+  bool can_read = false;
+  QueueingTimeEstimator::State queueing_time_estimator_state;
+
+  base::subtle::Atomic32 version;
+  seqlock_queueing_time_estimator_.seqlock.ReadOrFail(&can_read, &version);
+
+  // If we fail to determine if the main thread is busy, assume whether or not
+  // it's busy hasn't change since the last time we asked.
+  if (!can_read)
+    return CompositorThreadOnly().main_thread_seems_unresponsive;
+
+  queueing_time_estimator_state = seqlock_queueing_time_estimator_.data.state();
+
+  // If we fail to determine if the main thread is busy, assume whether or not
+  // it's busy hasn't change since the last time we asked.
+  if (seqlock_queueing_time_estimator_.seqlock.ReadRetry(version))
+    return CompositorThreadOnly().main_thread_seems_unresponsive;
+
+  QueueingTimeEstimator queueing_time_estimator(queueing_time_estimator_state);
+
+  estimated_queueing_time =
+      queueing_time_estimator.EstimateQueueingTimeIncludingCurrentTask(now);
+
+  bool main_thread_seems_unresponsive =
+      estimated_queueing_time > main_thread_responsiveness_threshold_;
+  CompositorThreadOnly().main_thread_seems_unresponsive =
+      main_thread_seems_unresponsive;
+
+  return main_thread_seems_unresponsive;
+}
+
 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 44 matching lines @@
       base::AutoLock lock(any_thread_lock_);
       if (!AnyThread().have_seen_touchstart)
         return;
     }
     MainThreadOnly().have_reported_blocking_intervention_since_navigation =
         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"
+        "https://developers.google.com/web/tools/chrome-devtools/profile/"
+        "evaluate-performance/rail"
         " and https://crbug.com/574343#c40 for more information.");
   }
 }
 
+void RendererSchedulerImpl::willProcessTask(TaskQueue* task_queue,
+                                            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::didProcessTask(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);
   // TODO(altimin): Per-page metrics should also be considered.
-  UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
-                              (end_time_ticks - start_time_ticks).InMicroseconds(), 1,
-                              1000000, 50);
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "RendererScheduler.TaskTime",
+      (end_time_ticks - start_time_ticks).InMicroseconds(), 1, 1000000, 50);
   UMA_HISTOGRAM_ENUMERATION("RendererScheduler.NumberOfTasksPerQueueType",
                             static_cast<int>(task_queue->GetQueueType()),
                             static_cast<int>(TaskQueue::QueueType::COUNT));
 }
 
 void RendererSchedulerImpl::AddTaskTimeObserver(
     TaskTimeObserver* task_time_observer) {
   helper_.AddTaskTimeObserver(task_time_observer);
 }
 
@@ skipping 109 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink