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

third_party/WebKit/Source/platform/scheduler/base/queueing_time_estimator.cc

Index: third_party/WebKit/Source/platform/scheduler/base/queueing_time_estimator.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/queueing_time_estimator.cc b/third_party/WebKit/Source/platform/scheduler/base/queueing_time_estimator.cc
index a8efe8d5d6b551286fa30c46fa604bd55904976c..43dc1b021162bb29f043b1d8c6280a9b288878b4 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/queueing_time_estimator.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/queueing_time_estimator.cc
@@ -4,7 +4,7 @@
 
 #include "platform/scheduler/base/queueing_time_estimator.h"
 
-#include "base/time/default_tick_clock.h"
+#include "base/memory/ptr_util.h"
 
 #include <algorithm>
 
@@ -59,17 +59,33 @@ QueueingTimeEstimator::QueueingTimeEstimator(
       window_duration_(window_duration),
       window_start_time_() {}
 
-void QueueingTimeEstimator::OnToplevelTaskCompleted(
-    base::TimeTicks task_start_time,
+QueueingTimeEstimator::QueueingTimeEstimator(
+    QueueingTimeEstimator::SerializedQueueingTimeEstimator
+        serialized_queueing_time_estimator)
+    : current_expected_queueing_time_(base::TimeDelta::FromInternalValue(
+          serialized_queueing_time_estimator[0])),
+      window_duration_(base::TimeDelta::FromInternalValue(
+          serialized_queueing_time_estimator[1])),
+      window_start_time_(base::TimeTicks::FromInternalValue(
+          serialized_queueing_time_estimator[2])),
+      current_task_start_time_(base::TimeTicks::FromInternalValue(
+          serialized_queueing_time_estimator[3])) {}
+
+void QueueingTimeEstimator::OnTopLevelTaskStarted(
+    base::TimeTicks task_start_time) {
+  current_task_start_time_ = task_start_time;
+}
+
+void QueueingTimeEstimator::OnTopLevelTaskCompleted(
     base::TimeTicks task_end_time) {
   if (window_start_time_.is_null())
-    window_start_time_ = task_start_time;
+    window_start_time_ = current_task_start_time_;
 
   while (TimePastWindowEnd(task_end_time)) {
-    if (!TimePastWindowEnd(task_start_time)) {
+    if (!TimePastWindowEnd(current_task_start_time_)) {
       // Include the current task in this window.
       current_expected_queueing_time_ += ExpectedQueueingTimeFromTask(
-          task_start_time, task_end_time, window_start_time_,
+          current_task_start_time_, task_end_time, window_start_time_,
           window_start_time_ + window_duration_);
     }
     client_->OnQueueingTimeForWindowEstimated(current_expected_queueing_time_);
@@ -78,8 +94,60 @@ void QueueingTimeEstimator::OnToplevelTaskCompleted(
   }
 
   current_expected_queueing_time_ += ExpectedQueueingTimeFromTask(
-      task_start_time, task_end_time, window_start_time_,
+      current_task_start_time_, task_end_time, window_start_time_,
       window_start_time_ + window_duration_);
+
+  current_task_start_time_ = base::TimeTicks();
+}
+
+QueueingTimeEstimator::SerializedQueueingTimeEstimator
+QueueingTimeEstimator::Serialize() const {
+  QueueingTimeEstimator::SerializedQueueingTimeEstimator result;
+  result[0] = current_expected_queueing_time_.ToInternalValue();
+  result[1] = window_duration_.ToInternalValue();
+  result[2] = window_start_time_.ToInternalValue();
+  result[3] = current_task_start_time_.ToInternalValue();
+  return result;
+}
+
+// Keeps track of the maximum queueing time.
+class RecordMaxQueueingTimeClient : public QueueingTimeEstimator::Client {
+ public:
+  void OnQueueingTimeForWindowEstimated(
+      base::TimeDelta queueing_time) override {
+    max_queueing_time_ = std::max(max_queueing_time_, queueing_time);
+  }
+
+  base::TimeDelta max_queueing_time() { return max_queueing_time_; }
+
+  RecordMaxQueueingTimeClient() {}
+  ~RecordMaxQueueingTimeClient() override {}
+
+ private:
+  base::TimeDelta max_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.
+  QueueingTimeEstimator temporary_queueing_time_estimator(*this);
+  temporary_queueing_time_estimator.client_ = &record_max_queueing_time_client;
+
+  if (!current_task_start_time_.is_null()) {
+    // There's a task in progress, pretend it ends now, and include it in the
+    // computation.
+    temporary_queueing_time_estimator.OnTopLevelTaskCompleted(now);
+  }
+
+  // Report the max queueing time, out of all windows spanned and the current
+  // window.
+  return std::max(
+      record_max_queueing_time_client.max_queueing_time(),
+      temporary_queueing_time_estimator.current_expected_queueing_time_);
 }
 
 bool QueueingTimeEstimator::TimePastWindowEnd(base::TimeTicks time) {