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

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.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/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 229 matching lines @@
 
   for (int i = 0; i < work_batch_size_; i++) {
     internal::WorkQueue* work_queue;
     if (!SelectWorkQueueToService(&work_queue))
       break;
 
     // TaskQueueManager guarantees that task queue will not be deleted
     // when we are in DoWork (but WorkQueue may be deleted).
     internal::TaskQueueImpl* task_queue = work_queue->task_queue();
 
+    if (!delegate_->IsNested()) {
+      for (auto& observer : task_time_observers_)
+        observer.ReportTaskStartTime(MonotonicTimeInSeconds(task_start_time));
+    }
+
     switch (ProcessTaskFromWorkQueue(work_queue)) {
       case ProcessTaskResult::DEFERRED:
+        if (delegate_->IsNested())
+          continue;
+        // TODO - test this case.
         // If a task was deferred, try again with another task.
+        for (auto& observer : task_time_observers_) {
+          observer.ReportTaskEndTime(task_queue,
+                                     MonotonicTimeInSeconds(task_start_time),
+                                     MonotonicTimeInSeconds(task_start_time));
+        }
         continue;
       case ProcessTaskResult::EXECUTED:
         break;
       case ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED:
         return;  // The TaskQueueManager got deleted, we must bail out.
     }
 
     lazy_now = real_time_domain()->CreateLazyNow();
     if (!delegate_->IsNested() && task_start_time != base::TimeTicks()) {
       // Only report top level task durations.
       base::TimeTicks task_end_time = lazy_now.Now();
       for (auto& observer : task_time_observers_) {
-        observer.ReportTaskTime(task_queue,
-                                MonotonicTimeInSeconds(task_start_time),
-                                MonotonicTimeInSeconds(task_end_time));
+        observer.ReportTaskEndTime(task_queue,
+                                   MonotonicTimeInSeconds(task_start_time),
+                                   MonotonicTimeInSeconds(task_end_time));
       }
       task_start_time = task_end_time;
     }
 
     work_queue = nullptr;  // The queue may have been unregistered.
 
     UpdateWorkQueues(lazy_now);
 
     // Only run a single task per batch in nested run loops so that we can
     // properly exit the nested loop when someone calls RunLoop::Quit().
@@ skipping 212 matching lines @@
                                            *work_queue->GetFrontTask());
   }
 }
 
 bool TaskQueueManager::HasImmediateWorkForTesting() const {
   return !selector_.EnabledWorkQueuesEmpty();
 }
 
 }  // namespace scheduler
 }  // namespace blink