Remove dependency on content::BrowserThread from GCMDriver

chrome/browser/services/gcm/gcm_driver_unittest.cc

 // Copyright 2014 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 "chrome/browser/services/gcm/gcm_driver.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/threading/thread.h"
 #include "chrome/browser/services/gcm/fake_gcm_client.h"
 #include "chrome/browser/services/gcm/fake_gcm_client_factory.h"
 #include "chrome/browser/services/gcm/gcm_app_handler.h"
 #include "components/gcm_driver/gcm_client_factory.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/fake_identity_provider.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
 const char kTestAccountID1[] = "user1@example.com";
 const char kTestAccountID2[] = "user2@example.com";
 const char kTestAppID1[] = "TestApp1";
 const char kTestAppID2[] = "TestApp2";
 const char kUserID1[] = "user1";
 
 void PumpCurrentLoop() {
   base::MessageLoop::ScopedNestableTaskAllower
       nestable_task_allower(base::MessageLoop::current());
   base::RunLoop().RunUntilIdle();
 }
 
 void PumpUILoop() {
   PumpCurrentLoop();
 }
 
-void PumpIOLoop() {
-  base::RunLoop run_loop;
-  content::BrowserThread::PostTaskAndReply(content::BrowserThread::IO,
-                                           FROM_HERE,
-                                           base::Bind(&PumpCurrentLoop),
-                                           run_loop.QuitClosure());
-  run_loop.Run();
-}
-
 std::vector<std::string> ToSenderList(const std::string& sender_ids) {
   std::vector<std::string> senders;
   Tokenize(sender_ids, ",", &senders);
   return senders;
 }
 
 class FakeGCMAppHandler : public GCMAppHandler {
  public:
   enum Event {
     NO_EVENT,
@@ skipping 106 matching lines @@
   GCMDriver* driver() { return driver_.get(); }
   FakeGCMAppHandler* gcm_app_handler() { return gcm_app_handler_.get(); }
   const std::string& registration_id() const { return registration_id_; }
   GCMClient::Result registration_result() const { return registration_result_; }
   const std::string& send_message_id() const { return send_message_id_; }
   GCMClient::Result send_result() const { return send_result_; }
   GCMClient::Result unregistration_result() const {
     return unregistration_result_;
   }
 
+  void PumpIOLoop();
+
   void ClearResults();
 
   bool HasAppHandlers() const;
   FakeGCMClient* GetGCMClient();
 
   void CreateDriver(FakeGCMClient::StartMode gcm_client_start_mode);
 
   void SignIn(const std::string& account_id);
   void SignOut();
 
   void Register(const std::string& app_id,
                 const std::vector<std::string>& sender_ids,
                 WaitToFinish wait_to_finish);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message,
             WaitToFinish wait_to_finish);
   void Unregister(const std::string& app_id, WaitToFinish wait_to_finish);
 
   void WaitForAsyncOperation();
 
  private:
   void RegisterCompleted(const std::string& registration_id,
                          GCMClient::Result result);
   void SendCompleted(const std::string& message_id, GCMClient::Result result);
   void UnregisterCompleted(GCMClient::Result result);
 
-  scoped_ptr<content::TestBrowserThreadBundle> thread_bundle_;
   base::ScopedTempDir temp_dir_;
   FakeOAuth2TokenService token_service_;
   scoped_ptr<FakeIdentityProvider> identity_provider_owner_;
   FakeIdentityProvider* identity_provider_;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  base::MessageLoopForUI message_loop_;
+  base::Thread io_thread_;

[Nicolas Zea, 2014/05/21 23:43:29]

Could you just have one task runner that you use for everything? I don't think
you need a real thread here

[jianli, 2014/05/22 00:11:29]

Yes, we can do that but I am afraid that we're not able to catch those DCHECK
failures to validate the correct calling thread.

[Nicolas Zea, 2014/05/22 17:00:42]

I'm skeptical about the value of the DCHECK's, and generally in favor of just
keeping the test and code simple. That said, it's your call here.

   scoped_ptr<GCMDriver> driver_;
   scoped_ptr<FakeGCMAppHandler> gcm_app_handler_;
 
   base::Closure async_operation_completed_callback_;
 
   std::string registration_id_;
   GCMClient::Result registration_result_;
   std::string send_message_id_;
   GCMClient::Result send_result_;
   GCMClient::Result unregistration_result_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMDriverTest);
 };
 
 GCMDriverTest::GCMDriverTest()
     : identity_provider_(NULL),
