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

chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.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/avatar/user_image_manager_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ skipping 246 matching lines @@
   void OnSaveImageDone(bool success);
 
   // Updates the user image in local state, setting it to one of the
   // default images or the saved |user_image_|, depending on
   // |image_index_|.
   void UpdateLocalState();
 
   // Notifies the |parent_| that the Job is done.
   void NotifyJobDone();
 
-  const std::string& user_id() const { return parent_->user_id(); }
+  const user_manager::UserID& user_id() const { return parent_->user_id(); }
 
   UserImageManagerImpl* parent_;
 
   // Whether one of the Load*() or Set*() methods has been run already.
   bool run_;
 
   int image_index_;
   GURL image_url_;
   base::FilePath image_path_;
 
@@ skipping 148 matching lines @@
         false);
   }
   user->SetImageURL(image_url_);
 
   parent_->OnJobChangedUserImage();
 }
 
 void UserImageManagerImpl::Job::SaveImageAndUpdateLocalState() {
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  image_path_ = user_data_dir.Append(user_id() + kSafeImagePathExtension);
+  image_path_ = user_data_dir.Append(user_id().GetUserEmail() + kSafeImagePathExtension);
 
   base::PostTaskAndReplyWithResult(
       parent_->background_task_runner_.get(),
       FROM_HERE,
       base::Bind(&SaveImage, user_image_, image_path_),
       base::Bind(&Job::OnSaveImageDone, weak_factory_.GetWeakPtr()));
 }
 
 void UserImageManagerImpl::Job::OnSaveImageDone(bool success) {
   if (success || image_index_ == user_manager::User::USER_IMAGE_PROFILE)
     UpdateLocalState();
   NotifyJobDone();
 }
 
 void UserImageManagerImpl::Job::UpdateLocalState() {
   // Ignore if data stored or cached outside the user's cryptohome is to be
   // treated as ephemeral.
   if (parent_->user_manager_->IsUserNonCryptohomeDataEphemeral(user_id()))
     return;
 
   scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
   entry->Set(kImagePathNodeName, new base::StringValue(image_path_.value()));
   entry->Set(kImageIndexNodeName, new base::FundamentalValue(image_index_));
   if (!image_url_.is_empty())
     entry->Set(kImageURLNodeName, new base::StringValue(image_url_.spec()));
   DictionaryPrefUpdate update(g_browser_process->local_state(),
                               kUserImageProperties);
-  update->SetWithoutPathExpansion(user_id(), entry.release());
+  update->SetWithoutPathExpansion(user_id().GetUserEmail(), entry.release());
 
   parent_->user_manager_->NotifyLocalStateChanged();
 }
 
 void UserImageManagerImpl::Job::NotifyJobDone() {
   parent_->OnJobDone();
 }
 
 UserImageManagerImpl::UserImageManagerImpl(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     user_manager::UserManager* user_manager)
     : UserImageManager(user_id),
       user_manager_(user_manager),
       downloading_profile_image_(false),
       profile_image_requested_(false),
       has_managed_image_(false),
       user_needs_migration_(false),
       weak_factory_(this) {
   base::SequencedWorkerPool* blocking_pool =
       content::BrowserThread::GetBlockingPool();
@@ skipping 19 matching lines @@
     return;
   user_manager::User* user = GetUserAndModify();
   bool needs_migration = false;
 
   // If entries are found in both |prefs_images_unsafe| and |prefs_images|,
   // |prefs_images| is honored for now but |prefs_images_unsafe| will be
   // migrated, overwriting the |prefs_images| entry, when the user logs in.
   const base::DictionaryValue* image_properties = NULL;
   if (prefs_images_unsafe) {
     needs_migration = prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
-        user_id(), &image_properties);
+        user_id().GetUserEmail(), &image_properties);
     if (needs_migration)
       user_needs_migration_ = true;
   }
   if (prefs_images) {
-    prefs_images->GetDictionaryWithoutPathExpansion(user_id(),
+    prefs_images->GetDictionaryWithoutPathExpansion(user_id().GetUserEmail(),
                                                     &image_properties);
   }
 
   // If the user image for |user_id| is managed by policy and the policy-set
   // image is being loaded and persisted right now, let that job continue. It
   // will update the user image when done.
   if (IsUserImageManaged() && job_.get())
     return;
 
   if (!image_properties) {
@@ skipping 51 matching lines @@
   } else {
     UMA_HISTOGRAM_ENUMERATION("UserImage.LoggedIn",
                               ImageIndexToHistogramIndex(user->image_index()),
                               user_manager::kHistogramImagesCount);
 
     if (!IsUserImageManaged() && user_needs_migration_) {
       const base::DictionaryValue* prefs_images_unsafe =
           g_browser_process->local_state()->GetDictionary(kUserImages);
       const base::DictionaryValue* image_properties = NULL;
       if (prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
-              user_id(), &image_properties)) {
+              user_id().GetUserEmail(), &image_properties)) {
         std::string image_path;
         image_properties->GetString(kImagePathNodeName, &image_path);
         job_.reset(new Job(this));
         if (!image_path.empty()) {
           VLOG(0) << "Loading old user image, then migrating it.";
           job_->SetToPath(base::FilePath(image_path),
                           user->image_index(),
                           user->image_url(),
                           false);
         } else {
@@ skipping 314 matching lines @@
   profile_image_load_start_time_ = base::TimeTicks::Now();
   profile_downloader_.reset(new ProfileDownloader(this));
   profile_downloader_->Start();
 }
 
 void UserImageManagerImpl::DeleteUserImageAndLocalStateEntry(
     const char* prefs_dict_root) {
   DictionaryPrefUpdate update(g_browser_process->local_state(),
                               prefs_dict_root);
   const base::DictionaryValue* image_properties;
-  if (!update->GetDictionaryWithoutPathExpansion(user_id(), &image_properties))
+  if (!update->GetDictionaryWithoutPathExpansion(user_id().GetUserEmail(), &image_properties))
     return;
 
   std::string image_path;
   image_properties->GetString(kImagePathNodeName, &image_path);
   if (!image_path.empty()) {
     background_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&base::DeleteFile),
                    base::FilePath(image_path),
                    false));
   }
