Eliminate component/update_client dependency on content/

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"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/test/sequenced_worker_pool_owner.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/threading/thread.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "components/update_client/crx_update_item.h"
 #include "components/update_client/ping_manager.h"
 #include "components/update_client/test_configurator.h"
 #include "components/update_client/test_installer.h"
 #include "components/update_client/update_checker.h"
 #include "components/update_client/update_client_internal.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace update_client {
 
 namespace {
 
 using base::FilePath;
 
@@ skipping 61 matching lines @@
 }  // namespace
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::Return;
 
-using content::BrowserThread;
-
 using std::string;
 
 class UpdateClientTest : public testing::Test {
  public:
   UpdateClientTest();
   ~UpdateClientTest() override;
 
-  void SetUp() override;
-  void TearDown() override;
-
  protected:
   void RunThreads();
 
   // Returns the full path to a test file.
   static base::FilePath TestFilePath(const char* file);
 
-  content::TestBrowserThreadBundle thread_bundle_;
+  scoped_refptr<update_client::Configurator> config() { return config_; }
 
+  base::Closure quit_closure() { return quit_closure_; }
+
+ private:
+  static const int kNumWorkerThreads_ = 2;
+
+  base::MessageLoopForUI message_loop_;
   base::RunLoop runloop_;
   base::Closure quit_closure_;
 
-  scoped_refptr<update_client::TestConfigurator> config_;
+  scoped_ptr<base::SequencedWorkerPoolOwner> worker_pool_;
+  scoped_ptr<base::Thread> thread_;
 
- private:
+  scoped_refptr<update_client::Configurator> config_;
+
   DISALLOW_COPY_AND_ASSIGN(UpdateClientTest);
 };
 
 UpdateClientTest::UpdateClientTest()
-    : config_(new TestConfigurator(
-          BrowserThread::GetBlockingPool()
-              ->GetSequencedTaskRunnerWithShutdownBehavior(
-                  BrowserThread::GetBlockingPool()->GetSequenceToken(),
-                  base::SequencedWorkerPool::SKIP_ON_SHUTDOWN),
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO))) {
+    : worker_pool_(
+          new base::SequencedWorkerPoolOwner(kNumWorkerThreads_, "test")),
+      thread_(new base::Thread("test")) {
+  quit_closure_ = runloop_.QuitClosure();
+
+  thread_->Start();
+
+  auto pool = worker_pool_->pool();
+  config_ = new TestConfigurator(
+      pool->GetSequencedTaskRunner(pool->GetSequenceToken()),
+      thread_->task_runner());
 }
 
 UpdateClientTest::~UpdateClientTest() {
-}
-
-void UpdateClientTest::SetUp() {
-  quit_closure_ = runloop_.QuitClosure();
-}
-
-void UpdateClientTest::TearDown() {
+  config_ = nullptr;
+  thread_->Stop();
+  worker_pool_->pool()->Shutdown();
 }
 
 void UpdateClientTest::RunThreads() {
   runloop_.Run();
 }
 
 base::FilePath UpdateClientTest::TestFilePath(const char* file) {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   return path.AppendASCII("components")
@@ skipping 62 matching lines @@
     void DoStartDownload(const GURL& url) override { EXPECT_TRUE(false); }
   };
 
   class FakePingManager : public FakePingManagerImpl {
    public:
     explicit FakePingManager(const Configurator& config)
         : FakePingManagerImpl(config) {}
     ~FakePingManager() override { EXPECT_TRUE(items().empty()); }
   };
 
-  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config_));
+  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config()));
   scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
+      config(), ping_manager.Pass(), &FakeUpdateChecker::Create,
       &FakeCrxDownloader::Create));
 
   MockObserver observer;
   InSequence seq;
   EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
                                 "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
   EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
                                 "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
 
   update_client->AddObserver(&observer);
 
   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_));
+      base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
 }
 
 // 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 {
@@ skipping 126 matching lines @@
       const auto& ping_items = items();
       EXPECT_EQ(1U, ping_items.size());
       EXPECT_EQ("jebgalgnebhfojomionfpkfelancnnkf", ping_items[0].id);
       EXPECT_TRUE(base::Version("0.9").Equals(ping_items[0].previous_version));
       EXPECT_TRUE(base::Version("1.0").Equals(ping_items[0].next_version));
       EXPECT_EQ(0, ping_items[0].error_category);
       EXPECT_EQ(0, ping_items[0].error_code);
     }
   };
 
-  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config_));
+  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config()));
   scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
+      config(), ping_manager.Pass(), &FakeUpdateChecker::Create,
       &FakeCrxDownloader::Create));
 
   MockObserver observer;
   {
     InSequence seq;
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
@@ skipping 12 matching lines @@
   }
 
   update_client->AddObserver(&observer);
 
   std::vector<std::string> ids;
   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_));
