Replace SetAuthenticatedUsername with SetAuthenticatedAccountId.

chrome/browser/signin/signin_manager_unittest.cc

 // Copyright (c) 2012 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/signin/core/browser/signin_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
 #include "chrome/browser/signin/gaia_cookie_manager_service_factory.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/test_signin_client_builder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/test_signin_client.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request.h"
@@ skipping 66 matching lines @@
     builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
                               BuildFakeProfileOAuth2TokenService);
     builder.AddTestingFactory(ChromeSigninClientFactory::GetInstance(),
                               signin::BuildTestSigninClient);
     builder.AddTestingFactory(SigninManagerFactory::GetInstance(),
                               SigninManagerBuild);
     builder.AddTestingFactory(AccountTrackerServiceFactory::GetInstance(),
                               FakeAccountTrackerService::Build);
     profile_ = builder.Build();
 
-    signin_client()->SetURLRequestContext(profile_->GetRequestContext());
+    TestSigninClient* client =
+        static_cast<TestSigninClient*>(
+            ChromeSigninClientFactory::GetForProfile(profile()));
+    client->SetURLRequestContext(profile_->GetRequestContext());
   }
 
   void TearDown() override {
     if (manager_)
       manager_->RemoveObserver(&test_observer_);
 
     // Destroy the SigninManager here, because it relies on profile() which is
     // freed in the base class.
     if (naked_manager_) {
       naked_manager_->Shutdown();
       naked_manager_.reset(NULL);
     }
     TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
 
     // Manually destroy PrefService and Profile so that they are shutdown
     // in the correct order.  Both need to be destroyed before the
     // |thread_bundle_| member.
     profile_.reset();
     prefs_.reset();  // LocalState needs to outlive the profile.
   }
 
   TestingProfile* profile() { return profile_.get(); }
 
   TestSigninClient* signin_client() {
       return static_cast<TestSigninClient*>(
           ChromeSigninClientFactory::GetInstance()->GetForProfile(profile()));
   }
 
+  // Seed the account tracker with information from logged in user.  Normally
+  // this is done by UI code before calling SigninManager.  Returns the string
+  // to use as the account_id.
+  std::string AddToAccountTracker(const std::string& gaia_id,
+                                  const std::string& email) {
+    AccountTrackerService* service =
+        AccountTrackerServiceFactory::GetForProfile(profile());
+    service->SeedAccountInfo(gaia_id, email);
+    return service->PickAccountIdForAccount(gaia_id, email);
+  }
+
   // Sets up the signin manager as a service if other code will try to get it as
   // a PKS.
   void SetUpSigninManagerAsService() {
     DCHECK(!manager_);
     DCHECK(!naked_manager_);
     manager_ = static_cast<SigninManager*>(
         SigninManagerFactory::GetForProfile(profile()));
     manager_->AddObserver(&test_observer_);
   }
 
