Move IdentityProvider usage from GCMDriverDesktop to GCMProfileService

components/gcm_driver/gcm_driver_desktop_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 "components/gcm_driver/gcm_driver_desktop.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 "components/gcm_driver/fake_gcm_app_handler.h"
 #include "components/gcm_driver/fake_gcm_client.h"
 #include "components/gcm_driver/fake_gcm_client_factory.h"
 #include "components/gcm_driver/gcm_app_handler.h"
 #include "components/gcm_driver/gcm_client_factory.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";
@@ skipping 68 matching lines @@
 
   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);
 
   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_;
   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()),
+    : 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() {
   io_thread_.Start();
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 }
 
@@ skipping 38 matching lines @@
 void GCMDriverTest::CreateDriver(
     FakeGCMClient::StartMode gcm_client_start_mode) {
   scoped_refptr<net::URLRequestContextGetter> request_context =
       new net::TestURLRequestContextGetter(io_thread_.message_loop_proxy());
   // TODO(johnme): Need equivalent test coverage of GCMDriverAndroid.
   driver_.reset(new GCMDriverDesktop(
       scoped_ptr<GCMClientFactory>(new FakeGCMClientFactory(
           gcm_client_start_mode,
           base::MessageLoopProxy::current(),
           io_thread_.message_loop_proxy())).Pass(),
-      identity_provider_owner_.PassAs<IdentityProvider>(),
       GCMClient::ChromeBuildInfo(),
       temp_dir_.path(),
       request_context,
       base::MessageLoopProxy::current(),
       io_thread_.message_loop_proxy(),
       task_runner_));
 
   gcm_app_handler_.reset(new FakeGCMAppHandler);
 }
 
 void GCMDriverTest::AddAppHandlers() {
   driver_->AddAppHandler(kTestAppID1, gcm_app_handler_.get());
   driver_->AddAppHandler(kTestAppID2, gcm_app_handler_.get());
 }
 
 void GCMDriverTest::RemoveAppHandlers() {
   driver_->RemoveAppHandler(kTestAppID1);
   driver_->RemoveAppHandler(kTestAppID2);
 }
 
 void GCMDriverTest::SignIn(const std::string& account_id) {
-  token_service_.AddAccount(account_id);
-  identity_provider_->LogIn(account_id);
+  driver_->OnSignedIn();
   PumpIOLoop();
   PumpUILoop();
 }
 
 void GCMDriverTest::SignOut() {
-  identity_provider_->LogOut();
+  driver_->Purge();
   PumpIOLoop();
   PumpUILoop();
 }
 
 void GCMDriverTest::Register(const std::string& app_id,
                              const std::vector<std::string>& sender_ids,
                              WaitToFinish wait_to_finish) {
   base::RunLoop run_loop;
   async_operation_completed_callback_ = run_loop.QuitClosure();
   driver_->Register(app_id,
@@ skipping 51 matching lines @@
   if (!async_operation_completed_callback_.is_null())
     async_operation_completed_callback_.Run();
 }
 
 void GCMDriverTest::UnregisterCompleted(GCMClient::Result result) {
   unregistration_result_ = result;
   if (!async_operation_completed_callback_.is_null())
     async_operation_completed_callback_.Run();
 }
 
-TEST_F(GCMDriverTest, CreateGCMDriverBeforeSignIn) {
+TEST_F(GCMDriverTest, Create) {
   // Create GCMDriver first. GCM is not started.
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_FALSE(driver()->IsStarted());
 
   // Sign in. GCM is still not started.
   SignIn(kTestAccountID1);
   EXPECT_FALSE(driver()->IsStarted());
 
   // GCM will be started only after both sign-in and app handler being
   AddAppHandlers();
   EXPECT_TRUE(driver()->IsStarted());
 }
 
-TEST_F(GCMDriverTest, CreateGCMDriverAfterSignIn) {
-  // Sign in. Nothings happens since GCMDriver is not created.
-  SignIn(kTestAccountID1);
-
-  // Create GCMDriver after sign-in. GCM is not started.
-  CreateDriver(FakeGCMClient::NO_DELAY_START);
-  EXPECT_FALSE(driver()->IsStarted());
-
-  // GCM will be started only after both sign-in and app handler being
-  AddAppHandlers();
-  EXPECT_TRUE(driver()->IsStarted());
-}
-
 TEST_F(GCMDriverTest, Shutdown) {
   CreateDriver(FakeGCMClient::NO_DELAY_START);
   EXPECT_FALSE(HasAppHandlers());
 
   AddAppHandlers();
   EXPECT_TRUE(HasAppHandlers());
 
   driver()->Shutdown();
   EXPECT_FALSE(HasAppHandlers());
 }
@@ skipping 555 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