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 92 matching lines @@
     }
     pending_dowork_count_++;
   }
 
   main_task_runner_->PostTask(
       FROM_HERE, Bind(&TaskQueueManager::DoWork, task_queue_manager_weak_ptr_,
                       on_main_thread));
 }
 
 void TaskQueueManager::DoWork(bool posted_from_main_thread) {
+  scoped_refptr<DeletionSentinel> protect(deletion_sentinel_);
+
   if (posted_from_main_thread) {
     pending_dowork_count_--;
     DCHECK_GE(pending_dowork_count_, 0);
   }
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // Pass nullptr to UpdateWorkQueues here to prevent waking up a
   // pump-after-wakeup queue.
   if (!UpdateWorkQueues(nullptr))
     return;
 
   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);
 
+    // Detect if the TaskQueueManager got deleted during the

[Sami, 2015/04/08 14:24:04]

This should probably be moved to within ProcessTaskFromWorkQueue so that we bail
out immediately after the task runs. Actually |protect| could also be moved
there.

[alex clarke (OOO till 29th), 2015/04/08 14:33:05]

Done.

+    // ProcessTaskFromWorkQueue call.
+    if (protect->HasOneRef())
+      return;
+
     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));
@@ skipping 94 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