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}

21 files changed, 138 insertions, 68 deletions

diff --git a/base/sequence_checker_unittest.cc b/base/sequence_checker_unittest.cc
index d721cbf..f0eda25 100644
--- a/base/sequence_checker_unittest.cc
+++ b/base/sequence_checker_unittest.cc
@@ -66,6 +66,7 @@ class SequenceCheckerTest : public testing::Test {
 
   void TearDown() override {
     other_thread_.Stop();
+    pool()->Shutdown();
   }
 
  protected:
@@ -308,6 +309,7 @@ void SequenceCheckerTest::TwoDifferentWorkerPoolsDeathTest() {
       base::Bind(&SequenceCheckedObject::DoStuff,
                  base::Unretained(sequence_checked_object.get())));
   second_pool_owner.pool()->FlushForTesting();
+  second_pool_owner.pool()->Shutdown();
 }
 
 #if ENABLE_SEQUENCE_CHECKER
diff --git a/base/test/launcher/test_launcher.cc b/base/test/launcher/test_launcher.cc
index dd13c4a..b1a1a89c 100644
--- a/base/test/launcher/test_launcher.cc
+++ b/base/test/launcher/test_launcher.cc
@@ -468,7 +468,10 @@ TestLauncher::TestLauncher(TestLauncherDelegate* launcher_delegate,
       parallel_jobs_(parallel_jobs) {
 }
 
-TestLauncher::~TestLauncher() {}
+TestLauncher::~TestLauncher() {
+  if (worker_pool_owner_)
+    worker_pool_owner_->pool()->Shutdown();
+}
 
 bool TestLauncher::Run() {
   if (!Init())
diff --git a/base/test/sequenced_worker_pool_owner.cc b/base/test/sequenced_worker_pool_owner.cc
index 37bad2b..b0d8b7a 100644
--- a/base/test/sequenced_worker_pool_owner.cc
+++ b/base/test/sequenced_worker_pool_owner.cc
@@ -18,11 +18,8 @@ SequencedWorkerPoolOwner::SequencedWorkerPoolOwner(
       has_work_call_count_(0) {}
 
 SequencedWorkerPoolOwner::~SequencedWorkerPoolOwner() {
-  pool_->Shutdown();
   pool_ = NULL;
-
-  // Spin the current message loop until SWP destruction verified in OnDestruct.
-  exit_loop_.Run();
+  MessageLoop::current()->Run();
 }
 
 const scoped_refptr<SequencedWorkerPool>& SequencedWorkerPoolOwner::pool() {
@@ -54,7 +51,8 @@ void SequencedWorkerPoolOwner::WillWaitForShutdown() {
 }
 
 void SequencedWorkerPoolOwner::OnDestruct() {
-  constructor_message_loop_->PostTask(FROM_HERE, exit_loop_.QuitClosure());
+  constructor_message_loop_->task_runner()->PostTask(
+      FROM_HERE, constructor_message_loop_->QuitWhenIdleClosure());
 }
 
 }  // namespace base
diff --git a/base/test/sequenced_worker_pool_owner.h b/base/test/sequenced_worker_pool_owner.h
index 20bffb1..bf5f2f7 100644
--- a/base/test/sequenced_worker_pool_owner.h
+++ b/base/test/sequenced_worker_pool_owner.h
@@ -12,7 +12,6 @@
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_worker_pool.h"
 
@@ -26,9 +25,6 @@ class MessageLoop;
 // strange races with other tests that touch global stuff (like histograms and
 // logging).  However, this requires that nothing else on this thread holds a
 // ref to the pool when the SequencedWorkerPoolOwner is destroyed.
-//
-// This class calls Shutdown on the owned SequencedWorkerPool in the destructor.
-// Tests may themselves call Shutdown earlier to test shutdown behavior.
 class SequencedWorkerPoolOwner : public SequencedWorkerPool::TestingObserver {
  public:
   SequencedWorkerPoolOwner(size_t max_threads,
@@ -50,11 +46,7 @@ class SequencedWorkerPoolOwner : public SequencedWorkerPool::TestingObserver {
   void WillWaitForShutdown() override;
   void OnDestruct() override;
 
-  // Used to run the current thread's message loop until the
-  // SequencedWorkerPool's destruction has been verified.
-  base::RunLoop exit_loop_;
   MessageLoop* const constructor_message_loop_;
-
   scoped_refptr<SequencedWorkerPool> pool_;
   Closure will_wait_for_shutdown_callback_;
 
diff --git a/base/threading/sequenced_task_runner_handle_unittest.cc b/base/threading/sequenced_task_runner_handle_unittest.cc
index bd380ef..1080262 100644
--- a/base/threading/sequenced_task_runner_handle_unittest.cc
+++ b/base/threading/sequenced_task_runner_handle_unittest.cc
@@ -61,6 +61,7 @@ TEST_F(SequencedTaskRunnerHandleTest, FromSequencedWorkerPool) {
       base::Bind(&SequencedTaskRunnerHandleTest::GetTaskRunner,
                  base::Bind(&WaitableEvent::Signal, base::Unretained(&event))));
   event.Wait();
+  owner.pool()->Shutdown();
 }
 
 class ThreadRunner : public DelegateSimpleThread::Delegate {
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 {
diff --git a/chrome/browser/chromeos/extensions/external_cache_unittest.cc b/chrome/browser/chromeos/extensions/external_cache_unittest.cc
index c0e036c..58f5268 100644
--- a/chrome/browser/chromeos/extensions/external_cache_unittest.cc
+++ b/chrome/browser/chromeos/extensions/external_cache_unittest.cc
@@ -70,6 +70,11 @@ class ExternalCacheTest : public testing::Test,
         pool_owner_->pool()->GetNamedSequenceToken("background"));
   }
 
+  void TearDown() override {
+    pool_owner_->pool()->Shutdown();
+    base::RunLoop().RunUntilIdle();
+  }
+
   // ExternalCache::Delegate:
   void OnExtensionListsUpdated(const base::DictionaryValue* prefs) override {
     prefs_.reset(prefs->DeepCopy());
diff --git a/chrome/browser/extensions/updater/local_extension_cache_unittest.cc b/chrome/browser/extensions/updater/local_extension_cache_unittest.cc
index 6dcda93..3fe8a2b 100644
--- a/chrome/browser/extensions/updater/local_extension_cache_unittest.cc
+++ b/chrome/browser/extensions/updater/local_extension_cache_unittest.cc
@@ -48,6 +48,11 @@ class LocalExtensionCacheTest : public testing::Test {
         pool_owner_->pool()->GetNamedSequenceToken("background"));
   }
 
+  void TearDown() override {
+    pool_owner_->pool()->Shutdown();
+    base::RunLoop().RunUntilIdle();
+  }
+
   base::FilePath CreateCacheDir(bool initialized) {
     EXPECT_TRUE(cache_dir_.CreateUniqueTempDir());
     if (initialized)
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc
index c2cd8ca..13cc2c1 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc
@@ -7,7 +7,6 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
-#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/drive_backend/callback_helper.h"
 #include "chrome/browser/sync_file_system/drive_backend/fake_sync_worker.h"
@@ -29,7 +28,7 @@ class SyncEngineTest : public testing::Test,
  public:
   typedef RemoteFileSyncService::OriginStatusMap RemoteOriginStatusMap;
 
-  SyncEngineTest() : worker_pool_owner_(1, "Worker") {}
+  SyncEngineTest() {}
   ~SyncEngineTest() override {}
 
   void SetUp() override {
@@ -38,25 +37,28 @@ class SyncEngineTest : public testing::Test,
     scoped_ptr<drive::DriveServiceInterface>
         fake_drive_service(new drive::FakeDriveService);
 
+    worker_pool_ = new base::SequencedWorkerPool(1, "Worker");
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
         base::ThreadTaskRunnerHandle::Get();
     worker_task_runner_ =
-        worker_pool_owner_.pool()->GetSequencedTaskRunnerWithShutdownBehavior(
-            worker_pool_owner_.pool()->GetSequenceToken(),
+        worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
+            worker_pool_->GetSequenceToken(),
             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
     sync_engine_.reset(new drive_backend::SyncEngine(
-        ui_task_runner.get(), worker_task_runner_.get(),
-        nullptr,  // drive_task_runner
-        worker_pool_owner_.pool().get(), profile_dir_.path(),
-        nullptr,    // task_logger
-        nullptr,    // notification_manager
-        nullptr,    // extension_service
-        nullptr,    // signin_manager
-        nullptr,    // token_service
-        nullptr,    // request_context
-        nullptr,    // drive_service_factory
-        nullptr));  // in_memory_env
+        ui_task_runner.get(),
+        worker_task_runner_.get(),
+        nullptr /* drive_task_runner */,
+        worker_pool_.get(),
+        profile_dir_.path(),
+        nullptr /* task_logger */,
+        nullptr /* notification_manager */,
+        nullptr /* extension_service */,
+        nullptr /* signin_manager */,
+        nullptr /* token_service */,
+        nullptr /* request_context */,
+        nullptr /* drive_service_factory */,
+        nullptr /* in_memory_env */));
 
     sync_engine_->InitializeForTesting(
         fake_drive_service.Pass(),
@@ -71,8 +73,12 @@ class SyncEngineTest : public testing::Test,
   void TearDown() override {
     sync_engine_.reset();
     WaitForWorkerTaskRunner();
+    worker_pool_->Shutdown();
 
     worker_task_runner_ = nullptr;
+    worker_pool_ = nullptr;
+
+    base::RunLoop().RunUntilIdle();
   }
 
   bool FindOriginStatus(const GURL& origin, std::string* status) {
@@ -125,7 +131,7 @@ class SyncEngineTest : public testing::Test,
   base::ScopedTempDir profile_dir_;
   scoped_ptr<drive_backend::SyncEngine> sync_engine_;
 
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
+  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncEngineTest);
diff --git a/chrome/browser/ui/app_list/search/history_unittest.cc b/chrome/browser/ui/app_list/search/history_unittest.cc
index 41578f1..d5365e6 100644
--- a/chrome/browser/ui/app_list/search/history_unittest.cc
+++ b/chrome/browser/ui/app_list/search/history_unittest.cc
@@ -99,6 +99,7 @@ class SearchHistoryTest : public testing::Test {
   }
   void TearDown() override {
     Flush();
+    worker_pool_owner_->pool()->Shutdown();
   }
 
   void CreateHistory() {
diff --git a/components/autofill/core/browser/test_autofill_driver.cc b/components/autofill/core/browser/test_autofill_driver.cc
index 38a83ed..3eaacd5 100644
--- a/components/autofill/core/browser/test_autofill_driver.cc
+++ b/components/autofill/core/browser/test_autofill_driver.cc
@@ -14,7 +14,9 @@ TestAutofillDriver::TestAutofillDriver()
           new base::SequencedWorkerPoolOwner(4, "TestAutofillDriver")),
       url_request_context_(NULL) {}
 
-TestAutofillDriver::~TestAutofillDriver() {}
+TestAutofillDriver::~TestAutofillDriver() {
+  blocking_pool_owner_->pool()->Shutdown();
+}
 
 bool TestAutofillDriver::IsOffTheRecord() const {
   return false;
diff --git a/components/component_updater/component_updater_service_unittest.cc b/components/component_updater/component_updater_service_unittest.cc
index a5a839d..9d78eb8 100644
--- a/components/component_updater/component_updater_service_unittest.cc
+++ b/components/component_updater/component_updater_service_unittest.cc
@@ -174,6 +174,7 @@ ComponentUpdaterTest::ComponentUpdaterTest()
 
 ComponentUpdaterTest::~ComponentUpdaterTest() {
   EXPECT_CALL(update_client(), RemoveObserver(_)).Times(1);
+  worker_pool_->pool()->Shutdown();
   component_updater_.reset();
 }
 
diff --git a/components/rlz/rlz_tracker_unittest.cc b/components/rlz/rlz_tracker_unittest.cc
index ba505ee..eb33d89 100644
--- a/components/rlz/rlz_tracker_unittest.cc
+++ b/components/rlz/rlz_tracker_unittest.cc
@@ -8,8 +8,8 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "components/rlz/rlz_tracker_delegate.h"
 #include "net/url_request/url_request_test_util.h"
@@ -30,10 +30,12 @@ namespace {
 class TestRLZTrackerDelegate : public RLZTrackerDelegate {
  public:
   TestRLZTrackerDelegate()
-      : worker_pool_owner_(1, "TestRLZTracker"),
+      : worker_pool_(new base::SequencedWorkerPool(1, "TestRLZTracker")),
         request_context_getter_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())) {}
 
+  ~TestRLZTrackerDelegate() override { worker_pool_->Shutdown(); }
+
   void set_brand(const char* brand) { brand_override_ = brand; }
 
   void set_reactivation_brand(const char* reactivation_brand) {
@@ -66,7 +68,7 @@ class TestRLZTrackerDelegate : public RLZTrackerDelegate {
   bool IsOnUIThread() override { return true; }
 
   base::SequencedWorkerPool* GetBlockingPool() override {
-    return worker_pool_owner_.pool().get();
+    return worker_pool_.get();
   }
 
   net::URLRequestContextGetter* GetRequestContext() override {
@@ -106,7 +108,7 @@ class TestRLZTrackerDelegate : public RLZTrackerDelegate {
   }
 
  private:
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
+  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   std::string brand_override_;
diff --git a/components/update_client/update_client_unittest.cc b/components/update_client/update_client_unittest.cc
index d8ad6df..c5bccb0 100644
--- a/components/update_client/update_client_unittest.cc
+++ b/components/update_client/update_client_unittest.cc
@@ -137,6 +137,7 @@ class UpdateClientTest : public testing::Test {
 
  protected:
   void RunThreads();
+  void StopWorkerPool();
 
   // Returns the full path to a test file.
   static base::FilePath TestFilePath(const char* file);
@@ -177,6 +178,10 @@ void UpdateClientTest::RunThreads() {
   runloop_.Run();
 }
 
+void UpdateClientTest::StopWorkerPool() {
+  worker_pool_->pool()->Shutdown();
+}
+
 base::FilePath UpdateClientTest::TestFilePath(const char* file) {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
@@ -282,6 +287,8 @@ TEST_F(UpdateClientTest, OneCrxNoUpdate) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the scenario where two CRXs are checked for updates. On CRX has
@@ -463,6 +470,8 @@ TEST_F(UpdateClientTest, TwoCrxUpdateNoUpdate) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the update check for two CRXs scenario. Both CRXs have updates.
@@ -699,6 +708,8 @@ TEST_F(UpdateClientTest, TwoCrxUpdate) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the scenario where there is a download timeout for the first
@@ -935,6 +946,8 @@ TEST_F(UpdateClientTest, TwoCrxUpdateDownloadTimeout) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the differential update scenario for one CRX.
@@ -1199,6 +1212,8 @@ TEST_F(UpdateClientTest, OneCrxDiffUpdate) {
   }
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the update scenario for one CRX where the CRX installer returns
@@ -1391,6 +1406,8 @@ TEST_F(UpdateClientTest, OneCrxInstallError) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the fallback from differential to full update scenario for one CRX.
@@ -1674,6 +1691,8 @@ TEST_F(UpdateClientTest, OneCrxDiffUpdateFailsFullUpdateSucceeds) {
   }
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the queuing of update checks. In this scenario, two update checks are
@@ -1778,6 +1797,8 @@ TEST_F(UpdateClientTest, OneCrxNoUpdateQueuedCall) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the install of one CRX.
@@ -1949,6 +1970,8 @@ TEST_F(UpdateClientTest, OneCrxInstall) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests that overlapping installs of the same CRX result in an error.
@@ -2061,6 +2084,8 @@ TEST_F(UpdateClientTest, ConcurrentInstallSameCRX) {
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Make sure that we don't get any crashes when trying to update an empty list
@@ -2119,6 +2144,8 @@ TEST_F(UpdateClientTest, EmptyIdList) {
       empty_id_list, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
   runloop.Run();
+
+  StopWorkerPool();
 }
 
 }  // namespace update_client
diff --git a/content/browser/media/webrtc_identity_store_unittest.cc b/content/browser/media/webrtc_identity_store_unittest.cc
index 025e2f3..b97808d 100644
--- a/content/browser/media/webrtc_identity_store_unittest.cc
+++ b/content/browser/media/webrtc_identity_store_unittest.cc
@@ -49,6 +49,8 @@ class WebRtcIdentityStoreTest : public testing::Test {
     webrtc_identity_store_->SetTaskRunnerForTesting(pool_owner_->pool());
   }
 
+  ~WebRtcIdentityStoreTest() override { pool_owner_->pool()->Shutdown(); }
+
   void SetValidityPeriod(base::TimeDelta validity_period) {
     webrtc_identity_store_->SetValidityPeriodForTesting(validity_period);
   }
diff --git a/content/browser/net/quota_policy_cookie_store_unittest.cc b/content/browser/net/quota_policy_cookie_store_unittest.cc
index ca33d6e..f7987c5 100644
--- a/content/browser/net/quota_policy_cookie_store_unittest.cc
+++ b/content/browser/net/quota_policy_cookie_store_unittest.cc
@@ -109,6 +109,7 @@ class QuotaPolicyCookieStoreTest : public testing::Test {
     // tasks that block pool shutdown (e.g. |store_|'s cleanup) have run before
     // yielding control.
     pool_owner_->pool()->FlushForTesting();
+    pool_owner_->pool()->Shutdown();
     pool_owner_.reset(new base::SequencedWorkerPoolOwner(3, "Background Pool"));
   }
 
@@ -118,6 +119,7 @@ class QuotaPolicyCookieStoreTest : public testing::Test {
 
   void TearDown() override {
     DestroyStore();
+    pool_owner_->pool()->Shutdown();
   }
 
   TestBrowserThreadBundle bundle_;
diff --git a/net/base/file_stream_unittest.cc b/net/base/file_stream_unittest.cc
index a36e5ce..b83cc18 100644
--- a/net/base/file_stream_unittest.cc
+++ b/net/base/file_stream_unittest.cc
@@ -13,9 +13,9 @@
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ -714,10 +714,11 @@ TEST_F(FileStreamTest, WriteClose) {
 }
 
 TEST_F(FileStreamTest, OpenAndDelete) {
-  base::SequencedWorkerPoolOwner pool_owner(1, "StreamTest");
+  scoped_refptr<base::SequencedWorkerPool> pool(
+      new base::SequencedWorkerPool(1, "StreamTest"));
 
   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
-  scoped_ptr<FileStream> stream(new FileStream(pool_owner.pool()));
+  scoped_ptr<FileStream> stream(new FileStream(pool.get()));
   int flags = base::File::FLAG_OPEN | base::File::FLAG_WRITE |
               base::File::FLAG_ASYNC;
   TestCompletionCallback open_callback;
@@ -729,12 +730,14 @@ TEST_F(FileStreamTest, OpenAndDelete) {
   stream.reset();
 
   // Force an operation through the pool.
-  scoped_ptr<FileStream> stream2(new FileStream(pool_owner.pool()));
+  scoped_ptr<FileStream> stream2(new FileStream(pool.get()));
   TestCompletionCallback open_callback2;
   rv = stream2->Open(temp_file_path(), flags, open_callback2.callback());
   EXPECT_EQ(OK, open_callback2.GetResult(rv));
   stream2.reset();
 
+  pool->Shutdown();
+
   // open_callback won't be called.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(open_callback.have_result());
diff --git a/net/extras/sqlite/sqlite_persistent_cookie_store_perftest.cc b/net/extras/sqlite/sqlite_persistent_cookie_store_perftest.cc
index 4be580b..b149ac0 100644
--- a/net/extras/sqlite/sqlite_persistent_cookie_store_perftest.cc
+++ b/net/extras/sqlite/sqlite_persistent_cookie_store_perftest.cc
@@ -99,6 +99,7 @@ class SQLitePersistentCookieStorePerfTest : public testing::Test {
 
   void TearDown() override {
     store_ = NULL;
+    pool_owner_->pool()->Shutdown();
   }
 
  protected:
diff --git a/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc b/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc
index 92965ee..fd140ea 100644
--- a/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc
+++ b/net/extras/sqlite/sqlite_persistent_cookie_store_unittest.cc
@@ -196,6 +196,7 @@ class SQLitePersistentCookieStoreTest : public testing::Test {
 
   void TearDown() override {
     DestroyStore();
+    pool_owner_->pool()->Shutdown();
   }
 
  protected:
diff --git a/net/url_request/url_request_simple_job_unittest.cc b/net/url_request/url_request_simple_job_unittest.cc
index 08c08fb..1286977 100644
--- a/net/url_request/url_request_simple_job_unittest.cc
+++ b/net/url_request/url_request_simple_job_unittest.cc
@@ -6,7 +6,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
-#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request_job.h"
@@ -114,12 +114,11 @@ class SimpleJobProtocolHandler :
 class URLRequestSimpleJobTest : public ::testing::Test {
  public:
   URLRequestSimpleJobTest()
-      : worker_pool_owner_(1, "URLRequestSimpleJobTest"),
-        task_runner_(worker_pool_owner_.pool()
-                         ->GetSequencedTaskRunnerWithShutdownBehavior(
-                             worker_pool_owner_.pool()
-                                 ->GetSequenceToken(),
-                             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
+      : worker_pool_(
+            new base::SequencedWorkerPool(1, "URLRequestSimpleJobTest")),
+        task_runner_(worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
+            worker_pool_->GetSequenceToken(),
+            base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
         context_(true) {
     job_factory_.SetProtocolHandler(
         "data", make_scoped_ptr(new SimpleJobProtocolHandler(task_runner_)));
@@ -130,6 +129,8 @@ class URLRequestSimpleJobTest : public ::testing::Test {
         context_.CreateRequest(GURL("data:test"), DEFAULT_PRIORITY, &delegate_);
   }
 
+  ~URLRequestSimpleJobTest() override { worker_pool_->Shutdown(); }
+
   void StartRequest(const HttpRequestHeaders* headers) {
     if (headers)
       request_->SetExtraRequestHeaders(*headers);
@@ -140,8 +141,10 @@ class URLRequestSimpleJobTest : public ::testing::Test {
     EXPECT_FALSE(request_->is_pending());
   }
 
+  void TearDown() override { worker_pool_->Shutdown(); }
+
  protected:
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
+  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   TestURLRequestContext context_;
   URLRequestJobFactoryImpl job_factory_;
diff --git a/ui/app_list/search/history_data_store_unittest.cc b/ui/app_list/search/history_data_store_unittest.cc
index 6af4dc0..26890f4 100644
--- a/ui/app_list/search/history_data_store_unittest.cc
+++ b/ui/app_list/search/history_data_store_unittest.cc
@@ -9,7 +9,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/search/dictionary_data_store.h"
 #include "ui/app_list/search/history_data.h"
@@ -41,10 +41,12 @@ std::string GetDataContent(const HistoryData::Data& data) {
 
 class HistoryDataStoreTest : public testing::Test {
  public:
-  HistoryDataStoreTest() : worker_pool_owner_(1, "AppLanucherTest") {}
+  HistoryDataStoreTest() {}
+  ~HistoryDataStoreTest() override {}
 
   // testing::Test overrides:
   void SetUp() override {
+    worker_pool_ = new base::SequencedWorkerPool(1, "AppLauncherTest");
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
   void TearDown() override {
@@ -55,7 +57,7 @@ class HistoryDataStoreTest : public testing::Test {
   void OpenStore(const std::string& file_name) {
     data_file_ = temp_dir_.path().AppendASCII(file_name);
     store_ = new HistoryDataStore(scoped_refptr<DictionaryDataStore>(
-        new DictionaryDataStore(data_file_, worker_pool_owner_.pool().get())));
+        new DictionaryDataStore(data_file_, worker_pool_.get())));
     Load();
   }
 
@@ -93,7 +95,7 @@ class HistoryDataStoreTest : public testing::Test {
   base::ScopedTempDir temp_dir_;
   base::FilePath data_file_;
   scoped_ptr<base::RunLoop> run_loop_;
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
+  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
 
   scoped_refptr<HistoryDataStore> store_;
   HistoryData::Associations associations_;