This CL replaces user_manager::UserID with AccountId.

chrome/browser/chromeos/login/users/multi_profile_user_controller_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 "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h"
@@ skipping 98 matching lines @@
 
 }  // namespace
 
 class MultiProfileUserControllerTest
     : public testing::Test,
       public MultiProfileUserControllerDelegate {
  public:
   MultiProfileUserControllerTest()
       : fake_user_manager_(new FakeChromeUserManager),
         user_manager_enabler_(fake_user_manager_),
-        user_not_allowed_count_(0) {}
+        user_not_allowed_count_(0) {
+    for (size_t i = 0; i < arraysize(kUsers); ++i) {
+      test_users_.push_back(AccountId::FromUserEmail(kUsers[i]));
+    }
+  }
+
   ~MultiProfileUserControllerTest() override {}
 
   void SetUp() override {
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
     ASSERT_TRUE(profile_manager_->SetUp());
     controller_.reset(new MultiProfileUserController(
         this, TestingBrowserProcess::GetGlobal()->local_state()));
 
-    for (size_t i = 0; i < arraysize(kUsers); ++i) {
-      const std::string user_email(kUsers[i]);
-      const user_manager::User* user = fake_user_manager_->AddUser(user_email);
+    for (size_t i = 0; i < test_users_.size(); ++i) {
+      const AccountId account_id(test_users_[i]);
+      const user_manager::User* user =
+          fake_user_manager_->AddUser(test_users_[i]);
 
       // Note that user profiles are created after user login in reality.
       TestingProfile* user_profile =
-          profile_manager_->CreateTestingProfile(user_email);
-      user_profile->set_profile_name(user_email);
+          profile_manager_->CreateTestingProfile(account_id.GetUserEmail());
+      user_profile->set_profile_name(account_id.GetUserEmail());
       user_profiles_.push_back(user_profile);
 
       ProfileHelper::Get()->SetUserToProfileMappingForTesting(user,
                                                               user_profile);
     }
   }
 
   void TearDown() override {
     // Clear our cached pointer to the PolicyCertVerifier.
     g_policy_cert_verifier_for_factory = NULL;
 
     // We must ensure that the PolicyCertVerifier outlives the
     // PolicyCertService so shutdown the profile here. Additionally, we need
     // to run the message loop between freeing the PolicyCertService and
     // freeing the PolicyCertVerifier (see
     // PolicyCertService::OnTrustAnchorsChanged() which is called from
     // PolicyCertService::Shutdown()).
     controller_.reset();
     profile_manager_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void LoginUser(size_t user_index) {
-    ASSERT_LT(user_index, arraysize(kUsers));
-    fake_user_manager_->LoginUser(kUsers[user_index]);
+    ASSERT_LT(user_index, test_users_.size());
+    fake_user_manager_->LoginUser(test_users_[user_index]);
     controller_->StartObserving(user_profiles_[user_index]);
   }
 
   void SetOwner(size_t user_index) {
-    fake_user_manager_->set_owner_email(kUsers[user_index]);
+    fake_user_manager_->set_owner_id(test_users_[user_index]);
   }
 
   PrefService* GetUserPrefs(size_t user_index) {
     return user_profiles_[user_index]->GetPrefs();
   }
 
   void SetPrefBehavior(size_t user_index, const std::string& behavior) {
     GetUserPrefs(user_index)->SetString(prefs::kMultiProfileUserBehavior,
                                         behavior);
   }
 
   std::string GetCachedBehavior(size_t user_index) {
-    return controller_->GetCachedValue(kUsers[user_index]);
+    return controller_->GetCachedValue(test_users_[user_index].GetUserEmail());
   }
 
   void SetCachedBehavior(size_t user_index,
                          const std::string& behavior) {
-    controller_->SetCachedValue(kUsers[user_index], behavior);
+    controller_->SetCachedValue(test_users_[user_index].GetUserEmail(),
+                                behavior);
   }
 
   void ResetCounts() {
     user_not_allowed_count_ = 0;
   }
 
   // MultiProfileUserControllerDeleagte overrides:
   void OnUserNotAllowed(const std::string& user_email) override {
     ++user_not_allowed_count_;
   }
@@ skipping 10 matching lines @@
   scoped_ptr<TestingProfileManager> profile_manager_;
   FakeChromeUserManager* fake_user_manager_;  // Not owned
   ScopedUserManagerEnabler user_manager_enabler_;
 
   scoped_ptr<MultiProfileUserController> controller_;
 
   std::vector<TestingProfile*> user_profiles_;
 
   int user_not_allowed_count_;
 
+  std::vector<AccountId> test_users_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MultiProfileUserControllerTest);
 };
 
 // Tests that everyone is allowed before a session starts.
 TEST_F(MultiProfileUserControllerTest, AllAllowedBeforeLogin) {
   const char* const kTestCases[] = {
     MultiProfileUserController::kBehaviorUnrestricted,
     MultiProfileUserController::kBehaviorPrimaryOnly,
     MultiProfileUserController::kBehaviorNotAllowed,
   };
   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     SetCachedBehavior(0, kTestCases[i]);
     MultiProfileUserController::UserAllowedInSessionReason reason;
-    EXPECT_TRUE(controller()->IsUserAllowedInSession(kUsers[0], &reason))
+    EXPECT_TRUE(controller()->IsUserAllowedInSession(
+        test_users_[0].GetUserEmail(), &reason))
         << "Case " << i;
     EXPECT_EQ(MultiProfileUserController::ALLOWED, reason) << "Case " << i;
     EXPECT_EQ(MultiProfileUserController::ALLOWED,
               MultiProfileUserController::GetPrimaryUserPolicy())
         << "Case " << i;
   }
 }
 
 // Tests that invalid cache value would become the default "unrestricted".
 TEST_F(MultiProfileUserControllerTest, InvalidCacheBecomesDefault) {
@@ skipping 45 matching lines @@
 TEST_F(MultiProfileUserControllerTest, IsSecondaryAllowed) {
   LoginUser(0);
 
   for (size_t i = 0; i < arraysize(kBehaviorTestCases); ++i) {
     SetPrefBehavior(0, kBehaviorTestCases[i].primary);
     SetCachedBehavior(1, kBehaviorTestCases[i].secondary);
     EXPECT_EQ(kBehaviorTestCases[i].expected_primary_policy,
               MultiProfileUserController::GetPrimaryUserPolicy())
         << "Case " << i;
     MultiProfileUserController::UserAllowedInSessionReason reason;
-    controller()->IsUserAllowedInSession(kUsers[1], &reason);
+    controller()->IsUserAllowedInSession(test_users_[1].GetUserEmail(),
+                                         &reason);
     EXPECT_EQ(kBehaviorTestCases[i].expected_secondary_allowed, reason)
         << "Case " << i;
   }
 }
 
 // Tests user behavior changes within a two-user session.
 TEST_F(MultiProfileUserControllerTest, PrimaryBehaviorChange) {
   LoginUser(0);
   LoginUser(1);
 
@@ skipping 13 matching lines @@
                 MultiProfileUserController::ALLOWED)
           << "Case " << i;
     }
   }
 }
 
 TEST_F(MultiProfileUserControllerTest,
        UsedPolicyCertificatesAllowedForPrimary) {
   // Verifies that any user can sign-in as the primary user, regardless of the
   // tainted state.
-  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(kUsers[0]);
+  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(
+      test_users_[0].GetUserEmail());
   MultiProfileUserController::UserAllowedInSessionReason reason;
-  EXPECT_TRUE(controller()->IsUserAllowedInSession(kUsers[0], &reason));
+  EXPECT_TRUE(controller()->IsUserAllowedInSession(
+      test_users_[0].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::ALLOWED, reason);
-  EXPECT_TRUE(controller()->IsUserAllowedInSession(kUsers[1], &reason));
+  EXPECT_TRUE(controller()->IsUserAllowedInSession(
+      test_users_[1].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::ALLOWED, reason);
   EXPECT_EQ(MultiProfileUserController::ALLOWED,
             MultiProfileUserController::GetPrimaryUserPolicy());
 }
 
 TEST_F(MultiProfileUserControllerTest,
        UsedPolicyCertificatesDisallowedForSecondary) {
   // Verifies that if a regular user is signed-in then other regular users can
   // be added but tainted users can't.
   LoginUser(1);
 
   // TODO(xiyuan): Remove the following SetPrefBehavor when default is
   // changed back to enabled.
   SetPrefBehavior(1, MultiProfileUserController::kBehaviorUnrestricted);
 
   MultiProfileUserController::UserAllowedInSessionReason reason;
-  EXPECT_TRUE(controller()->IsUserAllowedInSession(kUsers[0], &reason));
+  EXPECT_TRUE(controller()->IsUserAllowedInSession(
+      test_users_[0].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::ALLOWED, reason);
 
-  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(kUsers[0]);
-  EXPECT_FALSE(controller()->IsUserAllowedInSession(kUsers[0], &reason));
+  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(
+      test_users_[0].GetUserEmail());
+  EXPECT_FALSE(controller()->IsUserAllowedInSession(
+      test_users_[0].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::NOT_ALLOWED_POLICY_CERT_TAINTED,
             reason);
 }
 
 TEST_F(MultiProfileUserControllerTest,
        UsedPolicyCertificatesDisallowsSecondaries) {
   // Verifies that if a tainted user is signed-in then no other users can
   // be added.
-  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(kUsers[0]);
+  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(
+      test_users_[0].GetUserEmail());
   LoginUser(0);
 
   cert_verifier_.reset(new policy::PolicyCertVerifier(base::Closure()));
   g_policy_cert_verifier_for_factory = cert_verifier_.get();
   ASSERT_TRUE(
       policy::PolicyCertServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(0), TestPolicyCertServiceFactory));
 
   MultiProfileUserController::UserAllowedInSessionReason reason;
-  EXPECT_FALSE(controller()->IsUserAllowedInSession(kUsers[1], &reason));
+  EXPECT_FALSE(controller()->IsUserAllowedInSession(
+      test_users_[1].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::NOT_ALLOWED_PRIMARY_POLICY_CERT_TAINTED,
             reason);
   EXPECT_EQ(MultiProfileUserController::NOT_ALLOWED_PRIMARY_POLICY_CERT_TAINTED,
             MultiProfileUserController::GetPrimaryUserPolicy());
-  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(kUsers[1]);
-  EXPECT_FALSE(controller()->IsUserAllowedInSession(kUsers[1], &reason));
+  policy::PolicyCertServiceFactory::SetUsedPolicyCertificates(
+      test_users_[1].GetUserEmail());
+  EXPECT_FALSE(controller()->IsUserAllowedInSession(
+      test_users_[1].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::NOT_ALLOWED_POLICY_CERT_TAINTED,
             reason);
   EXPECT_EQ(MultiProfileUserController::NOT_ALLOWED_PRIMARY_POLICY_CERT_TAINTED,
             MultiProfileUserController::GetPrimaryUserPolicy());
 
   // Flush tasks posted to IO.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MultiProfileUserControllerTest,
@@ skipping 10 matching lines @@
   g_policy_cert_verifier_for_factory = cert_verifier_.get();
   ASSERT_TRUE(
       policy::PolicyCertServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           profile(0), TestPolicyCertServiceFactory));
   policy::PolicyCertService* service =
       policy::PolicyCertServiceFactory::GetForProfile(profile(0));
   ASSERT_TRUE(service);
 
   EXPECT_FALSE(service->has_policy_certificates());
   MultiProfileUserController::UserAllowedInSessionReason reason;
-  EXPECT_TRUE(controller()->IsUserAllowedInSession(kUsers[1], &reason));
+  EXPECT_TRUE(controller()->IsUserAllowedInSession(
+      test_users_[1].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::ALLOWED, reason);
   EXPECT_EQ(MultiProfileUserController::ALLOWED,
             MultiProfileUserController::GetPrimaryUserPolicy());
 
   net::CertificateList certificates;
   certificates.push_back(new net::X509Certificate(
       "subject", "issuer", base::Time(), base::Time()));
   service->OnTrustAnchorsChanged(certificates);
   EXPECT_TRUE(service->has_policy_certificates());
-  EXPECT_FALSE(controller()->IsUserAllowedInSession(kUsers[1], &reason));
+  EXPECT_FALSE(controller()->IsUserAllowedInSession(
+      test_users_[1].GetUserEmail(), &reason));
   EXPECT_EQ(MultiProfileUserController::NOT_ALLOWED_PRIMARY_POLICY_CERT_TAINTED,
             reason);
   EXPECT_EQ(MultiProfileUserController::NOT_ALLOWED_PRIMARY_POLICY_CERT_TAINTED,
             MultiProfileUserController::GetPrimaryUserPolicy());
 
   // Flush tasks posted to IO.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace chromeos