This CL replaces user_manager::UserID with AccountId.

chrome/browser/chromeos/login/users/user_manager_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 <cstdlib>
 #include <cstring>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 29 matching lines @@
   Profile* CreateProfileHelper(const base::FilePath& file_path) override {
     if (!base::PathExists(file_path)) {
       if (!base::CreateDirectory(file_path))
         return NULL;
     }
     return new TestingProfile(file_path, NULL);
   }
 };
 
 class UserManagerTest : public testing::Test {
+ public:
+  UserManagerTest()
+      : owner_at_invalid_domain_(

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

in class member initialization

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

Done.

+            AccountId::FromUserEmail("owner@invalid.domain")),
+        user0_at_invalid_domain_(
+            AccountId::FromUserEmail("user0@invalid.domain")),
+        user1_at_invalid_domain_(
+            AccountId::FromUserEmail("user1@invalid.domain")) {}
+
  protected:
   void SetUp() override {
     base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
     command_line.AppendSwitch(::switches::kTestType);
     command_line.AppendSwitch(
         chromeos::switches::kIgnoreUserProfileMappingForTests);
 
     settings_helper_.ReplaceProvider(kDeviceOwner);
 
     // Populate the stub DeviceSettingsProvider with valid values.
@@ skipping 32 matching lines @@
   }
 
   bool GetUserManagerEphemeralUsersEnabled() const {
     return GetChromeUserManager()->GetEphemeralUsersEnabled();
   }
 
   void SetUserManagerEphemeralUsersEnabled(bool ephemeral_users_enabled) {
     GetChromeUserManager()->SetEphemeralUsersEnabled(ephemeral_users_enabled);
   }
 
-  const std::string& GetUserManagerOwnerEmail() const {
-    return GetChromeUserManager()->GetOwnerEmail();
+  const AccountId GetUserManagerOwnerId() const {

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

Don't need const return type

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

Done.

+    return GetChromeUserManager()->GetOwnerId();
   }
 
-  void SetUserManagerOwnerEmail(const std::string& owner_email) {
-    GetChromeUserManager()->SetOwnerEmail(owner_email);
+  void SetUserManagerOwnerId(const AccountId& owner_id) {

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

owner_account_id

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

Done.

+    GetChromeUserManager()->SetOwnerId(owner_id);
   }
 
   void ResetUserManager() {
     // Reset the UserManager singleton.
     user_manager_enabler_.reset();
     // Initialize the UserManager singleton to a fresh ChromeUserManagerImpl
     // instance.
     user_manager_enabler_.reset(
         new ScopedUserManagerEnabler(new ChromeUserManagerImpl));
 
     // ChromeUserManagerImpl ctor posts a task to reload policies.
     base::RunLoop().RunUntilIdle();
   }
 
   void SetDeviceSettings(bool ephemeral_users_enabled,
                          const std::string &owner,
                          bool supervised_users_enabled) {
     settings_helper_.SetBoolean(kAccountsPrefEphemeralUsersEnabled,
                                 ephemeral_users_enabled);
     settings_helper_.SetString(kDeviceOwner, owner);
     settings_helper_.SetBoolean(kAccountsPrefSupervisedUsersEnabled,
                                 supervised_users_enabled);
   }
 
   void RetrieveTrustedDevicePolicies() {
     GetChromeUserManager()->RetrieveTrustedDevicePolicies();
   }
 
+  const AccountId owner_at_invalid_domain_;
+  const AccountId user0_at_invalid_domain_;
+  const AccountId user1_at_invalid_domain_;
+
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
 
   ScopedCrosSettingsTestHelper settings_helper_;
   scoped_ptr<ScopedTestingLocalState> local_state_;
 
   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
   base::ScopedTempDir temp_dir_;
 };
 
 TEST_F(UserManagerTest, RetrieveTrustedDevicePolicies) {
   SetUserManagerEphemeralUsersEnabled(true);
-  SetUserManagerOwnerEmail("");
+  SetUserManagerOwnerId(EmptyAccountId());
 
-  SetDeviceSettings(false, "owner@invalid.domain", false);
+  SetDeviceSettings(false, owner_at_invalid_domain_.GetUserEmail(), false);
   RetrieveTrustedDevicePolicies();
 
   EXPECT_FALSE(GetUserManagerEphemeralUsersEnabled());
-  EXPECT_EQ(GetUserManagerOwnerEmail(), "owner@invalid.domain");
+  EXPECT_EQ(GetUserManagerOwnerId(), owner_at_invalid_domain_);
 }
 
 TEST_F(UserManagerTest, RemoveAllExceptOwnerFromList) {
   user_manager::UserManager::Get()->UserLoggedIn(
-      "owner@invalid.domain", "owner@invalid.domain", false);
+      owner_at_invalid_domain_, owner_at_invalid_domain_.GetUserEmail(), false);
   ResetUserManager();
   user_manager::UserManager::Get()->UserLoggedIn(
-      "user0@invalid.domain", "owner@invalid.domain", false);
+      user0_at_invalid_domain_, owner_at_invalid_domain_.GetUserEmail(), false);
   ResetUserManager();
   user_manager::UserManager::Get()->UserLoggedIn(
-      "user1@invalid.domain", "owner@invalid.domain", false);
+      user1_at_invalid_domain_, owner_at_invalid_domain_.GetUserEmail(), false);
   ResetUserManager();
 
   const user_manager::UserList* users =
       &user_manager::UserManager::Get()->GetUsers();
   ASSERT_EQ(3U, users->size());
