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

components/update_client/update_client_unittest.cc

 // Copyright 2015 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
@@ skipping 119 matching lines @@
 
 using std::string;
 
 class UpdateClientTest : public testing::Test {
  public:
   UpdateClientTest();
   ~UpdateClientTest() override;
 
  protected:
   void RunThreads();
+  void StopWorkerPool();
 
   // Returns the full path to a test file.
   static base::FilePath TestFilePath(const char* file);
 
   scoped_refptr<update_client::Configurator> config() { return config_; }
 
   base::Closure quit_closure() { return quit_closure_; }
 
  private:
   static const int kNumWorkerThreads_ = 2;
@@ skipping 20 matching lines @@
       message_loop_.task_runner());
 }
 
 UpdateClientTest::~UpdateClientTest() {
 }
 
 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);
   return path.AppendASCII("components")
       .AppendASCII("test")
       .AppendASCII("data")
       .AppendASCII("update_client")
       .AppendASCII(file);
 }
 
@@ skipping 85 matching lines @@
   std::vector<std::string> ids;
   ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
 
   update_client->Update(
       ids, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the scenario where two CRXs are checked for updates. On CRX has
 // an update, the other CRX does not.
 TEST_F(UpdateClientTest, TwoCrxUpdateNoUpdate) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
       CrxComponent crx1;
@@ skipping 161 matching lines @@
   ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
   ids.push_back(std::string("abagagagagagagagagagagagagagagag"));
 
   update_client->Update(
       ids, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the update check for two CRXs scenario. Both CRXs have updates.
 TEST_F(UpdateClientTest, TwoCrxUpdate) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
       CrxComponent crx1;
       crx1.name = "test_jebg";
@@ skipping 216 matching lines @@
   ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
   ids.push_back(std::string("ihfokbkgjpifnbbojhneepfflplebdkc"));
 
   update_client->Update(
       ids, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the scenario where there is a download timeout for the first
 // CRX. The update for the first CRX fails. The update client waits before
 // attempting the update for the second CRX. This update succeeds.
 TEST_F(UpdateClientTest, TwoCrxUpdateDownloadTimeout) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
@@ skipping 216 matching lines @@
   ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
   ids.push_back(std::string("ihfokbkgjpifnbbojhneepfflplebdkc"));
 
   update_client->Update(
       ids, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the differential update scenario for one CRX.
 TEST_F(UpdateClientTest, OneCrxDiffUpdate) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
       static int num_calls = 0;
 
@@ skipping 244 matching lines @@
 
   {
     base::RunLoop runloop;
     update_client->Update(
         ids, base::Bind(&DataCallbackFake::Callback),
         base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
     runloop.Run();
   }
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the update scenario for one CRX where the CRX installer returns
 // an error.
 TEST_F(UpdateClientTest, OneCrxInstallError) {
   class MockInstaller : public CrxInstaller {
    public:
     MOCK_METHOD1(OnUpdateError, void(int error));
     MOCK_METHOD2(Install,
                  bool(const base::DictionaryValue& manifest,
@@ skipping 172 matching lines @@
   std::vector<std::string> ids;
   ids.push_back(std::string("jebgalgnebhfojomionfpkfelancnnkf"));
 
   update_client->Update(
       ids, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the fallback from differential to full update scenario for one CRX.
 TEST_F(UpdateClientTest, OneCrxDiffUpdateFailsFullUpdateSucceeds) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
       static int num_calls = 0;
 
@@ skipping 263 matching lines @@
 
   {
     base::RunLoop runloop;
     update_client->Update(
         ids, base::Bind(&DataCallbackFake::Callback),
         base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
     runloop.Run();
   }
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the queuing of update checks. In this scenario, two update checks are
 // done for one CRX. The second update check call is queued up and will run
 // after the first check has completed. The CRX has no updates.
 TEST_F(UpdateClientTest, OneCrxNoUpdateQueuedCall) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
@@ skipping 84 matching lines @@
   update_client->Update(
       ids, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
   update_client->Update(
       ids, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests the install of one CRX.
 TEST_F(UpdateClientTest, OneCrxInstall) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
       CrxComponent crx;
       crx.name = "test_jebg";
@@ skipping 151 matching lines @@
   update_client->AddObserver(&observer);
 
   update_client->Install(
       std::string("jebgalgnebhfojomionfpkfelancnnkf"),
       base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Tests that overlapping installs of the same CRX result in an error.
 TEST_F(UpdateClientTest, ConcurrentInstallSameCRX) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {
       CrxComponent crx;
       crx.name = "test_jebg";
@@ skipping 92 matching lines @@
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   update_client->Install(
       std::string("jebgalgnebhfojomionfpkfelancnnkf"),
       base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
+
+  StopWorkerPool();
 }
 
 // Make sure that we don't get any crashes when trying to update an empty list
 // of ids.
 TEST_F(UpdateClientTest, EmptyIdList) {
   class DataCallbackFake {
    public:
     static void Callback(const std::vector<std::string>& ids,
                          std::vector<CrxComponent>* components) {}
   };
@@ skipping 38 matching lines @@
   scoped_refptr<UpdateClient> update_client(new UpdateClientImpl(
       config(), make_scoped_ptr(new FakePingManagerImpl(*config())),
       &FakeUpdateChecker::Create, &FakeCrxDownloader::Create));
 
   std::vector<std::string> empty_id_list;
   base::RunLoop runloop;
   update_client->Update(
       empty_id_list, base::Bind(&DataCallbackFake::Callback),
       base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
   runloop.Run();
+
+  StopWorkerPool();
 }
 
 }  // namespace update_client