This CL replaces user_manager::UserID with AccountId.

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 39 matching lines @@
   void SetUpOnMainThread() override {
     OobeBaseTest::SetUpOnMainThread();
     LoadRefreshTokenToDeviceIdMap();
   }
 
   void TearDownOnMainThread() override {
     SaveRefreshTokenToDeviceIdMap();
     OobeBaseTest::TearDownOnMainThread();
   }
 
-  std::string GetDeviceId(const std::string& user_id) {
+  std::string GetDeviceId(const AccountId& user_id) {

[achuithb, 2015/10/23 00:08:50]

account_id, here and below

[Alexander Alekseev, 2015/10/23 09:11:22]

Done.

     return user_manager::UserManager::Get()->GetKnownUserDeviceId(user_id);
   }
 
-  std::string GetDeviceIdFromSigninClient(const std::string& user_id) {
+  std::string GetDeviceIdFromSigninClient(const AccountId& user_id) {
     return ChromeSigninClientFactory::GetForProfile(
                ProfileHelper::Get()->GetProfileByUser(
                    user_manager::UserManager::Get()->FindUser(user_id)))
         ->GetSigninScopedDeviceId();
   }
 
   std::string GetDeviceIdFromGAIA(const std::string& refresh_token) {
     return fake_gaia_->GetDeviceIdByRefreshToken(refresh_token);
   }
 
   // Checks that user's device ID retrieved from UserManager and SigninClient
   // are the same.
   // If |refresh_token| is not empty, checks that device ID associated with the
   // |refresh_token| in GAIA is the same as ID saved on device.
-  void CheckDeviceIDIsConsistent(const std::string& user_id,
+  void CheckDeviceIDIsConsistent(const AccountId& user_id,
                                  const std::string& refresh_token) {
     const std::string device_id_in_signin_client =
         GetDeviceIdFromSigninClient(user_id);
     const std::string device_id_in_local_state = GetDeviceId(user_id);
 
     EXPECT_FALSE(device_id_in_signin_client.empty());
     EXPECT_EQ(device_id_in_signin_client, device_id_in_local_state);
 
     if (!refresh_token.empty()) {
       const std::string device_id_in_gaia = GetDeviceIdFromGAIA(refresh_token);
@@ skipping 25 matching lines @@
 
   void SignInOffline(const std::string& user_id, const std::string& password) {
     WaitForSigninScreen();
 
     JS().ExecuteAsync(
         base::StringPrintf("chrome.send('authenticateUser', ['%s', '%s'])",
                            user_id.c_str(), password.c_str()));
     WaitForSessionStart();
   }
 
-  void RemoveUser(const std::string& user_id) {
+  void RemoveUser(const AccountId& user_id) {
     user_manager::UserManager::Get()->RemoveUser(user_id, this);
     user_removal_loop_.Run();
   }
 
  private:
   // user_manager::RemoveUserDelegate:
   void OnBeforeUserRemoved(const std::string& username) override {}
 
   void OnUserRemoved(const std::string& username) override {
     user_removal_loop_.Quit();
@@ skipping 33 matching lines @@
                                 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,
                kFakeUserGaiaId);
-  CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken1);
+  CheckDeviceIDIsConsistent(AccountId::FromUserEmail(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);
+  const std::string device_id =
+      GetDeviceId(AccountId::FromUserEmail(kFakeUserEmail));
   EXPECT_FALSE(device_id.empty());
   EXPECT_EQ(device_id, GetDeviceIdFromGAIA(kRefreshToken1));
 
   SignInOnline(kFakeUserEmail, kFakeUserPassword, kRefreshToken2,
                kFakeUserGaiaId);
-  CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken2);
+  CheckDeviceIDIsConsistent(AccountId::FromUserEmail(kFakeUserEmail),
+                            kRefreshToken2);
 
-  CHECK_EQ(device_id, GetDeviceId(kFakeUserEmail));
+  CHECK_EQ(device_id, GetDeviceId(AccountId::FromUserEmail(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);
+  const std::string device_id =
+      GetDeviceId(AccountId::FromUserEmail(kFakeUserEmail));
   EXPECT_FALSE(device_id.empty());
 
   SignInOffline(kFakeUserEmail, kFakeUserPassword);
-  CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken2);
+  CheckDeviceIDIsConsistent(AccountId::FromUserEmail(kFakeUserEmail),
+                            kRefreshToken2);
 
   // Verify that device ID remained the same after offline auth.
-  CHECK_EQ(device_id, GetDeviceId(kFakeUserEmail));
+  CHECK_EQ(device_id, GetDeviceId(AccountId::FromUserEmail(kFakeUserEmail)));
 }
 
 // Add the second user.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_PRE_NewUsers) {
   WaitForSigninScreen();
   JS().ExecuteAsync("chrome.send('showAddUser')");
   SignInOnline(kSecondUserEmail, kSecondUserPassword, kSecondUserRefreshToken1,
                kSecondUserGaiaId);
-  CheckDeviceIDIsConsistent(kSecondUserEmail, kSecondUserRefreshToken1);
+  CheckDeviceIDIsConsistent(AccountId::FromUserEmail(kSecondUserEmail),
+                            kSecondUserRefreshToken1);
 }
 
 // Remove the second user.
 IN_PROC_BROWSER_TEST_F(DeviceIDTest, PRE_NewUsers) {
   WaitForSigninScreen();
-  RemoveUser(kSecondUserEmail);
+  RemoveUser(AccountId::FromUserEmail(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());
+  EXPECT_TRUE(GetDeviceId(AccountId::FromUserEmail(kSecondUserEmail)).empty());
   SignInOnline(kSecondUserEmail, kSecondUserPassword, kSecondUserRefreshToken2,
                kSecondUserGaiaId);
-  CheckDeviceIDIsConsistent(kSecondUserEmail, kSecondUserRefreshToken2);
+  CheckDeviceIDIsConsistent(AccountId::FromUserEmail(kSecondUserEmail),
+                            kSecondUserRefreshToken2);
   EXPECT_NE(GetDeviceIdFromGAIA(kSecondUserRefreshToken1),
-            GetDeviceId(kSecondUserEmail));
+            GetDeviceId(AccountId::FromUserEmail(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,
                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));
+                   GetDeviceId(AccountId::FromUserEmail(kFakeUserEmail)));
 
   // Can't use SetKnownUserDeviceId here, because it forbids changing a device
   // ID.
   user_manager::UserManager::Get()->SetKnownUserStringPref(
-      kFakeUserEmail, "device_id", std::string());
+      AccountId::FromUserEmail(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());
+  EXPECT_TRUE(GetDeviceId(AccountId::FromUserEmail(kFakeUserEmail)).empty());
   SignInOffline(kFakeUserEmail, kFakeUserPassword);
-  CheckDeviceIDIsConsistent(kFakeUserEmail, kRefreshToken1);
+  CheckDeviceIDIsConsistent(AccountId::FromUserEmail(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,
                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());
+      AccountId::FromUserEmail(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());
+  EXPECT_TRUE(GetDeviceId(AccountId::FromUserEmail(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());
+  CheckDeviceIDIsConsistent(AccountId::FromUserEmail(kFakeUserEmail),
+                            std::string());
 }
 
 }  // namespace chromeos