Add crash keys to TaskQueueManager::ProcessTaskFromWorkQueue

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"
+#include "base/debug/crash_logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
 #include "platform/scheduler/base/task_queue_selector.h"
 #include "platform/scheduler/base/work_queue.h"
 #include "platform/scheduler/base/work_queue_sets.h"
 #include "public/platform/scheduler/base/task_time_observer.h"
 
@@ skipping 26 matching lines @@
     base::OnceClosure cb) {
   return base::BindRepeating([](base::OnceClosure cb) { std::move(cb).Run(); },
                              base::Passed(&cb));
 }
 }
 
 TaskQueueManager::TaskQueueManager(
     scoped_refptr<TaskQueueManagerDelegate> delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
-    const char* disabled_by_default_verbose_tracing_category)
+    const char* disabled_by_default_verbose_tracing_category,
+    bool set_crash_keys)
     : real_time_domain_(new RealTimeDomain(tracing_category)),
       delegate_(delegate),
       task_was_run_on_quiescence_monitored_queue_(false),
       other_thread_pending_wakeup_(false),
+      set_crash_keys_(set_crash_keys),
       work_batch_size_(1),
       task_count_(0),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
       currently_executing_task_queue_(nullptr),
       observer_(nullptr),
       deletion_sentinel_(new DeletionSentinel()),
@@ skipping 238 matching lines @@
   task_annotator_.DidQueueTask("TaskQueueManager::PostTask", pending_task);
 }
 
 TaskQueueManager::ProcessTaskResult TaskQueueManager::ProcessTaskFromWorkQueue(
     internal::WorkQueue* work_queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<DeletionSentinel> protect(deletion_sentinel_);
   internal::TaskQueueImpl::Task pending_task =
       work_queue->TakeTaskFromWorkQueue();
 
+  // Temporary for https://crbug.com/660427
+  CHECK(!pending_task.task.is_null()) << "Posted from "
+                                      << pending_task.posted_from.ToString();
+
   // It's possible the task was canceled, if so bail out.
   if (pending_task.task.IsCancelled())
     return ProcessTaskResult::EXECUTED;
 
   internal::TaskQueueImpl* queue = work_queue->task_queue();
   if (queue->GetQuiescenceMonitored())
     task_was_run_on_quiescence_monitored_queue_ = true;
 
+  static const char kBlinkSchedulerTaskFunctionNameKey[] =
+      "blink_scheduler_task_function_name";
+  static const char kBlinkSchedulerTaskFileNameKey[] =
+      "blink_scheduler_task_file_name";
+
+  bool is_nested = delegate_->IsNested();
+  if (!is_nested && set_crash_keys_) {
+    base::debug::SetCrashKeyValue(kBlinkSchedulerTaskFunctionNameKey,
+                                  pending_task.posted_from.file_name());
+    base::debug::SetCrashKeyValue(kBlinkSchedulerTaskFileNameKey,
+                                  pending_task.posted_from.function_name());
+  }
+
   if (!pending_task.nestable && delegate_->IsNested()) {
     // Defer non-nestable work to the main task runner.  NOTE these tasks can be
     // arbitrarily delayed so the additional delay should not be a problem.
     // TODO(skyostil): Figure out a way to not forget which task queue the
     // task is associated with. See http://crbug.com/522843.
     // TODO(tzik): Remove base::UnsafeConvertOnceClosureToRepeating once
     // TaskRunners have migrated to OnceClosure.
     delegate_->PostNonNestableTask(
         pending_task.posted_from,
         UnsafeConvertOnceClosureToRepeating(std::move(pending_task.task)));
@@ skipping 11 matching lines @@
   }
   TRACE_EVENT1(tracing_category_, "TaskQueueManager::RunTask", "queue",
                queue->GetName());
   // NOTE when TaskQueues get unregistered a reference ends up getting retained
   // by |queues_to_delete_| which is cleared at the top of |DoWork|. This means
   // we are OK to use raw pointers here.
   internal::TaskQueueImpl* prev_executing_task_queue =
       currently_executing_task_queue_;
   currently_executing_task_queue_ = queue;
   task_annotator_.RunTask("TaskQueueManager::PostTask", &pending_task);
+
   // Detect if the TaskQueueManager just got deleted.  If this happens we must
   // not access any member variables after this point.
   if (protect->HasOneRef())
     return ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED;
 
+  if (!is_nested && set_crash_keys_) {
+    base::debug::ClearCrashKey(kBlinkSchedulerTaskFunctionNameKey);
+    base::debug::ClearCrashKey(kBlinkSchedulerTaskFileNameKey);
+  }
+
   currently_executing_task_queue_ = prev_executing_task_queue;
 
   if (queue->GetShouldNotifyObservers()) {
     for (auto& observer : task_observers_)
       observer.DidProcessTask(pending_task);
     queue->NotifyDidProcessTask(pending_task);
   }
 
   return ProcessTaskResult::EXECUTED;
 }
@@ skipping 116 matching lines @@
                                            *work_queue->GetFrontTask());
   }
 }
 
 bool TaskQueueManager::HasImmediateWorkForTesting() const {
   return !selector_.EnabledWorkQueuesEmpty();
 }
 
 }  // namespace scheduler
 }  // namespace blink