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

third_party/WebKit/Source/platform/scheduler/base/queueing_time_estimator.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 "platform/scheduler/base/queueing_time_estimator.h"
 
-#include "base/time/default_tick_clock.h"
+#include "base/memory/ptr_util.h"
 
 #include <algorithm>
 
 namespace blink {
 namespace scheduler {
 
 namespace {
 
 // This method computes the expected queueing time of a randomly distributed
 // task R within a window containing a single task T. Let T' be the time range
@@ skipping 34 matching lines @@
 
 }  // namespace
 
 QueueingTimeEstimator::QueueingTimeEstimator(
     QueueingTimeEstimator::Client* client,
     base::TimeDelta window_duration)
     : client_(client),
       window_duration_(window_duration),
       window_start_time_() {}
 
-void QueueingTimeEstimator::OnToplevelTaskCompleted(
+void QueueingTimeEstimator::OnTopLevelTaskStarted(base::TimeTicks task_start_time) {
+  current_task_start_time_ = task_start_time;
+}
+
+void QueueingTimeEstimator::OnTopLevelTaskCompleted(
     base::TimeTicks task_start_time,
     base::TimeTicks task_end_time) {
+  current_task_start_time_ = base::TimeTicks();
   if (window_start_time_.is_null())
     window_start_time_ = task_start_time;
 
   while (TimePastWindowEnd(task_end_time)) {
     if (!TimePastWindowEnd(task_start_time)) {
       // Include the current task in this window.
       current_expected_queueing_time_ += ExpectedQueueingTimeFromTask(
           task_start_time, task_end_time, window_start_time_,
           window_start_time_ + window_duration_);
     }
     client_->OnQueueingTimeForWindowEstimated(current_expected_queueing_time_);
     window_start_time_ += window_duration_;
     current_expected_queueing_time_ = base::TimeDelta();
   }
 
   current_expected_queueing_time_ += ExpectedQueueingTimeFromTask(
       task_start_time, task_end_time, window_start_time_,
       window_start_time_ + window_duration_);
 }
 
+// Keeps track of the maximum queueing time.
+class RecordMaxQueueingTimeClient : public QueueingTimeEstimator::Client {
+ public:
+  void OnQueueingTimeForWindowEstimated(
+      base::TimeDelta queueing_time) override {
+    worst_queueing_time_ = std::max(worst_queueing_time_, queueing_time);
+  }
+
+  base::TimeDelta worst_queueing_time() {

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

naming nit: "worst_queueing_time" is subjective but "max_queueing_time" would be
objective and match the name of this class :)

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

Done.

+    return worst_queueing_time_;
+  }
+
+  RecordMaxQueueingTimeClient() {}
+  ~RecordMaxQueueingTimeClient() override {}
+
+ private:
+  base::TimeDelta worst_queueing_time_;
+  DISALLOW_COPY_AND_ASSIGN(RecordMaxQueueingTimeClient);
+};
+
+base::TimeDelta QueueingTimeEstimator::EstimateQueueingTimeIncludingCurrentTask(
+    base::TimeTicks now) const {
+  RecordMaxQueueingTimeClient record_max_queueing_time_client;
+
+  // Make a copy of this QueueingTimeEstimator. We'll use it to evaluate the
+  // estimated input latency, assuming that any active task ends now.
+  std::unique_ptr<QueueingTimeEstimator> temporary_queueing_time_estimator =
+      CloneWithClient(&record_max_queueing_time_client);
+
+  // Use a task of length zero to ensure we consider the most recent window
+  // (aligned to window intervals).
+  base::TimeTicks start_time = now;
+  base::TimeTicks end_time = now;
+
+  // If there's a task in progress, pretend it ends now, and include it in the
+  // computation.
+  if (!current_task_start_time_.is_null())
+    start_time = current_task_start_time_;
+
+  temporary_queueing_time_estimator->OnTopLevelTaskCompleted(start_time,
+                                                             end_time);
+
+  // Report the worst queueing time, out of all windows spanned and the current
+  // window.
+  return std::max(
+      record_max_queueing_time_client.worst_queueing_time(),
+      temporary_queueing_time_estimator->current_expected_queueing_time_);
+}
+
+std::unique_ptr<QueueingTimeEstimator> QueueingTimeEstimator::CloneWithClient(
+    Client* client) const {
+  auto queueing_time_estimator =
+      base::MakeUnique<QueueingTimeEstimator>(client, window_duration_);
+  queueing_time_estimator->current_expected_queueing_time_ =
+      current_expected_queueing_time_;
+  queueing_time_estimator->window_start_time_ = window_start_time_;
+  queueing_time_estimator->current_task_start_time_ = current_task_start_time_;
+  return queueing_time_estimator;
+}
+
 bool QueueingTimeEstimator::TimePastWindowEnd(base::TimeTicks time) {
   return time > window_start_time_ + window_duration_;
 }
 
 }  // namespace scheduler
 }  // namespace blink