@@ skipping 15 matching lines @@
     DCHECK(manager_);
     manager_->RemoveObserver(&test_observer_);
     manager_->Shutdown();
     if (naked_manager_)
       naked_manager_.reset(NULL);
     manager_ = NULL;
   }
 
   void ExpectSignInWithRefreshTokenSuccess() {
     EXPECT_TRUE(manager_->IsAuthenticated());
+    EXPECT_FALSE(manager_->GetAuthenticatedAccountId().empty());
+    EXPECT_FALSE(manager_->GetAuthenticatedUsername().empty());
 
     ProfileOAuth2TokenService* token_service =
         ProfileOAuth2TokenServiceFactory::GetForProfile(profile());
     EXPECT_TRUE(token_service->RefreshTokenIsAvailable(
-        manager_->GetAuthenticatedUsername()));
+        manager_->GetAuthenticatedAccountId()));
 
     // Should go into token service and stop.
     EXPECT_EQ(1, test_observer_.num_successful_signins_);
     EXPECT_EQ(0, test_observer_.num_failed_signins_);
   }
 
   void CompleteSigninCallback(const std::string& oauth_token) {
     oauth_tokens_fetched_.push_back(oauth_token);
     manager_->CompletePendingSignin();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   net::TestURLFetcherFactory factory_;
   scoped_ptr<SigninManager> naked_manager_;
   SigninManager* manager_;
   TestSigninManagerObserver test_observer_;
   scoped_ptr<TestingProfile> profile_;
   std::vector<std::string> oauth_tokens_fetched_;
   scoped_ptr<TestingPrefServiceSimple> prefs_;
   std::vector<std::string> cookies_;
 };
 
 TEST_F(SigninManagerTest, SignInWithRefreshToken) {
   SetUpSigninManagerAsService();
   EXPECT_FALSE(manager_->IsAuthenticated());
 
+  std::string account_id = AddToAccountTracker("gaia_id", "user@gmail.com");
   manager_->StartSignInWithRefreshToken(
-      "rt1",
+      "rt",
+      "gaia_id",
       "user@gmail.com",
       "password",
       SigninManager::OAuthTokenFetchedCallback());
 
   ExpectSignInWithRefreshTokenSuccess();
 
   // Should persist across resets.
   ShutDownManager();
   CreateNakedSigninManager();
   manager_->Initialize(NULL);
-  EXPECT_EQ("user@gmail.com", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ(account_id, manager_->GetAuthenticatedAccountId());
 }
 
 TEST_F(SigninManagerTest, SignInWithRefreshTokenCallbackComplete) {
   SetUpSigninManagerAsService();
   EXPECT_FALSE(manager_->IsAuthenticated());
 
   // Since the password is empty, must verify the gaia cookies first.
   SigninManager::OAuthTokenFetchedCallback callback =
       base::Bind(&SigninManagerTest::CompleteSigninCallback,
                  base::Unretained(this));
   manager_->StartSignInWithRefreshToken(
-      "rt1",
+      "rt",
+      "gaia_id",
       "user@gmail.com",
       "password",
       callback);
 
   ExpectSignInWithRefreshTokenSuccess();
   ASSERT_EQ(1U, oauth_tokens_fetched_.size());
-  EXPECT_EQ(oauth_tokens_fetched_[0], "rt1");
+  EXPECT_EQ(oauth_tokens_fetched_[0], "rt");
 }
 
 TEST_F(SigninManagerTest, SignInWithRefreshTokenCallsPostSignout) {
   SetUpSigninManagerAsService();
   EXPECT_FALSE(manager_->IsAuthenticated());
 
   std::string gaia_id = "12345";
   std::string email = "user@google.com";
 
   FakeAccountTrackerService* account_tracker_service =
     static_cast<FakeAccountTrackerService*>(
         AccountTrackerServiceFactory::GetForProfile(profile()));
   account_tracker_service->SeedAccountInfo(gaia_id, email);
   account_tracker_service->EnableNetworkFetches();
   std::string account_id = account_tracker_service->PickAccountIdForAccount(
       gaia_id, email);
 
   ASSERT_TRUE(signin_client()->get_signed_in_password().empty());
 
   manager_->StartSignInWithRefreshToken(
       "rt1",
+      gaia_id,
       email,
       "password",
       SigninManager::OAuthTokenFetchedCallback());
 
   // PostSignedIn is not called until the AccountTrackerService returns.
   ASSERT_EQ("", signin_client()->get_signed_in_password());
 
   account_tracker_service->FakeUserInfoFetchSuccess(
       account_id, email, gaia_id, "google.com");
 
   // AccountTracker and SigninManager are both done and PostSignedIn was called.
   ASSERT_EQ("password", signin_client()->get_signed_in_password());
 
   ExpectSignInWithRefreshTokenSuccess();
 
 }
 
 TEST_F(SigninManagerTest, SignOut) {
   SetUpSigninManagerAsService();
   manager_->StartSignInWithRefreshToken(
-      "rt1",
+      "rt",
+      "gaia_id",
       "user@gmail.com",
       "password",
       SigninManager::OAuthTokenFetchedCallback());
   manager_->SignOut(signin_metrics::SIGNOUT_TEST);
   EXPECT_FALSE(manager_->IsAuthenticated());
+  EXPECT_TRUE(manager_->GetAuthenticatedUsername().empty());
+  EXPECT_TRUE(manager_->GetAuthenticatedAccountId().empty());
   // Should not be persisted anymore
   ShutDownManager();
   CreateNakedSigninManager();
   manager_->Initialize(NULL);
   EXPECT_FALSE(manager_->IsAuthenticated());
+  EXPECT_TRUE(manager_->GetAuthenticatedUsername().empty());
+  EXPECT_TRUE(manager_->GetAuthenticatedAccountId().empty());
 }
 
 TEST_F(SigninManagerTest, SignOutWhileProhibited) {
   SetUpSigninManagerAsService();
   EXPECT_FALSE(manager_->IsAuthenticated());
+  EXPECT_TRUE(manager_->GetAuthenticatedUsername().empty());
+  EXPECT_TRUE(manager_->GetAuthenticatedAccountId().empty());
 
-  manager_->SetAuthenticatedUsername("user@gmail.com");
+  manager_->SetAuthenticatedAccountInfo("gaia_id", "user@gmail.com");
   manager_->ProhibitSignout(true);
   manager_->SignOut(signin_metrics::SIGNOUT_TEST);
   EXPECT_TRUE(manager_->IsAuthenticated());
   manager_->ProhibitSignout(false);
   manager_->SignOut(signin_metrics::SIGNOUT_TEST);
   EXPECT_FALSE(manager_->IsAuthenticated());
 }
 
 TEST_F(SigninManagerTest, Prohibited) {
   g_browser_process->local_state()->SetString(
@@ skipping 15 matching lines @@
   CreateNakedSigninManager();
   manager_->Initialize(g_browser_process->local_state());
   EXPECT_TRUE(manager_->IsAllowedUsername("test@google.com"));
   EXPECT_TRUE(manager_->IsAllowedUsername("happy@google.com"));
   EXPECT_FALSE(manager_->IsAllowedUsername("test@invalid.com"));
   EXPECT_FALSE(manager_->IsAllowedUsername("test@notgoogle.com"));
   EXPECT_FALSE(manager_->IsAllowedUsername(std::string()));
 }
 
 TEST_F(SigninManagerTest, ProhibitedAtStartup) {
-  profile()->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
-                                   "monkey@invalid.com");
+  std::string account_id = AddToAccountTracker("gaia_id", "user@gmail.com");
+  profile()->GetPrefs()->SetString(prefs::kGoogleServicesAccountId, account_id);
   g_browser_process->local_state()->SetString(
       prefs::kGoogleServicesUsernamePattern, ".*@google.com");
   CreateNakedSigninManager();
   manager_->Initialize(g_browser_process->local_state());
   // Currently signed in user is prohibited by policy, so should be signed out.
   EXPECT_EQ("", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ("", manager_->GetAuthenticatedAccountId());
 }
 
 TEST_F(SigninManagerTest, ProhibitedAfterStartup) {
-  std::string user("monkey@invalid.com");
-  profile()->GetPrefs()->SetString(prefs::kGoogleServicesUsername, user);
+  std::string account_id = AddToAccountTracker("gaia_id", "user@gmail.com");
+  profile()->GetPrefs()->SetString(prefs::kGoogleServicesAccountId, account_id);
   CreateNakedSigninManager();
   manager_->Initialize(g_browser_process->local_state());
-  EXPECT_EQ(user, manager_->GetAuthenticatedUsername());
+  EXPECT_EQ("user@gmail.com", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ(account_id, manager_->GetAuthenticatedAccountId());
   // Update the profile - user should be signed out.
   g_browser_process->local_state()->SetString(
       prefs::kGoogleServicesUsernamePattern, ".*@google.com");
   EXPECT_EQ("", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ("", manager_->GetAuthenticatedAccountId());
 }
 
 TEST_F(SigninManagerTest, ExternalSignIn) {
   CreateNakedSigninManager();
   manager_->Initialize(g_browser_process->local_state());
-  EXPECT_EQ("",
-            profile()->GetPrefs()->GetString(prefs::kGoogleServicesUsername));
   EXPECT_EQ("", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ("", manager_->GetAuthenticatedAccountId());
   EXPECT_EQ(0, test_observer_.num_successful_signins_);
 
-  manager_->OnExternalSigninCompleted("external@example.com");
+  std::string account_id = AddToAccountTracker("gaia_id", "user@gmail.com");
+  manager_->OnExternalSigninCompleted(account_id);
   EXPECT_EQ(1, test_observer_.num_successful_signins_);
   EXPECT_EQ(0, test_observer_.num_failed_signins_);
-  EXPECT_EQ("external@example.com",
-            profile()->GetPrefs()->GetString(prefs::kGoogleServicesUsername));
-  EXPECT_EQ("external@example.com", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ("user@gmail.com", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ(account_id, manager_->GetAuthenticatedAccountId());
 }
 
 TEST_F(SigninManagerTest, SigninNotAllowed) {
   std::string user("user@google.com");
-  profile()->GetPrefs()->SetString(prefs::kGoogleServicesUsername, user);
+  profile()->GetPrefs()->SetString(prefs::kGoogleServicesAccountId, user);
   profile()->GetPrefs()->SetBoolean(prefs::kSigninAllowed, false);
-  SetUpSigninManagerAsService();
+  CreateNakedSigninManager();
+  AddToAccountTracker("gaia_id", user);
+  manager_->Initialize(g_browser_process->local_state());
+  // Currently signing in is prohibited by policy, so should be signed out.
+  EXPECT_EQ("", manager_->GetAuthenticatedUsername());
+  EXPECT_EQ("", manager_->GetAuthenticatedAccountId());
 }
+
+TEST_F(SigninManagerTest, UpgradeToNewPrefs) {
+  profile()->GetPrefs()->SetString(prefs::kGoogleServicesUsername,
+                                   "user@gmail.com");
+  profile()->GetPrefs()->SetString(prefs::kGoogleServicesUserAccountId,
+                                   "account_id");
+  CreateNakedSigninManager();
+  manager_->Initialize(g_browser_process->local_state());
+  EXPECT_EQ("user@gmail.com", manager_->GetAuthenticatedUsername());
+
+  // TODO(rogerta): until the migration to gaia id, the account id will remain
+  // the old username.
+  EXPECT_EQ("user@gmail.com", manager_->GetAuthenticatedAccountId());
+  EXPECT_EQ("user@gmail.com",
+            profile()->GetPrefs()->GetString(prefs::kGoogleServicesAccountId));
+  EXPECT_EQ("",
+            profile()->GetPrefs()->GetString(prefs::kGoogleServicesUsername));
+
+  // Make sure account tracker was updated.
+  AccountTrackerService* service =
+      AccountTrackerServiceFactory::GetForProfile(profile());
+  AccountTrackerService::AccountInfo info = service->GetAccountInfo(
+      manager_->GetAuthenticatedAccountId());
+  EXPECT_EQ("user@gmail.com", info.email);
+  EXPECT_EQ("account_id", info.gaia);
+}