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

chrome/browser/profiles/profile_io_data.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 "chrome/browser/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 258 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&crypto::InitializeTPMForChromeOSUser,
                    username_hash, info.token_slot_id));
   } else {
     NOTREACHED() << "TPMTokenInfoGetter reported invalid token.";
   }
 }
 
-void GetTPMInfoForUserOnUIThread(const std::string& username,
+void GetTPMInfoForUserOnUIThread(const user_manager::UserID& user_id,
                                  const std::string& username_hash) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(1) << "Getting TPM info from cryptohome for "
-           << " " << username << " " << username_hash;
+           << " " << user_id.GetUserEmail() << " " << username_hash;
   scoped_ptr<chromeos::TPMTokenInfoGetter> scoped_token_info_getter =
       chromeos::TPMTokenInfoGetter::CreateForUserToken(
-          username,
+          user_id,
           chromeos::DBusThreadManager::Get()->GetCryptohomeClient(),
           base::ThreadTaskRunnerHandle::Get());
   chromeos::TPMTokenInfoGetter* token_info_getter =
       scoped_token_info_getter.get();
 
   // Bind |token_info_getter| to the callback to ensure it does not go away
   // before TPM token info is fetched.
   // TODO(tbarzic, pneubeck): Handle this in a nicer way when this logic is
   //     moved to a separate profile service.
   token_info_getter->Start(
       base::Bind(&DidGetTPMInfoForUserOnUIThread,
                  base::Passed(&scoped_token_info_getter),
                  username_hash));
 }
 
-void StartTPMSlotInitializationOnIOThread(const std::string& username,
+void StartTPMSlotInitializationOnIOThread(const user_manager::UserID& user_id,
                                           const std::string& username_hash) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&GetTPMInfoForUserOnUIThread, username, username_hash));
+      base::Bind(&GetTPMInfoForUserOnUIThread, user_id, username_hash));
 }
 
-void StartNSSInitOnIOThread(const std::string& username,
+void StartNSSInitOnIOThread(const user_manager::UserID& user_id,
                             const std::string& username_hash,
                             const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << "Starting NSS init for " << username
+  DVLOG(1) << "Starting NSS init for " << user_id.GetUserEmail()
            << "  hash:" << username_hash;
 
   // Make sure NSS is initialized for the user.
   crypto::InitializeNSSForChromeOSUser(username_hash, path);
 
   // Check if it's OK to initialize TPM for the user before continuing. This
   // may not be the case if the TPM slot initialization was previously
   // requested for the same user.
   if (!crypto::ShouldInitializeTPMForChromeOSUser(username_hash))
     return;
 
   crypto::WillInitializeTPMForChromeOSUser(username_hash);
 
   if (crypto::IsTPMTokenEnabledForNSS()) {
     if (crypto::IsTPMTokenReady(base::Bind(
-            &StartTPMSlotInitializationOnIOThread, username, username_hash))) {
-      StartTPMSlotInitializationOnIOThread(username, username_hash);
+            &StartTPMSlotInitializationOnIOThread, user_id, username_hash))) {
+      StartTPMSlotInitializationOnIOThread(user_id, username_hash);
     } else {
       DVLOG(1) << "Waiting for tpm ready ...";
     }
   } else {
     crypto::InitializePrivateSoftwareSlotForChromeOSUser(username_hash);
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(USE_NSS_CERTS)
@@ skipping 79 matching lines @@
     // No need to initialize NSS for users with empty username hash:
     // Getters for a user's NSS slots always return NULL slot if the user's
     // username hash is empty, even when the NSS is not initialized for the
     // user.
     if (user && !user->username_hash().empty()) {
       params->username_hash = user->username_hash();
       DCHECK(!params->username_hash.empty());
       BrowserThread::PostTask(BrowserThread::IO,
                               FROM_HERE,
                               base::Bind(&StartNSSInitOnIOThread,
-                                         user->email(),
+                                         user->GetUserID(),
                                          user->username_hash(),
                                          profile->GetPath()));
 
       // Use the device-wide system key slot only if the user is of the same
       // domain as the device is registered to.
       policy::BrowserPolicyConnectorChromeOS* connector =
           g_browser_process->platform_part()
               ->browser_policy_connector_chromeos();
       params->use_system_key_slot =
-          connector->GetUserAffiliation(user->email()) ==
+          connector->GetUserAffiliation(user->GetUserID()) ==
           policy::USER_AFFILIATION_MANAGED;
     }
   }
 #endif
 
   params->profile = profile;
   profile_params_.reset(params.release());
 
   ChromeNetworkDelegate::InitializePrefsOnUIThread(
       &enable_referrers_,
@@ skipping 833 matching lines @@
       new DevToolsNetworkTransactionFactory(
           network_controller_.get(), shared_session),
       shared_session->net_log(), backend));
 }
 
 void ProfileIOData::SetCookieSettingsForTesting(
     CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }