Replace SetAuthenticatedUsername with SetAuthenticatedAccountId.

chrome/browser/chromeos/login/signin/oauth2_browsertest.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 <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "chromeos/login/auth/key.h"
 #include "chromeos/login/auth/user_context.h"
 #include "components/app_modal/javascript_app_modal_dialog.h"
 #include "components/app_modal/native_app_modal_dialog.h"
+#include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/browser_test_utils.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using app_modal::AppModalDialog;
 using app_modal::JavaScriptAppModalDialog;
 using net::test_server::BasicHttpResponse;
 using net::test_server::HttpRequest;
 using net::test_server::HttpResponse;
 
 namespace chromeos {
 
 namespace {
 
 // Email of owner account for test.
-const char kTestAccountId[] = "username@gmail.com";
-const char kTestRawAccountId[] = "User.Name";
+const char kTestGaiaId[] = "12345";
+const char kTestEmail[] = "username@gmail.com";
+const char kTestRawEmail[] = "User.Name@gmail.com";
 const char kTestAccountPassword[] = "fake-password";
 const char kTestAuthCode[] = "fake-auth-code";
 const char kTestGaiaUberToken[] = "fake-uber-token";
 const char kTestAuthLoginAccessToken[] = "fake-access-token";
 const char kTestRefreshToken[] = "fake-refresh-token";
 const char kTestAuthSIDCookie[] = "fake-auth-SID-cookie";
 const char kTestAuthLSIDCookie[] = "fake-auth-LSID-cookie";
 const char kTestSessionSIDCookie[] = "fake-session-SID-cookie";
 const char kTestSessionLSIDCookie[] = "fake-session-LSID-cookie";
 const char kTestSession2SIDCookie[] = "fake-session2-SID-cookie";
 const char kTestSession2LSIDCookie[] = "fake-session2-LSID-cookie";
 const char kTestUserinfoToken[] = "fake-userinfo-token";
 const char kTestLoginToken[] = "fake-login-token";
 const char kTestSyncToken[] = "fake-sync-token";
 const char kTestAuthLoginToken[] = "fake-oauthlogin-token";
 
+std::string PickAccountId(Profile* profile,
+                          const std::string& gaia_id,
+                          const std::string& email) {
+  return AccountTrackerService::PickAccountIdForAccount(profile->GetPrefs(),
+                                                        gaia_id, email);
+}
+
 class OAuth2LoginManagerStateWaiter : public OAuth2LoginManager::Observer {
  public:
   explicit OAuth2LoginManagerStateWaiter(Profile* profile)
      : profile_(profile),
        waiting_for_state_(false),
        final_state_(OAuth2LoginManager::SESSION_RESTORE_NOT_STARTED) {
   }
 
   void WaitForStates(
       const std::set<OAuth2LoginManager::SessionRestoreState>& states) {
@@ skipping 63 matching lines @@
     params.access_token = kTestAuthLoginAccessToken;
     params.gaia_uber_token = kTestGaiaUberToken;
     params.session_sid_cookie = kTestSessionSIDCookie;
     params.session_lsid_cookie = kTestSessionLSIDCookie;
     fake_gaia_->SetMergeSessionParams(params);
     SetupGaiaServerWithAccessTokens();
   }
 
   void SetupGaiaServerForUnexpiredAccount() {
     FakeGaia::MergeSessionParams params;
-    params.email = kTestAccountId;
+    params.email = kTestEmail;
     fake_gaia_->SetMergeSessionParams(params);
     SetupGaiaServerWithAccessTokens();
   }
 
   void SetupGaiaServerForExpiredAccount() {
     FakeGaia::MergeSessionParams params;
     params.gaia_uber_token = kTestGaiaUberToken;
     params.session_sid_cookie = kTestSession2SIDCookie;
     params.session_lsid_cookie = kTestSession2LSIDCookie;
     fake_gaia_->SetMergeSessionParams(params);
     SetupGaiaServerWithAccessTokens();
   }
 
   void LoginAsExistingUser() {
     content::WindowedNotificationObserver(
       chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 
     JsExpect("!!document.querySelector('#account-picker')");
     JsExpect("!!document.querySelector('#pod-row')");
 
-    EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId),
+    std::string account_id = PickAccountId(
+        ProfileManager::GetPrimaryUserProfile(), kTestGaiaId, kTestEmail);
+
+    EXPECT_EQ(GetOAuthStatusFromLocalState(account_id),
               user_manager::User::OAUTH2_TOKEN_STATUS_VALID);
 
-    EXPECT_TRUE(TryToLogin(kTestAccountId, kTestAccountPassword));
+    // Try login.  Primary profile has changed.
+    EXPECT_TRUE(TryToLogin(kTestGaiaId, kTestEmail, kTestAccountPassword));
     Profile* profile = ProfileManager::GetPrimaryUserProfile();
 
     // Wait for the session merge to finish.
     WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_DONE);
 
     // Check for existance of refresh token.
     ProfileOAuth2TokenService* token_service =
           ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
-    EXPECT_TRUE(token_service->RefreshTokenIsAvailable(kTestAccountId));
+    EXPECT_TRUE(token_service->RefreshTokenIsAvailable(account_id));
 
-    EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId),
+    EXPECT_EQ(GetOAuthStatusFromLocalState(account_id),
               user_manager::User::OAUTH2_TOKEN_STATUS_VALID);
   }
 
-  bool TryToLogin(const std::string& username,
+  bool TryToLogin(const std::string& gaia_id,
+                  const std::string& username,
                   const std::string& password) {
-    if (!AddUserToSession(username, password))
+    if (!AddUserToSession(gaia_id, username, password))
       return false;
 
     if (const user_manager::User* active_user =
             user_manager::UserManager::Get()->GetActiveUser()) {
       return active_user->email() == username;
     }
 
     return false;
   }
 
   user_manager::User::OAuthTokenStatus GetOAuthStatusFromLocalState(
-      const std::string& user_id) const {
+      const std::string& account_id) const {
     PrefService* local_state = g_browser_process->local_state();
     const base::DictionaryValue* prefs_oauth_status =
         local_state->GetDictionary("OAuthTokenStatus");
     int oauth_token_status = user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN;
     if (prefs_oauth_status &&
         prefs_oauth_status->GetIntegerWithoutPathExpansion(
-            user_id, &oauth_token_status)) {
+            account_id, &oauth_token_status)) {
       user_manager::User::OAuthTokenStatus result =
           static_cast<user_manager::User::OAuthTokenStatus>(oauth_token_status);
       return result;
     }
     return user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN;
   }
 
  protected:
   // OobeBaseTest overrides.
   Profile* profile() override {
     if (user_manager::UserManager::Get()->GetActiveUser())
       return ProfileManager::GetPrimaryUserProfile();
 
     return OobeBaseTest::profile();
   }
 
-  bool AddUserToSession(const std::string& username,
+  bool AddUserToSession(const std::string& gaia_id,
+                        const std::string& username,
                         const std::string& password) {
     ExistingUserController* controller =
         ExistingUserController::current_controller();
     if (!controller) {
       ADD_FAILURE();
       return false;
     }
 
     UserContext user_context(username);
+    user_context.SetGaiaID(gaia_id);
     user_context.SetKey(Key(password));
     controller->Login(user_context, SigninSpecifics());
     content::WindowedNotificationObserver(
         chrome::NOTIFICATION_SESSION_STARTED,
         content::NotificationService::AllSources()).Wait();
     const user_manager::UserList& logged_users =
         user_manager::UserManager::Get()->GetLoggedInUsers();
     for (user_manager::UserList::const_iterator it = logged_users.begin();
          it != logged_users.end();
          ++it) {
       if ((*it)->email() == username)
         return true;
     }
     return false;
   }
 
   void SetupGaiaServerWithAccessTokens() {
+    fake_gaia_->MapEmailToGaiaId(kTestEmail, kTestGaiaId);
+
     // Configure OAuth authentication.
     GaiaUrls* gaia_urls = GaiaUrls::GetInstance();
 
     // This token satisfies the userinfo.email request from
     // DeviceOAuth2TokenService used in token validation.
     FakeGaia::AccessTokenInfo userinfo_token_info;
     userinfo_token_info.token = kTestUserinfoToken;
     userinfo_token_info.scopes.insert(
         "https://www.googleapis.com/auth/userinfo.email");
     userinfo_token_info.audience = gaia_urls->oauth2_chrome_client_id();
-    userinfo_token_info.email = kTestAccountId;
+    userinfo_token_info.email = kTestEmail;
     fake_gaia_->IssueOAuthToken(kTestRefreshToken, userinfo_token_info);
 
     FakeGaia::AccessTokenInfo userinfo_profile_token_info;
     userinfo_profile_token_info.token = kTestUserinfoToken;
     userinfo_profile_token_info.scopes.insert(
         "https://www.googleapis.com/auth/userinfo.profile");
     userinfo_profile_token_info.audience = gaia_urls->oauth2_chrome_client_id();
-    userinfo_profile_token_info.email = kTestAccountId;
+    userinfo_profile_token_info.email = kTestEmail;
     fake_gaia_->IssueOAuthToken(kTestRefreshToken, userinfo_profile_token_info);
 
     // The any-api access token for accessing the token minting endpoint.
     FakeGaia::AccessTokenInfo login_token_info;
     login_token_info.token = kTestLoginToken;
     login_token_info.scopes.insert(GaiaConstants::kAnyApiOAuth2Scope);
     login_token_info.audience = gaia_urls->oauth2_chrome_client_id();
     fake_gaia_->IssueOAuthToken(kTestRefreshToken, login_token_info);
 
     // The /auth/chromesync access token for accessing sync endpoint.
@@ skipping 36 matching lines @@
     chromeos::WizardController* wizard_controller =
         chromeos::WizardController::default_controller();
     wizard_controller->SkipToLoginForTesting(LoginScreenContext());
 
     content::WindowedNotificationObserver(
       chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
       content::NotificationService::AllSources()).Wait();
 
     // Use capitalized and dotted user name on purpose to make sure
     // our email normalization kicks in.
-    GetLoginDisplay()->ShowSigninScreenForCreds(kTestRawAccountId,
+    GetLoginDisplay()->ShowSigninScreenForCreds(kTestRawEmail,
                                                 kTestAccountPassword);
 
     content::WindowedNotificationObserver(
       chrome::NOTIFICATION_SESSION_STARTED,
       content::NotificationService::AllSources()).Wait();
 
     if (wait_for_merge) {
       // Wait for the session merge to finish.
       WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_DONE);
     }
@@ skipping 58 matching lines @@
   net::CookieList cookie_list_;
   scoped_refptr<content::MessageLoopRunner> runner_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieReader);
 };
 
 // PRE_MergeSession is testing merge session for a new profile.
 IN_PROC_BROWSER_TEST_F(OAuth2Test, PRE_PRE_PRE_MergeSession) {
   StartNewUserSession(true);
   // Check for existance of refresh token.
+  std::string account_id = PickAccountId(profile(), kTestGaiaId, kTestEmail);
   ProfileOAuth2TokenService* token_service =
         ProfileOAuth2TokenServiceFactory::GetForProfile(
             profile());
-  EXPECT_TRUE(token_service->RefreshTokenIsAvailable(kTestAccountId));
+  EXPECT_TRUE(token_service->RefreshTokenIsAvailable(account_id));
 
-  EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId),
+  EXPECT_EQ(GetOAuthStatusFromLocalState(account_id),
             user_manager::User::OAUTH2_TOKEN_STATUS_VALID);
 
   scoped_refptr<CookieReader> cookie_reader(new CookieReader());
   cookie_reader->ReadCookies(profile());
   EXPECT_EQ(cookie_reader->GetCookieValue("SID"), kTestSessionSIDCookie);
   EXPECT_EQ(cookie_reader->GetCookieValue("LSID"), kTestSessionLSIDCookie);
 }
 
 // MergeSession test is running merge session process for an existing profile
 // that was generated in PRE_PRE_PRE_MergeSession test. In this test, we
