This CL replaces user_manager::UserID with AccountId.

chrome/browser/chromeos/login/existing_user_controller_browsertest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 87 matching lines @@
         content::RunAllPendingInMessageLoop();
         break;
     }
   }
 }
 
 }  // namespace
 
 class ExistingUserControllerTest : public policy::DevicePolicyCrosBrowserTest {
  protected:
-  ExistingUserControllerTest() : mock_login_display_(NULL) {}
+  ExistingUserControllerTest()
+      : mock_login_display_(NULL),

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

in-class member initialization

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

Done.

+        account_id_(AccountId::FromUserEmail(kUsername)) {}
 
   ExistingUserController* existing_user_controller() {
     return ExistingUserController::current_controller();
   }
 
   const ExistingUserController* existing_user_controller() const {
     return ExistingUserController::current_controller();
   }
 
   void SetUpInProcessBrowserTestFixture() override {
@@ skipping 70 matching lines @@
     ListPrefUpdate users_pref(g_browser_process->local_state(),
                               "LoggedInUsers");
     users_pref->AppendIfNotPresent(new base::StringValue(user_id));
   }
 
   // ExistingUserController private member accessors.
   base::OneShotTimer* auto_login_timer() {
     return existing_user_controller()->auto_login_timer_.get();
   }
 
-  const std::string& auto_login_username() const {
-    return existing_user_controller()->public_session_auto_login_username_;
+  const AccountId auto_login_account_id() const {

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

Return AccountId not const AccountId

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

Done.

+    return AccountId::FromUserEmail(
+        existing_user_controller()->public_session_auto_login_username_);
   }
 
   int auto_login_delay() const {
     return existing_user_controller()->public_session_auto_login_delay_;
   }
 
   bool is_login_in_progress() const {
     return existing_user_controller()->is_login_in_progress_;
   }
 
   scoped_ptr<ExistingUserController> existing_user_controller_;
 
   // |mock_login_display_| is owned by the ExistingUserController, which calls
   // CreateLoginDisplay() on the |mock_login_display_host_| to get it.
   MockLoginDisplay* mock_login_display_;
   scoped_ptr<MockLoginDisplayHost> mock_login_display_host_;
 
   // Mock URLFetcher.
   MockURLFetcherFactory<SuccessFetcher> factory_;
 
+  const AccountId account_id_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ExistingUserControllerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerTest, PRE_ExistingUserLogin) {
-  RegisterUser(kUsername);
+  RegisterUser(account_id_.GetUserEmail());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerTest, ExistingUserLogin) {
   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
       .Times(2);
-  UserContext user_context(kUsername);
+  UserContext user_context(account_id_);
   user_context.SetGaiaID(kGaiaID);
   user_context.SetKey(Key(kPassword));
-  user_context.SetUserIDHash(kUsername);
+  user_context.SetUserIDHash(account_id_.GetUserEmail());
   test::UserSessionManagerTestApi session_manager_test_api(
       UserSessionManager::GetInstance());
   session_manager_test_api.InjectStubUserContext(user_context);
   EXPECT_CALL(*mock_login_display_, SetUIEnabled(true))
       .Times(1);
   EXPECT_CALL(*mock_login_display_host_,
               StartWizard(WizardController::kTermsOfServiceScreenName))
       .Times(0);
 
   content::WindowedNotificationObserver profile_prepared_observer(
@@ skipping 27 matching lines @@
 
   ExpectLoginFailure();
 }
 
 void ExistingUserControllerUntrustedTest::SetUpSessionManager() {
   InstallOwnerKey();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerUntrustedTest,
                        ExistingUserLoginForbidden) {
-  UserContext user_context(kUsername);
+  UserContext user_context(account_id_);
   user_context.SetGaiaID(kGaiaID);
   user_context.SetKey(Key(kPassword));
-  user_context.SetUserIDHash(kUsername);
+  user_context.SetUserIDHash(account_id_.GetUserEmail());
   existing_user_controller()->Login(user_context, SigninSpecifics());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerUntrustedTest,
                        NewUserLoginForbidden) {
-  UserContext user_context(kUsername);
+  UserContext user_context(account_id_);
   user_context.SetGaiaID(kGaiaID);
   user_context.SetKey(Key(kPassword));
-  user_context.SetUserIDHash(kUsername);
+  user_context.SetUserIDHash(account_id_.GetUserEmail());
   existing_user_controller()->CompleteLogin(user_context);
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerUntrustedTest,
                        GuestLoginForbidden) {
   existing_user_controller()->Login(
       UserContext(user_manager::USER_TYPE_GUEST, std::string()),
       SigninSpecifics());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerUntrustedTest,
                        SupervisedUserLoginForbidden) {
-  UserContext user_context(kSupervisedUserID);
+  UserContext user_context(AccountId::FromUserEmail(kSupervisedUserID));
   user_context.SetKey(Key(kPassword));
-  user_context.SetUserIDHash(kUsername);
+  user_context.SetUserIDHash(account_id_.GetUserEmail());
   existing_user_controller()->Login(user_context, SigninSpecifics());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerUntrustedTest,
                        SupervisedUserCreationForbidden) {
   MockBaseScreenDelegate mock_base_screen_delegate;
   SupervisedUserCreationScreenHandler supervised_user_creation_screen_handler;
   SupervisedUserCreationScreen supervised_user_creation_screen(
       &mock_base_screen_delegate, &supervised_user_creation_screen_handler);
 
-  supervised_user_creation_screen.AuthenticateManager(kUsername, kPassword);
+  supervised_user_creation_screen.AuthenticateManager(
+      account_id_.GetUserEmail(), kPassword);
 }
 
 MATCHER_P(HasDetails, expected, "") {
   return expected == *content::Details<const std::string>(arg).ptr();
 }
 
 class ExistingUserControllerPublicSessionTest
     : public ExistingUserControllerTest {
  protected:
   ExistingUserControllerPublicSessionTest()
-      : public_session_user_id_(policy::GenerateDeviceLocalAccountUserId(
-            kPublicSessionAccountId,
-            policy::DeviceLocalAccount::TYPE_PUBLIC_SESSION)) {
-  }
+      : public_session_user_id_(
+            AccountId::FromUserEmail(policy::GenerateDeviceLocalAccountUserId(
+                kPublicSessionAccountId,
+                policy::DeviceLocalAccount::TYPE_PUBLIC_SESSION))) {}
 
   void SetUpOnMainThread() override {
     ExistingUserControllerTest::SetUpOnMainThread();
 
     // Wait for the public session user to be created.
     if (!user_manager::UserManager::Get()->IsKnownUser(
             public_session_user_id_)) {
       content::WindowedNotificationObserver(
           chrome::NOTIFICATION_USER_LIST_CHANGED,
           base::Bind(&user_manager::UserManager::IsKnownUser,
                      base::Unretained(user_manager::UserManager::Get()),
                      public_session_user_id_)).Wait();
     }
 
     // Wait for the device local account policy to be installed.
     policy::CloudPolicyStore* store =
         TestingBrowserProcess::GetGlobal()
             ->platform_part()
             ->browser_policy_connector_chromeos()
             ->GetDeviceLocalAccountPolicyService()
-            ->GetBrokerForUser(public_session_user_id_)
+            ->GetBrokerForUser(public_session_user_id_.GetUserEmail())
             ->core()
             ->store();
     if (!store->has_policy()) {
       policy::MockCloudPolicyStoreObserver observer;
 
       base::RunLoop loop;
       store->AddObserver(&observer);
       EXPECT_CALL(observer, OnStoreLoaded(store))
           .Times(1)
           .WillOnce(InvokeWithoutArgs(&loop, &base::RunLoop::Quit));
       loop.Run();
       store->RemoveObserver(&observer);
     }
   }
 
   void SetUpSessionManager() override {
     InstallOwnerKey();
 
     // Setup the device policy.
     em::ChromeDeviceSettingsProto& proto(device_policy()->payload());
     em::DeviceLocalAccountInfoProto* account =
         proto.mutable_device_local_accounts()->add_account();
     account->set_account_id(kPublicSessionAccountId);

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

This is still correct, right? We don't store the admin email in AccountId,
right?

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

AFAIK, this is not admin email. This is local account id (i.e. ID of
kPublicSessionAccountId).

chrome_device_policy.proto says we need to store some unique identifier for each
local account. So this is still valid until we switch to opaque Id there.

     account->set_type(
         em::DeviceLocalAccountInfoProto::ACCOUNT_TYPE_PUBLIC_SESSION);
     RefreshDevicePolicy();
 
     // Setup the device local account policy.
     policy::UserPolicyBuilder device_local_account_policy;
     device_local_account_policy.policy_data().set_username(
         kPublicSessionAccountId);
     device_local_account_policy.policy_data().set_policy_type(
         policy::dm_protocol::kChromePublicAccountPolicyType);
@@ skipping 94 matching lines @@
   void MakeCrosSettingsPermanentlyUntrusted() {
     device_policy()->policy().set_policy_data_signature("bad signature");
     session_manager_client()->set_device_policy(device_policy()->GetBlob());
     session_manager_client()->OnPropertyChangeComplete(true);
 
     base::RunLoop run_loop;
     WaitForPermanentlyUntrustedStatusAndRun(run_loop.QuitClosure());
     run_loop.Run();
   }
 
-  const std::string public_session_user_id_;
+  const AccountId public_session_user_id_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExistingUserControllerPublicSessionTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        ConfigureAutoLoginUsingPolicy) {
   existing_user_controller()->OnSigninScreenReady();
-  EXPECT_EQ("", auto_login_username());
+  EXPECT_TRUE(auto_login_account_id().empty());
   EXPECT_EQ(0, auto_login_delay());
   EXPECT_FALSE(auto_login_timer());
 
   // Set the policy.
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
-  EXPECT_EQ(public_session_user_id_, auto_login_username());
+  EXPECT_EQ(public_session_user_id_, auto_login_account_id());
   EXPECT_EQ(kAutoLoginLongDelay, auto_login_delay());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_TRUE(auto_login_timer()->IsRunning());
 
   // Unset the policy.
   SetAutoLoginPolicy("", 0);
-  EXPECT_EQ("", auto_login_username());
+  EXPECT_TRUE(auto_login_account_id().empty());
   EXPECT_EQ(0, auto_login_delay());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        AutoLoginNoDelay) {
   // Set up mocks to check login success.
   UserContext user_context(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
-                           public_session_user_id_);
-  user_context.SetUserIDHash(user_context.GetUserID());
+                           public_session_user_id_.GetUserEmail());
+  user_context.SetUserIDHash(user_context.GetUserID().GetUserEmail());
   ExpectSuccessfulLogin(user_context);
   existing_user_controller()->OnSigninScreenReady();
 
   // Start auto-login and wait for login tasks to complete.
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginNoDelay);
   content::RunAllPendingInMessageLoop();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        AutoLoginShortDelay) {
   // Set up mocks to check login success.
   UserContext user_context(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
-                           public_session_user_id_);
-  user_context.SetUserIDHash(user_context.GetUserID());
+                           public_session_user_id_.GetUserEmail());
+  user_context.SetUserIDHash(user_context.GetUserID().GetUserEmail());
   ExpectSuccessfulLogin(user_context);
   existing_user_controller()->OnSigninScreenReady();
 
   content::WindowedNotificationObserver profile_prepared_observer(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources());
 
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginShortDelay);
   ASSERT_TRUE(auto_login_timer());
   // Don't assert that timer is running: with the short delay sometimes
