We should use UserID object to identify users instead of username.

chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.cc

 // Copyright (c) 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/user_cloud_policy_manager_factory_chromeos.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 118 matching lines @@
   const user_manager::User* user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
   CHECK(user);
 
   // User policy exists for enterprise accounts only:
   // - For regular enterprise users (those who have a GAIA account), a
   //   |UserCloudPolicyManagerChromeOS| is created here.
   // - For device-local accounts, policy is provided by
   //   |DeviceLocalAccountPolicyService|.
   // All other user types do not have user policy.
-  const std::string& username = user->email();
+  const user_manager::UserID& user_id = user->GetUserID();
   if (!user->HasGaiaAccount() ||
       user->IsSupervised() ||
-      BrowserPolicyConnector::IsNonEnterpriseUser(username)) {
+      BrowserPolicyConnector::IsNonEnterpriseUser(user_id)) {
     return scoped_ptr<UserCloudPolicyManagerChromeOS>();
   }
 
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
-  UserAffiliation affiliation = connector->GetUserAffiliation(username);
+  UserAffiliation affiliation = connector->GetUserAffiliation(user_id);
   const bool is_affiliated_user = affiliation == USER_AFFILIATION_MANAGED;
   const bool is_browser_restart =
       command_line->HasSwitch(chromeos::switches::kLoginUser);
   const bool wait_for_initial_policy =
       !is_browser_restart &&
       (user_manager::UserManager::Get()->IsCurrentUserNew() ||
        is_affiliated_user);
 
   const base::TimeDelta initial_policy_fetch_timeout =
       user_manager::UserManager::Get()->IsCurrentUserNew()
@@ skipping 14 matching lines @@
   const base::FilePath external_data_dir =
         profile_dir.Append(kPolicy).Append(kPolicyExternalDataDir);
   base::FilePath policy_key_dir;
   CHECK(PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &policy_key_dir));
 
   scoped_ptr<UserCloudPolicyStoreChromeOS> store(
       new UserCloudPolicyStoreChromeOS(
           chromeos::DBusThreadManager::Get()->GetCryptohomeClient(),
           chromeos::DBusThreadManager::Get()->GetSessionManagerClient(),
           background_task_runner,
-          username, policy_key_dir, token_cache_file, policy_cache_file));
+          user_id, policy_key_dir, token_cache_file, policy_cache_file));
 
   scoped_refptr<base::SequencedTaskRunner> backend_task_runner =
       content::BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
           content::BrowserThread::GetBlockingPool()->GetSequenceToken());
   scoped_refptr<base::SequencedTaskRunner> io_task_runner =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO);
   scoped_ptr<CloudExternalDataManager> external_data_manager(
       new UserCloudExternalDataManager(base::Bind(&GetChromePolicyDetails),
                                        backend_task_runner,
                                        io_task_runner,
                                        external_data_dir,
                                        store.get()));
   if (force_immediate_load)
     store->LoadImmediately();
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::FILE);
 
   scoped_ptr<UserCloudPolicyManagerChromeOS> manager(
       new UserCloudPolicyManagerChromeOS(
           store.Pass(), external_data_manager.Pass(),
           component_policy_cache_dir, wait_for_initial_policy,
           initial_policy_fetch_timeout, base::ThreadTaskRunnerHandle::Get(),
           file_task_runner, io_task_runner));
 
   bool wildcard_match = false;
   if (connector->IsEnterpriseManaged() &&
-      chromeos::CrosSettings::IsWhitelisted(username, &wildcard_match) &&
-      wildcard_match && !connector->IsNonEnterpriseUser(username)) {
-    manager->EnableWildcardLoginCheck(username);
+      chromeos::CrosSettings::IsWhitelisted(user_id, &wildcard_match) &&
+      wildcard_match && !connector->IsNonEnterpriseUser(user_id)) {
+    manager->EnableWildcardLoginCheck(user_id);
   }
 
   manager->Init(
       SchemaRegistryServiceFactory::GetForContext(profile)->registry());
   manager->Connect(g_browser_process->local_state(),
                    device_management_service,
                    g_browser_process->system_request_context(),
                    affiliation);
 
   DCHECK(managers_.find(profile) == managers_.end());
@@ skipping 23 matching lines @@
 
 bool UserCloudPolicyManagerFactoryChromeOS::HasTestingFactory(
     content::BrowserContext* context) {
   return false;
 }
 
 void UserCloudPolicyManagerFactoryChromeOS::CreateServiceNow(
     content::BrowserContext* context) {}
 
 }  // namespace policy