+      task_runner_(new base::TestSimpleTaskRunner()),
+      io_thread_("IOThread"),
       registration_result_(GCMClient::UNKNOWN_ERROR),
       send_result_(GCMClient::UNKNOWN_ERROR),
       unregistration_result_(GCMClient::UNKNOWN_ERROR) {
   identity_provider_owner_.reset(new FakeIdentityProvider(&token_service_));
   identity_provider_ = identity_provider_owner_.get();
 }
 
 GCMDriverTest::~GCMDriverTest() {
 }
 
 void GCMDriverTest::SetUp() {
-  thread_bundle_.reset(new content::TestBrowserThreadBundle(
-      content::TestBrowserThreadBundle::REAL_IO_THREAD));
+  io_thread_.Start();
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 }
 
 void GCMDriverTest::TearDown() {
   if (!driver_)
     return;
 
   driver_->Shutdown();
   driver_.reset();
   PumpIOLoop();
+
+  io_thread_.Stop();
+}
+
+void GCMDriverTest::PumpIOLoop() {
+  base::RunLoop run_loop;
+  io_thread_.message_loop_proxy()->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&PumpCurrentLoop),
+      run_loop.QuitClosure());
+  run_loop.Run();
 }
 
 void GCMDriverTest::ClearResults() {
   registration_id_.clear();
   registration_result_ = GCMClient::UNKNOWN_ERROR;
 
   send_message_id_.clear();
   send_result_ = GCMClient::UNKNOWN_ERROR;
 
   unregistration_result_ = GCMClient::UNKNOWN_ERROR;
 }
 
 bool GCMDriverTest::HasAppHandlers() const {
   return !driver_->app_handlers().empty();
 }
 
 FakeGCMClient* GCMDriverTest::GetGCMClient() {
   return static_cast<FakeGCMClient*>(driver_->GetGCMClientForTesting());
 }
 
 void GCMDriverTest::CreateDriver(
     FakeGCMClient::StartMode gcm_client_start_mode) {
   scoped_refptr<net::URLRequestContextGetter> request_context =
-      new net::TestURLRequestContextGetter(
-          content::BrowserThread::GetMessageLoopProxyForThread(
-              content::BrowserThread::IO));
+      new net::TestURLRequestContextGetter(io_thread_.message_loop_proxy());
   driver_.reset(new GCMDriver(
       scoped_ptr<GCMClientFactory>(new FakeGCMClientFactory(
-          gcm_client_start_mode)).Pass(),
+          gcm_client_start_mode,
+          base::MessageLoopProxy::current(),
+          io_thread_.message_loop_proxy())).Pass(),
       identity_provider_owner_.PassAs<IdentityProvider>(),
       temp_dir_.path(),
-      request_context));
+      request_context,
+      base::MessageLoopProxy::current(),
+      io_thread_.message_loop_proxy(),
+      task_runner_));
 
   gcm_app_handler_.reset(new FakeGCMAppHandler);
   driver_->AddAppHandler(kTestAppID1, gcm_app_handler_.get());
   driver_->AddAppHandler(kTestAppID2, gcm_app_handler_.get());
 }
 
 void GCMDriverTest::SignIn(const std::string& account_id) {
   token_service_.AddAccount(account_id);
   identity_provider_->LogIn(account_id);
   PumpIOLoop();
@@ skipping 560 matching lines @@
 
 TEST_F(GCMDriverFunctionalTest, MessagesDeleted) {
   GetGCMClient()->DeleteMessages(kTestAppID1);
   gcm_app_handler()->WaitForNotification();
   EXPECT_EQ(FakeGCMAppHandler::MESSAGES_DELETED_EVENT,
             gcm_app_handler()->received_event());
   EXPECT_EQ(kTestAppID1, gcm_app_handler()->app_id());
 }
 
 }  // namespace gcm