Revert of Tests: Simplify SequencedWorkerPoolOwner, call Shutdown on destructor.

base/threading/sequenced_worker_pool_unittest.cc

Index: base/threading/sequenced_worker_pool_unittest.cc
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index 262c4fbdbfa8a189856afd99d7d43ef0a94fb6be..5812ee75ac5f84df1fc7df48d107b1a1c69d84e8 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -233,6 +233,8 @@
       : tracker_(new TestTracker) {
     ResetPool();
   }
+
+  void TearDown() override { pool()->Shutdown(); }
 
   const scoped_refptr<SequencedWorkerPool>& pool() {
     return pool_owner_->pool();
@@ -349,6 +351,7 @@
   ASSERT_EQ(1u, completion_sequence.size());
   ASSERT_EQ(1, completion_sequence[0]);
 
+  pool()->Shutdown();
   // Shutdown is asynchronous, so use ResetPool() to block until the pool is
   // fully destroyed (and thus shut down).
   ResetPool();
@@ -427,6 +430,9 @@
   std::vector<int> result =
       tracker()->WaitUntilTasksComplete(2*kNumTasks);
   EXPECT_EQ(2 * kNumTasks, result.size());
+
+  pool2.pool()->Shutdown();
+  pool1.pool()->Shutdown();
 }
 
 // Test that tasks with the same sequence token are executed in order but don't
@@ -793,30 +799,33 @@
   SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
   SequencedWorkerPool::SequenceToken unsequenced_token;
 
-  SequencedWorkerPoolOwner unused_pool_owner(2, "unused_pool");
+  scoped_refptr<SequencedWorkerPool> unused_pool =
+      new SequencedWorkerPool(2, "unused_pool");
 
   EXPECT_FALSE(pool()->RunsTasksOnCurrentThread());
   EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token1));
   EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(token2));
   EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(unsequenced_token));
-  EXPECT_FALSE(unused_pool_owner.pool()->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(unused_pool->IsRunningSequenceOnCurrentThread(token1));
+  EXPECT_FALSE(unused_pool->IsRunningSequenceOnCurrentThread(token2));
   EXPECT_FALSE(
-      unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token1));
-  EXPECT_FALSE(
-      unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token2));
-  EXPECT_FALSE(unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(
-      unsequenced_token));
+      unused_pool->IsRunningSequenceOnCurrentThread(unsequenced_token));
 
   pool()->PostSequencedWorkerTask(
-      token1, FROM_HERE, base::Bind(&IsRunningOnCurrentThreadTask, token1,
-                                    token2, pool(), unused_pool_owner.pool()));
+      token1, FROM_HERE,
+      base::Bind(&IsRunningOnCurrentThreadTask,
+                 token1, token2, pool(), unused_pool));
   pool()->PostSequencedWorkerTask(
       token2, FROM_HERE,
-      base::Bind(&IsRunningOnCurrentThreadTask, token2, unsequenced_token,
-                 pool(), unused_pool_owner.pool()));
+      base::Bind(&IsRunningOnCurrentThreadTask,
+                 token2, unsequenced_token, pool(), unused_pool));
   pool()->PostWorkerTask(
-      FROM_HERE, base::Bind(&IsRunningOnCurrentThreadTask, unsequenced_token,
-                            token1, pool(), unused_pool_owner.pool()));
+      FROM_HERE,
+      base::Bind(&IsRunningOnCurrentThreadTask,
+                 unsequenced_token, token1, pool(), unused_pool));
+  pool()->Shutdown();
+  unused_pool->Shutdown();
 }
 
 // Checks that tasks are destroyed in the right context during shutdown. If a
@@ -938,14 +947,16 @@
   pool()->FlushForTesting();
 }
 
-TEST_F(SequencedWorkerPoolTest, ShutsDownCleanWithContinueOnShutdown) {
+TEST(SequencedWorkerPoolRefPtrTest, ShutsDownCleanWithContinueOnShutdown) {
+  MessageLoop loop;
+  scoped_refptr<SequencedWorkerPool> pool(new SequencedWorkerPool(3, "Pool"));
   scoped_refptr<SequencedTaskRunner> task_runner =
-      pool()->GetSequencedTaskRunnerWithShutdownBehavior(
-          pool()->GetSequenceToken(),
+      pool->GetSequencedTaskRunnerWithShutdownBehavior(
+          pool->GetSequenceToken(),
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
   // Upon test exit, should shut down without hanging.
-  pool()->Shutdown();
+  pool->Shutdown();
 }
 
 class SequencedWorkerPoolTaskRunnerTestDelegate {