-  update->RemoveWithoutPathExpansion(user_id(), NULL);
+  update->RemoveWithoutPathExpansion(user_id().GetUserEmail(), NULL);
 }
 
 void UserImageManagerImpl::OnJobChangedUserImage() {
   if (GetUser()->is_logged_in())
     TryToInitDownloadedProfileImage();
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
       content::Source<UserImageManagerImpl>(this),
       content::Details<const user_manager::User>(GetUser()));
 }
 
 void UserImageManagerImpl::OnJobDone() {
   if (job_.get())
     base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, job_.release());
   else
     NOTREACHED();
 
   if (!user_needs_migration_)
     return;
   // Migration completed for |user_id|.
   user_needs_migration_ = false;
 
   const base::DictionaryValue* prefs_images_unsafe =
       g_browser_process->local_state()->GetDictionary(kUserImages);
   const base::DictionaryValue* image_properties = NULL;
   if (!prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
-          user_id(), &image_properties)) {
+          user_id().GetUserEmail(), &image_properties)) {
     NOTREACHED();
     return;
   }
 
   int image_index = user_manager::User::USER_IMAGE_INVALID;
   image_properties->GetInteger(kImageIndexNodeName, &image_index);
   UMA_HISTOGRAM_ENUMERATION("UserImage.Migration",
                             ImageIndexToHistogramIndex(image_index),
                             user_manager::kHistogramImagesCount);
 
@@ skipping 14 matching lines @@
                    weak_factory_.GetWeakPtr()));
   } else {
     // If no old image exists, remove |user_id| from the old prefs dictionary.
     UpdateLocalStateAfterMigration();
   }
 }
 
 void UserImageManagerImpl::UpdateLocalStateAfterMigration() {
   DictionaryPrefUpdate update(g_browser_process->local_state(),
                               kUserImages);
-  update->RemoveWithoutPathExpansion(user_id(), NULL);
+  update->RemoveWithoutPathExpansion(user_id().GetUserEmail(), NULL);
 }
 
 void UserImageManagerImpl::TryToCreateImageSyncObserver() {
   const user_manager::User* user = GetUser();
   // If the currently logged-in user's user image is managed, the sync observer
   // must not be started so that the policy-set image does not get synced out.
   if (!user_image_sync_observer_ &&
       user && user->CanSyncImage() &&
       !IsUserImageManaged()) {
     user_image_sync_observer_.reset(new UserImageSyncObserver(user));
   }
 }
 
 const user_manager::User* UserImageManagerImpl::GetUser() const {
   return user_manager_->FindUser(user_id());
 }
 
 user_manager::User* UserImageManagerImpl::GetUserAndModify() const {
   return user_manager_->FindUserAndModify(user_id());
 }
 
 bool UserImageManagerImpl::IsUserLoggedInAndHasGaiaAccount() const {
   const user_manager::User* user = GetUser();
   if (!user)
     return false;
   return user->is_logged_in() && user->HasGaiaAccount();
 }
 
 }  // namespace chromeos