Ensure that SequencedWorkerPools in tests don't outlive their tests

base/threading/sequenced_worker_pool.h

 // 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.
 
 #ifndef BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 #define BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 #pragma once
 
 #include <cstddef>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
 namespace base {
 
+class MessageLoopProxy;
+
+template <class T> class DeleteHelper;
+
 // A worker thread pool that enforces ordering between sets of tasks. It also
 // allows you to specify what should happen to your tasks on shutdown.
 //
 // To enforce ordering, get a unique sequence token from the pool and post all
 // tasks you want to order with the token. All tasks with the same token are
 // guaranteed to execute serially, though not necessarily on the same thread.
 //
 // Example:
 //   SequencedWorkerPool::SequenceToken token = pool.GetSequenceToken();
 //   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
@@ skipping 77 matching lines @@
     explicit SequenceToken(int id) : id_(id) {}
 
     int id_;
   };
 
   // Allows tests to perform certain actions.
   class TestingObserver {
    public:
     virtual ~TestingObserver() {}
     virtual void WillWaitForShutdown() = 0;
+    virtual void OnDestruct() = 0;
   };
 
   // Pass the maximum number of threads (they will be lazily created as needed)
   // and a prefix for the thread name to ad in debugging.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix);
 
   // Returns a unique token that can be used to sequence tasks posted to
   // PostSequencedWorkerTask(). Valid tokens are alwys nonzero.
   SequenceToken GetSequenceToken();
@@ skipping 86 matching lines @@
   // After this call, subsequent calls to post tasks will fail.
   void Shutdown();
 
   // Called by tests to set the testing observer. This is NULL by default
   // and ownership of the pointer is kept with the caller.
   void SetTestingObserver(TestingObserver* observer);
 
  protected:
   virtual ~SequencedWorkerPool();
 
+  virtual void OnDestruct() const OVERRIDE;
+
  private:
   friend class RefCountedThreadSafe<SequencedWorkerPool>;
+  friend class DeleteHelper<SequencedWorkerPool>;
 
   class Inner;
   class Worker;
 
-  // Avoid pulling in too many headers by putting everything into
-  // |inner_|.
+  const scoped_refptr<MessageLoopProxy> constructor_message_loop_;
+
+  // Avoid pulling in too many headers by putting (almost) everything
+  // into |inner_|.
   const scoped_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_