This CL fixes the issue with login using alternative e-mails.

chrome/browser/chromeos/login/signin/device_id_browsertest.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/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 13 matching lines @@
 
 namespace {
 
 char kRefreshToken1[] = "refresh_token_1";
 char kRefreshToken2[] = "refresh_token_2";
 const base::FilePath::CharType kRefreshTokenToDeviceIdMapFile[] =
     FILE_PATH_LITERAL("refrest_token_to_device_id.json");
 
 char kSecondUserEmail[] = "second_user@gmail.com";
 char kSecondUserPassword[] = "password";
+char kSecondUserGaiaId[] = "4321";
 char kSecondUserRefreshToken1[] = "refresh_token_second_user_1";
 char kSecondUserRefreshToken2[] = "refresh_token_second_user_2";
 
 }  // namespace
 
 namespace chromeos {
 
 class DeviceIDTest : public OobeBaseTest,
                      public user_manager::RemoveUserDelegate {
  public:
@@ skipping 47 matching lines @@
   }
 
   void WaitForSessionStart() {
     content::WindowedNotificationObserver(
         chrome::NOTIFICATION_SESSION_STARTED,
         content::NotificationService::AllSources()).Wait();
   }
 
   void SignInOnline(const std::string& user_id,
                     const std::string& password,
-                    const std::string& refresh_token) {
+                    const std::string& refresh_token,
+                    const std::string& gaia_id) {
     WaitForGaiaPageLoad();
 
     FakeGaia::MergeSessionParams params;
     params.email = user_id;
     params.refresh_token = refresh_token;
     fake_gaia_->UpdateMergeSessionParams(params);
+    fake_gaia_->MapEmailToGaiaId(user_id, gaia_id);
 
     GetLoginDisplay()->ShowSigninScreenForCreds(user_id, password);
     WaitForSessionStart();
   }
 
   void SignInOffline(const std::string& user_id, const std::string& password) {
     WaitForSigninScreen();
 
     JS().ExecuteAsync(
         base::StringPrintf("chrome.send('authenticateUser', ['%s', '%s'])",
@@ skipping 46 matching lines @@
     EXPECT_TRUE(base::JSONWriter::Write(dictionary, &json));
     EXPECT_TRUE(base::WriteFile(GetRefreshTokenToDeviceIdMapFilePath(),
                                 json.c_str(), json.length()));
   }
 
   base::RunLoop user_removal_loop_;
 };
 
 // Add the first user and check that device ID is consistent.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_PRE_PRE_PRE_PRE_NewUsers) {
-  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken1);
+  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken1,
+               kFakeUserGaiaId);
   CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken1);
 }
 
 // Authenticate the first user through GAIA and verify that device ID remains
 // the same.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_PRE_PRE_PRE_NewUsers) {
   const std::string device_id = GetDeviceId(kFakeUserEmail);
   EXPECT_FALSE(device_id.empty());
   EXPECT_EQ(device_id, GetDeviceIdFromGAIA(kRefreshToken1));
 
-  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken2);
+  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken2,
+               kFakeUserGaiaId);
   CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken2);
 
   CHECK_EQ(device_id, GetDeviceId(kFakeUserEmail));
 }
 
 // Authenticate the first user offline and verify that device ID remains
 // the same.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_PRE_PRE_NewUsers) {
   const std::string device_id = GetDeviceId(kFakeUserEmail);
   EXPECT_FALSE(device_id.empty());
 
   SignInOffline(kFakeUserEmail, kFakeUserPassword);
   CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken2);
 
   // Verify that device ID remained the same after offline auth.
   CHECK_EQ(device_id, GetDeviceId(kFakeUserEmail));
 }
 
 // Add the second user.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_PRE_NewUsers) {
   WaitForSigninScreen();
   JS().ExecuteAsync("chrome.send('showAddUser')");
-  SignInOnline(kSecondUserEmail, kSecondUserPassword, kSecondUserRefreshToken1);
+  SignInOnline(kSecondUserEmail, kSecondUserPassword, kSecondUserRefreshToken1,
+               kSecondUserGaiaId);
   CheckDeviceIDIsConsistent(kSecondUserEmail, kSecondUserRefreshToken1);
 }
 
 // Remove the second user.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_NewUsers) {
   WaitForSigninScreen();
   RemoveUser(kSecondUserEmail);
 }
 
 // Add the second user back. Verify that device ID has been changed.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, NewUsers) {
   EXPECT_TRUE(GetDeviceId(kSecondUserEmail).empty());
-  SignInOnline(kSecondUserEmail, kSecondUserPassword, kSecondUserRefreshToken2);
+  SignInOnline(kSecondUserEmail, kSecondUserPassword, kSecondUserRefreshToken2,
+               kSecondUserGaiaId);
   CheckDeviceIDIsConsistent(kSecondUserEmail, kSecondUserRefreshToken2);
   EXPECT_NE(GetDeviceIdFromGAIA(kSecondUserRefreshToken1),
             GetDeviceId(kSecondUserEmail));
 }
 
 // Set up a user that has a device ID stored in preference only.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_Migration) {
-  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken1);
+  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken1,
+               kFakeUserGaiaId);
 
   // Simulate user that has device ID saved only in preferences (pre-M44).
   PrefService* prefs =
       ProfileHelper::Get()
           ->GetProfileByUser(user_manager::UserManager::Get()->GetActiveUser())
           ->GetPrefs();
   prefs->SetString(prefs::kGoogleServicesSigninScopedDeviceId,
                    GetDeviceId(kFakeUserEmail));
 
   // Can't use SetKnownUserDeviceId here, because it forbids changing a device
   // ID.
   user_manager::UserManager::Get()->SetKnownUserStringPref(
       kFakeUserEmail, "device_id", std::string());
 }
 
 // Tests that after the first sign in the device ID has been moved to the Local
 // state.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, Migration) {
   EXPECT_TRUE(GetDeviceId(kFakeUserEmail).empty());
   SignInOffline(kFakeUserEmail, kFakeUserPassword);
   CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken1);
 }
 
 // Set up a user that doesn't have a device ID.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_LegacyUsers) {
-  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken1);
+  SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken1,
+               kFakeUserGaiaId);
 
   PrefService* prefs =
       ProfileHelper::Get()
           ->GetProfileByUser(user_manager::UserManager::Get()->GetActiveUser())
           ->GetPrefs();
   EXPECT_TRUE(
       prefs->GetString(prefs::kGoogleServicesSigninScopedDeviceId).empty());
 
   // Can't use SetKnownUserDeviceId here, because it forbids changing a device
   // ID.
   user_manager::UserManager::Get()->SetKnownUserStringPref(
       kFakeUserEmail, "device_id", std::string());
 }
 
 // Tests that device ID has been generated after the first sign in.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, LegacyUsers) {
   EXPECT_TRUE(GetDeviceId(kFakeUserEmail).empty());
   SignInOffline(kFakeUserEmail, kFakeUserPassword);
   // Last param |auth_code| is empty, because we don't pass a device ID to GAIA
   // in this case.
   CheckDeviceIDIsConsistent(kFakeUserEmail, std::string());
 }
 
 }  // namespace chromeos