@@ skipping 32 matching lines @@
 IN_PROC_BROWSER_TEST_F(OAuth2Test, MergeSession) {
   SimulateNetworkOnline();
 
   content::WindowedNotificationObserver(
     chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
     content::NotificationService::AllSources()).Wait();
 
   JsExpect("!!document.querySelector('#account-picker')");
   JsExpect("!!document.querySelector('#pod-row')");
 
-  EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId),
+  std::string account_id = PickAccountId(profile(), kTestGaiaId, kTestEmail);
+  EXPECT_EQ(GetOAuthStatusFromLocalState(account_id),
             user_manager::User::OAUTH2_TOKEN_STATUS_VALID);
 
-  EXPECT_TRUE(TryToLogin(kTestAccountId, kTestAccountPassword));
+  EXPECT_TRUE(TryToLogin(kTestGaiaId, kTestEmail, kTestAccountPassword));
 
   // Wait for the session merge to finish.
   WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_FAILED);
 
-  EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId),
+  EXPECT_EQ(GetOAuthStatusFromLocalState(account_id),
             user_manager::User::OAUTH2_TOKEN_STATUS_INVALID);
 }
 
 
 const char kGooglePageContent[] =
     "<html><title>Hello!</title><script>alert('hello');</script>"
     "<body>Hello Google!</body></html>";
 const char kRandomPageContent[] =
     "<html><title>SomthingElse</title><body>I am SomethingElse</body></html>";
 const char kHelloPagePath[] = "/hello_google";
@@ skipping 293 matching lines @@
 
   if (!catcher.GetNextResult()) {
     std::string message = catcher.message();
     ADD_FAILURE() << "Tests failed: " << message;
   }
 
   EXPECT_TRUE(fake_google_.IsPageRequested());
 }
 
 }  // namespace chromeos