+      base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
 }
 
 // Tests the update check for two CRXs scenario. Both CRXs have updates.
 TEST_F(UpdateClientTest, TwoCrxUpdate) {
   class DataCallbackFake {
    public:
@@ skipping 173 matching lines @@
       EXPECT_EQ(0, ping_items[0].error_category);
       EXPECT_EQ(0, ping_items[0].error_code);
       EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[1].id);
       EXPECT_TRUE(base::Version("0.8").Equals(ping_items[1].previous_version));
       EXPECT_TRUE(base::Version("1.0").Equals(ping_items[1].next_version));
       EXPECT_EQ(0, ping_items[1].error_category);
       EXPECT_EQ(0, ping_items[1].error_code);
     }
   };
 
-  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config_));
+  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config()));
   scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
+      config(), ping_manager.Pass(), &FakeUpdateChecker::Create,
       &FakeCrxDownloader::Create));
 
   MockObserver observer;
   {
     InSequence seq;
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
@@ skipping 20 matching lines @@
   }
 
   update_client->AddObserver(&observer);
 
   std::vector<std::string> ids;
   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_));
+      base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
 }
 
 // Tests the differential update scenario for one CRX.
 TEST_F(UpdateClientTest, OneCrxDiffUpdate) {
   class DataCallbackFake {
    public:
@@ skipping 197 matching lines @@
       EXPECT_EQ(0, ping_items[0].error_category);
       EXPECT_EQ(0, ping_items[0].error_code);
       EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[1].id);
       EXPECT_TRUE(base::Version("1.0").Equals(ping_items[1].previous_version));
       EXPECT_TRUE(base::Version("2.0").Equals(ping_items[1].next_version));
       EXPECT_EQ(0, ping_items[1].diff_error_category);
       EXPECT_EQ(0, ping_items[1].diff_error_code);
     }
   };
 
-  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config_));
+  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config()));
   scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
+      config(), ping_manager.Pass(), &FakeUpdateChecker::Create,
       &FakeCrxDownloader::Create));
 
   MockObserver observer;
   {
     InSequence seq;
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
                                   "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
                                   "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
@@ skipping 190 matching lines @@
       const auto& ping_items = items();
       EXPECT_EQ(1U, ping_items.size());
       EXPECT_EQ("jebgalgnebhfojomionfpkfelancnnkf", ping_items[0].id);
       EXPECT_TRUE(base::Version("0.9").Equals(ping_items[0].previous_version));
       EXPECT_TRUE(base::Version("1.0").Equals(ping_items[0].next_version));
       EXPECT_EQ(3, ping_items[0].error_category);  // kInstallError.
       EXPECT_EQ(9, ping_items[0].error_code);      // kInstallerError.
     }
   };
 
-  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config_));
+  scoped_ptr<PingManager> ping_manager(new FakePingManager(*config()));
   scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
+      config(), ping_manager.Pass(), &FakeUpdateChecker::Create,
       &FakeCrxDownloader::Create));
 
   MockObserver observer;
   {
     InSequence seq;
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_READY,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_NOT_UPDATED,
                                   "jebgalgnebhfojomionfpkfelancnnkf")).Times(1);
   }
 
   update_client->AddObserver(&observer);
 
   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_));
+      base::Bind(&CompletionCallbackFake::Callback, quit_closure()));
 
   RunThreads();
 
   update_client->RemoveObserver(&observer);
 }
 
 // Tests the fallback from differential to full update scenario for one CRX.
 TEST_F(UpdateClientTest, OneCrxDiffUpdateFailsFullUpdateSucceeds) {
   class DataCallbackFake {
    public:
@@ skipping 213 matching lines @@
       EXPECT_EQ(0, ping_items[0].error_code);
       EXPECT_EQ("ihfokbkgjpifnbbojhneepfflplebdkc", ping_items[1].id);
       EXPECT_TRUE(base::Version("1.0").Equals(ping_items[1].previous_version));
       EXPECT_TRUE(base::Version("2.0").Equals(ping_items[1].next_version));
       EXPECT_TRUE(ping_items[1].diff_update_failed);
       EXPECT_EQ(1, ping_items[1].diff_error_category);  // kNetworkError.
       EXPECT_EQ(-1, ping_items[1].diff_error_code);
     }
   };
 
-  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config_));
+  scoped_ptr<FakePingManager> ping_manager(new FakePingManager(*config()));
   scoped_ptr<UpdateClient> update_client(new UpdateClientImpl(
-      config_, ping_manager.Pass(), &FakeUpdateChecker::Create,
+      config(), ping_manager.Pass(), &FakeUpdateChecker::Create,
       &FakeCrxDownloader::Create));
 
   MockObserver observer;
   {
     InSequence seq;
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_CHECKING_FOR_UPDATES,
                                   "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_FOUND,
                                   "ihfokbkgjpifnbbojhneepfflplebdkc")).Times(1);
     EXPECT_CALL(observer, OnEvent(Events::COMPONENT_UPDATE_DOWNLOADING,
@@ skipping 35 matching lines @@
     update_client->Update(
         ids, base::Bind(&DataCallbackFake::Callback),
         base::Bind(&CompletionCallbackFake::Callback, runloop.QuitClosure()));
     runloop.Run();
   }
 
   update_client->RemoveObserver(&observer);
 }
 
 }  // namespace update_client