Speculative patch: Make it safe to delete the TQM inside a Task

content/child/scheduler/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 "content/child/scheduler/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 446 matching lines @@
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     TaskQueueSelector* selector,
     const char* disabled_by_default_tracing_category)
     : main_task_runner_(main_task_runner),
       selector_(selector),
       pending_dowork_count_(0),
       work_batch_size_(1),
       time_source_(nullptr),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
+      deletion_sentinel_(new DeletionSentinel()),
       weak_factory_(this) {
   DCHECK(main_task_runner->RunsTasksOnCurrentThread());
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(disabled_by_default_tracing_category,
                                      "TaskQueueManager", this);
 
   task_queue_manager_weak_ptr_ = weak_factory_.GetWeakPtr();
   for (size_t i = 0; i < task_queue_count; i++) {
     scoped_refptr<internal::TaskQueue> queue(make_scoped_refptr(
         new internal::TaskQueue(this, disabled_by_default_tracing_category)));
     queues_.push_back(queue);
@@ skipping 112 matching lines @@
 
   base::PendingTask previous_task((tracked_objects::Location()),
                                   (base::Closure()));
   for (int i = 0; i < work_batch_size_; i++) {
     size_t queue_index;
     if (!SelectWorkQueueToService(&queue_index))
       return;
     // Note that this function won't post another call to DoWork if one is
     // already pending, so it is safe to call it in a loop.
     MaybePostDoWorkOnMainRunner();
-    ProcessTaskFromWorkQueue(queue_index, i > 0, &previous_task);
+
+    if (ProcessTaskFromWorkQueue(queue_index, i > 0, &previous_task))
+      return; // The TaskQueueManager got deleted, we must bail out.
 
     if (!UpdateWorkQueues(&previous_task))
       return;
   }
 }
 
 bool TaskQueueManager::SelectWorkQueueToService(size_t* out_queue_index) {
   bool should_run = selector_->SelectWorkQueueToService(out_queue_index);
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       disabled_by_default_tracing_category_, "TaskQueueManager", this,
       AsValueWithSelectorResult(should_run, *out_queue_index));
   return should_run;
 }
 
 void TaskQueueManager::DidQueueTask(base::PendingTask* pending_task) {
   pending_task->sequence_num = task_sequence_num_.GetNext();
   task_annotator_.DidQueueTask("TaskQueueManager::PostTask", *pending_task);
 }
 
-void TaskQueueManager::ProcessTaskFromWorkQueue(
+bool TaskQueueManager::ProcessTaskFromWorkQueue(
     size_t queue_index,
     bool has_previous_task,
     base::PendingTask* previous_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
+  scoped_refptr<DeletionSentinel> protect(deletion_sentinel_);
   internal::TaskQueue* queue = Queue(queue_index);
   base::PendingTask pending_task = queue->TakeTaskFromWorkQueue();
   if (!pending_task.nestable && main_task_runner_->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.
     main_task_runner_->PostNonNestableTask(pending_task.posted_from,
                                            pending_task.task);
   } else {
     // Suppress "will" task observer notifications for the first and "did"
     // notifications for the last task in the batch to avoid duplicate
     // notifications.
     if (has_previous_task) {
       FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                         DidProcessTask(*previous_task));
       FOR_EACH_OBSERVER(base::MessageLoop::TaskObserver, task_observers_,
                         WillProcessTask(pending_task));
     }
     task_annotator_.RunTask("TaskQueueManager::PostTask",
                             "TaskQueueManager::RunTask", 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 true;
+
     pending_task.task.Reset();
     *previous_task = pending_task;
   }
+  return false;
 }
 
 bool TaskQueueManager::RunsTasksOnCurrentThread() const {
   return main_task_runner_->RunsTasksOnCurrentThread();
 }
 
 bool TaskQueueManager::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
@@ skipping 49 matching lines @@
   state->EndArray();
   state->BeginDictionary("selector");
   selector_->AsValueInto(state.get());
   state->EndDictionary();
   if (should_run)
     state->SetInteger("selected_queue", selected_queue);
   return state;
 }
 
 }  // namespace content