@@ skipping 10 matching lines @@
 
   profile_prepared_observer.Wait();
 
   // Wait for login tasks to complete.
   content::RunAllPendingInMessageLoop();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        LoginStopsAutoLogin) {
   // Set up mocks to check login success.
-  UserContext user_context(kUsername);
+  UserContext user_context(account_id_);
   user_context.SetGaiaID(kGaiaID);
   user_context.SetKey(Key(kPassword));
-  user_context.SetUserIDHash(user_context.GetUserID());
+  user_context.SetUserIDHash(user_context.GetUserID().GetUserEmail());
   ExpectSuccessfulLogin(user_context);
 
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
   content::WindowedNotificationObserver profile_prepared_observer(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources());
 
@@ skipping 10 matching lines @@
 
   // Timer should still be stopped after login completes.
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        GuestModeLoginStopsAutoLogin) {
   EXPECT_CALL(*mock_login_display_, SetUIEnabled(false))
       .Times(2);
-  UserContext user_context(kUsername);
+  UserContext user_context(account_id_);
   user_context.SetGaiaID(kGaiaID);
   user_context.SetKey(Key(kPassword));
   test::UserSessionManagerTestApi session_manager_test_api(
       UserSessionManager::GetInstance());
   session_manager_test_api.InjectStubUserContext(user_context);
 
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
   // Login and check that it stopped the timer.
   existing_user_controller()->Login(UserContext(user_manager::USER_TYPE_GUEST,
                                                 std::string()),
                                     SigninSpecifics());
   EXPECT_TRUE(is_login_in_progress());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 
   // Wait for login tasks to complete.
   content::RunAllPendingInMessageLoop();
 
   // Timer should still be stopped after login completes.
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        CompleteLoginStopsAutoLogin) {
   // Set up mocks to check login success.
-  UserContext user_context(kUsername);
+  UserContext user_context(account_id_);
   user_context.SetGaiaID(kGaiaID);
   user_context.SetKey(Key(kPassword));
-  user_context.SetUserIDHash(user_context.GetUserID());
+  user_context.SetUserIDHash(user_context.GetUserID().GetUserEmail());
   ExpectSuccessfulLogin(user_context);
   EXPECT_CALL(*mock_login_display_host_, OnCompleteLogin())
       .Times(1);
 
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
   content::WindowedNotificationObserver profile_prepared_observer(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
@@ skipping 11 matching lines @@
 
   // Timer should still be stopped after login completes.
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        PublicSessionLoginStopsAutoLogin) {
   // Set up mocks to check login success.
   UserContext user_context(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
-                           public_session_user_id_);
-  user_context.SetUserIDHash(user_context.GetUserID());
+                           public_session_user_id_.GetUserEmail());
+  user_context.SetUserIDHash(user_context.GetUserID().GetUserEmail());
   ExpectSuccessfulLogin(user_context);
   existing_user_controller()->OnSigninScreenReady();
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   EXPECT_TRUE(auto_login_timer());
 
   content::WindowedNotificationObserver profile_prepared_observer(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources());
 
   // Login and check that it stopped the timer.
   existing_user_controller()->Login(
       UserContext(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
-                  public_session_user_id_),
+                  public_session_user_id_.GetUserEmail()),
       SigninSpecifics());
 
   EXPECT_TRUE(is_login_in_progress());
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 
   profile_prepared_observer.Wait();
 
   // Wait for login tasks to complete.
   content::RunAllPendingInMessageLoop();
 
   // Timer should still be stopped after login completes.
   ASSERT_TRUE(auto_login_timer());
   EXPECT_FALSE(auto_login_timer()->IsRunning());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        LoginForbiddenWhenUntrusted) {
   // Make cros settings untrusted.
   MakeCrosSettingsPermanentlyUntrusted();
 
   // Check that the attempt to start a public session fails with an error.
   ExpectLoginFailure();
-  UserContext user_context(kUsername);
+  UserContext user_context(account_id_);
   user_context.SetGaiaID(kGaiaID);
   user_context.SetKey(Key(kPassword));
-  user_context.SetUserIDHash(user_context.GetUserID());
+  user_context.SetUserIDHash(user_context.GetUserID().GetUserEmail());
   existing_user_controller()->Login(user_context, SigninSpecifics());
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        NoAutoLoginWhenUntrusted) {
   // Start the public session timer.
   SetAutoLoginPolicy(kPublicSessionAccountId, kAutoLoginLongDelay);
   existing_user_controller()->OnSigninScreenReady();
   EXPECT_TRUE(auto_login_timer());
 
   // Make cros settings untrusted.
   MakeCrosSettingsPermanentlyUntrusted();
 
   // Check that when the timer fires, auto-login fails with an error.
   ExpectLoginFailure();
   FireAutoLogin();
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        PRE_TestLoadingPublicUsersFromLocalState) {
   // First run propagates public accounts and stores them in Local State.
 }
 
 IN_PROC_BROWSER_TEST_F(ExistingUserControllerPublicSessionTest,
                        TestLoadingPublicUsersFromLocalState) {
   // Second run loads list of public accounts from Local State.
 }
 
 }  // namespace chromeos