Ensure that SequencedWorkerPools in tests don't outlive their tests

base/threading/sequenced_worker_pool.cc

 // Copyright (c) 2012 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 "base/threading/sequenced_worker_pool.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
+#include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/simple_thread.h"
 #include "base/time.h"
 #include "base/tracked_objects.h"
 
 namespace base {
 
@@ skipping 224 matching lines @@
 
 SequencedWorkerPool::Inner::~Inner() {
   // You must call Shutdown() before destroying the pool.
   DCHECK(shutdown_called_);
 
   // Need to explicitly join with the threads before they're destroyed or else
   // they will be running when our object is half torn down.
   for (size_t i = 0; i < threads_.size(); i++)
     threads_[i]->Join();
   threads_.clear();
+
+  if (testing_observer_)
+    testing_observer_->OnDestruct();
 }
 
 SequencedWorkerPool::SequenceToken
 SequencedWorkerPool::Inner::GetSequenceToken() {
   subtle::Atomic32 result =
       subtle::NoBarrier_AtomicIncrement(&last_sequence_number_, 1);
   return SequenceToken(static_cast<int>(result));
 }
 
 SequencedWorkerPool::SequenceToken
@@ skipping 357 matching lines @@
   return !thread_being_created_ &&
          blocking_shutdown_thread_count_ == 0 &&
          blocking_shutdown_pending_task_count_ == 0;
 }
 
 // SequencedWorkerPool --------------------------------------------------------
 
 SequencedWorkerPool::SequencedWorkerPool(
     size_t max_threads,
     const std::string& thread_name_prefix)
-    : inner_(new Inner(ALLOW_THIS_IN_INITIALIZER_LIST(this),
-                       max_threads, thread_name_prefix)) {}
+    : constructor_message_loop_(MessageLoopProxy::current()),
+      inner_(new Inner(ALLOW_THIS_IN_INITIALIZER_LIST(this),
+                       max_threads, thread_name_prefix)) {
+  DCHECK(constructor_message_loop_.get());
+}
 
 SequencedWorkerPool::~SequencedWorkerPool() {}
 
+void SequencedWorkerPool::OnDestruct() const {
+  // TODO(akalin): Once we can easily check if we're on a worker
+  // thread or not, use that instead of restricting destruction to
+  // only the constructor message loop.
+  if (constructor_message_loop_->BelongsToCurrentThread()) {
+    LOG(INFO) << "Deleting on this thread";
+    delete this;
+  } else {
+    LOG(INFO) << "Deleting soon";
+    constructor_message_loop_->DeleteSoon(FROM_HERE, this);
+  }
+}
+
 SequencedWorkerPool::SequenceToken SequencedWorkerPool::GetSequenceToken() {
   return inner_->GetSequenceToken();
 }
 
 SequencedWorkerPool::SequenceToken SequencedWorkerPool::GetNamedSequenceToken(
     const std::string& name) {
   return inner_->GetNamedSequenceToken(name);
 }
 
 bool SequencedWorkerPool::PostWorkerTask(
@@ skipping 68 matching lines @@
 
 void SequencedWorkerPool::Shutdown() {
   inner_->Shutdown();
 }
 
 void SequencedWorkerPool::SetTestingObserver(TestingObserver* observer) {
   inner_->SetTestingObserver(observer);
 }
 
 }  // namespace base