-  EXPECT_EQ((*users)[0]->email(), "user1@invalid.domain");
-  EXPECT_EQ((*users)[1]->email(), "user0@invalid.domain");
-  EXPECT_EQ((*users)[2]->email(), "owner@invalid.domain");
+  EXPECT_EQ((*users)[0]->GetUserID(), user1_at_invalid_domain_);
+  EXPECT_EQ((*users)[1]->GetUserID(), user0_at_invalid_domain_);
+  EXPECT_EQ((*users)[2]->GetUserID(), owner_at_invalid_domain_);
 
-  SetDeviceSettings(true, "owner@invalid.domain", false);
+  SetDeviceSettings(true, owner_at_invalid_domain_.GetUserEmail(), false);
   RetrieveTrustedDevicePolicies();
 
   users = &user_manager::UserManager::Get()->GetUsers();
   EXPECT_EQ(1U, users->size());
-  EXPECT_EQ((*users)[0]->email(), "owner@invalid.domain");
+  EXPECT_EQ((*users)[0]->GetUserID(), owner_at_invalid_domain_);
 }
 
 TEST_F(UserManagerTest, RegularUserLoggedInAsEphemeral) {
-  SetDeviceSettings(true, "owner@invalid.domain", false);
+  SetDeviceSettings(true, owner_at_invalid_domain_.GetUserEmail(), false);
   RetrieveTrustedDevicePolicies();
 
   user_manager::UserManager::Get()->UserLoggedIn(
-      "owner@invalid.domain", "user0@invalid.domain", false);
+      owner_at_invalid_domain_, user0_at_invalid_domain_.GetUserEmail(), false);
   ResetUserManager();
   user_manager::UserManager::Get()->UserLoggedIn(
-      "user0@invalid.domain", "user0@invalid.domain", false);
+      user0_at_invalid_domain_, user0_at_invalid_domain_.GetUserEmail(), false);
   ResetUserManager();
 
   const user_manager::UserList* users =
       &user_manager::UserManager::Get()->GetUsers();
   EXPECT_EQ(1U, users->size());
-  EXPECT_EQ((*users)[0]->email(), "owner@invalid.domain");
+  EXPECT_EQ((*users)[0]->GetUserID(), owner_at_invalid_domain_);
 }
 
 }  // namespace chromeos