Revert of Tests: Simplify SequencedWorkerPoolOwner, call Shutdown on destructor. (patchset #4 id:60001 of https://codereview.chromium.org/1417353006/ )

Reason for revert:
Suspected for persistent failures on ios_net_unittests

- RoundTripTestCookieStore/CookieStoreTest/0.TestNonDottedAndTLD
- CookieStoreIOS/CookieStoreTest/0.TestNonDottedAndTLD

Failing since https://build.chromium.org/p/chromium.mac/builders/iOS_Simulator_%28dbg%29/builds/32876

Errors like

../../net/cookies/cookie_store_unittest.h:536: Failure
Value of: this->SetCookie(cs.get(), url, "a=1; domain=com")
  Actual: false
Expected: true

(It's a tricky one! Sorry if this is not it)

Original issue's description:
> Tests: Simplify SequencedWorkerPoolOwner, call Shutdown on destructor.
>
> Also ports remaining tests using raw SWPs to use SWPOwner.
>
> BUG=450228
>
> Committed: https://crrev.com/fc939726c283e34112d9bc845a39460410fe9cd9
> Cr-Commit-Position: refs/heads/master@{#362805}

TBR=phajdan.jr@chromium.org,jam@chromium.org,brettw@chromium.org,tommycli@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=450228

Review URL: https://codereview.chromium.org/1496493004

Cr-Commit-Position: refs/heads/master@{#362890}

1 files changed, 28 insertions, 17 deletions

diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index 262c4fb..5812ee7 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -234,6 +234,8 @@ class SequencedWorkerPoolTest : public testing::Test {
     ResetPool();
   }
 
+  void TearDown() override { pool()->Shutdown(); }
+
   const scoped_refptr<SequencedWorkerPool>& pool() {
     return pool_owner_->pool();
   }
@@ -349,6 +351,7 @@ TEST_F(SequencedWorkerPoolTest, DelayedTaskDuringShutdown) {
   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 @@ TEST_F(SequencedWorkerPoolTest, LotsOfTasksTwoPools) {
   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 @@ TEST_F(SequencedWorkerPoolTest, IsRunningOnCurrentThread) {
   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_owner.pool()->IsRunningSequenceOnCurrentThread(token1));
+  EXPECT_FALSE(unused_pool->RunsTasksOnCurrentThread());
+  EXPECT_FALSE(unused_pool->IsRunningSequenceOnCurrentThread(token1));
+  EXPECT_FALSE(unused_pool->IsRunningSequenceOnCurrentThread(token2));
   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 @@ TEST_F(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) {
   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 {