This CL replaces user_manager::UserID with AccountId.

chrome/browser/chromeos/policy/cloud_external_data_policy_observer_unittest.cc

 // Copyright 2013 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/policy/cloud_external_data_policy_observer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
@@ skipping 105 matching lines @@
   void SetDeviceLocalAccountAvatarPolicy(const std::string& account_id,
                                          const std::string& value);
 
   void AddDeviceLocalAccount(const std::string& account_id);
   void RemoveDeviceLocalAccount(const std::string& account_id);
 
   DeviceLocalAccountPolicyBroker* GetBrokerForDeviceLocalAccountUser();
 
   void RefreshDeviceLocalAccountPolicy(DeviceLocalAccountPolicyBroker* broker);
 
-  void LogInAsDeviceLocalAccount(const std::string& user_id);
+  void LogInAsDeviceLocalAccount(const AccountId& account_id);
 
   void SetRegularUserAvatarPolicy(const std::string& value);
 
   void LogInAsRegularUser();
 
   const std::string device_local_account_user_id_;
 
   std::string avatar_policy_1_data_;
   std::string avatar_policy_2_data_;
   std::string avatar_policy_1_;
@@ skipping 176 matching lines @@
       device_local_account_user_id_);
 }
 
 void CloudExternalDataPolicyObserverTest::RefreshDeviceLocalAccountPolicy(
     DeviceLocalAccountPolicyBroker* broker) {
   broker->core()->store()->Load();
   device_settings_test_helper_.Flush();
 }
 
 void CloudExternalDataPolicyObserverTest::LogInAsDeviceLocalAccount(
-    const std::string& user_id) {
-  user_manager_->AddUser(user_id);
+    const AccountId& account_id) {
+  user_manager_->AddUser(account_id);
 
   device_local_account_policy_provider_.reset(
       new DeviceLocalAccountPolicyProvider(
-          user_id,
-          device_local_account_policy_service_.get(),
+          account_id.GetUserEmail(), device_local_account_policy_service_.get(),
           scoped_ptr<PolicyMap>()));
 
   PolicyServiceImpl::Providers providers;
   providers.push_back(device_local_account_policy_provider_.get());
   TestingProfile::Builder builder;
   builder.SetPolicyService(
       scoped_ptr<PolicyService>(new PolicyServiceImpl(providers)));
   builder.SetPath(chromeos::ProfileHelper::Get()->GetProfilePathByUserIdHash(
-      chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(user_id)));
+      chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
+          account_id.GetUserEmail())));
 
   profile_ = builder.Build();
-  profile_->set_profile_name(user_id);
+  profile_->set_profile_name(account_id.GetUserEmail());
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
       content::Details<Profile>(profile_.get()));
 }
 
 void CloudExternalDataPolicyObserverTest::SetRegularUserAvatarPolicy(
     const std::string& value) {
   PolicyMap policy_map;
   if (!value.empty()) {
     policy_map.Set(
         key::kUserAvatarImage,
         POLICY_LEVEL_MANDATORY,
         POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD,
         new base::StringValue(value),
         external_data_manager_.CreateExternalDataFetcher(
             key::kUserAvatarImage).release());
   }
   user_policy_provider_.UpdateChromePolicy(policy_map);
 }
 
 void CloudExternalDataPolicyObserverTest::LogInAsRegularUser() {
-  user_manager_->AddUser(kRegularUserID);
+  user_manager_->AddUser(AccountId::FromUserEmail(kRegularUserID));
 
   PolicyServiceImpl::Providers providers;
   providers.push_back(&user_policy_provider_);
   TestingProfile::Builder builder;
   builder.SetPolicyService(
       scoped_ptr<PolicyService>(new PolicyServiceImpl(providers)));
   builder.SetPath(chromeos::ProfileHelper::Get()->GetProfilePathByUserIdHash(
       chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
           kRegularUserID)));
 
@@ skipping 277 matching lines @@
        ExistingDeviceLocalAccountSetAfterLogin) {
   AddDeviceLocalAccount(kDeviceLocalAccount);
 
   DeviceLocalAccountPolicyBroker* broker = GetBrokerForDeviceLocalAccountUser();
   ASSERT_TRUE(broker);
   broker->external_data_manager()->Connect(NULL);
   base::RunLoop().RunUntilIdle();
 
   CreateObserver();
 
-  LogInAsDeviceLocalAccount(kDeviceLocalAccount);
+  LogInAsDeviceLocalAccount(AccountId::FromUserEmail(kDeviceLocalAccount));
 
   EXPECT_TRUE(set_calls_.empty());
   EXPECT_TRUE(cleared_calls_.empty());
   EXPECT_TRUE(fetched_calls_.empty());
   ClearObservations();
 
   SetDeviceLocalAccountAvatarPolicy(kDeviceLocalAccount, avatar_policy_1_);
   RefreshDeviceLocalAccountPolicy(broker);
 
   EXPECT_TRUE(cleared_calls_.empty());
@@ skipping 275 matching lines @@
 
   EXPECT_TRUE(set_calls_.empty());
   EXPECT_TRUE(cleared_calls_.empty());
   ASSERT_EQ(1u, fetched_calls_.size());
   EXPECT_EQ(kRegularUserID, fetched_calls_.front().first);
   EXPECT_EQ(avatar_policy_2_data_, fetched_calls_.front().second);
   ClearObservations();
 }
 
 }  // namespace policy