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

chrome/browser/ui/ash/launcher/chrome_launcher_controller.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/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller.h"
@@ skipping 49 matching lines @@
 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/favicon/content/content_favicon_driver.h"
+#include "components/user_manager/user_id.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
@@ skipping 228 matching lines @@
 
   // The owning ChromeLauncherController.
   ChromeLauncherController* controller_;
 
   // The notification registrar to track the Profile creations after a user got
   // added to the session (if required).
   content::NotificationRegistrar registrar_;
 
   // Users which were just added to the system, but which profiles were not yet
   // (fully) loaded.
-  std::set<std::string> added_user_ids_waiting_for_profiles_;
+  std::set<user_manager::UserID> added_user_ids_waiting_for_profiles_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerUserSwitchObserverChromeOS);
 };
 
 void ChromeLauncherControllerUserSwitchObserverChromeOS::UserAddedToSession(
     const user_manager::User* active_user) {
   Profile* profile = multi_user_util::GetProfileFromUserID(
-      active_user->email());
+      active_user->GetUserID());
   // If we do not have a profile yet, we postpone forwarding the notification
   // until it is loaded.
   if (!profile)
-    added_user_ids_waiting_for_profiles_.insert(active_user->email());
+    added_user_ids_waiting_for_profiles_.insert(active_user->GetUserID());
   else
     AddUser(profile);
 }
 
 void ChromeLauncherControllerUserSwitchObserverChromeOS::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PROFILE_ADDED &&
       !added_user_ids_waiting_for_profiles_.empty()) {
     // Check if the profile is from a user which was on the waiting list.
     Profile* profile = content::Source<Profile>(source).ptr();
-    std::string user_id = multi_user_util::GetUserIDFromProfile(profile);
-    std::set<std::string>::iterator it = std::find(
+    user_manager::UserID user_id = multi_user_util::GetUserIDFromProfile(profile);
+    std::set<user_manager::UserID>::iterator it = std::find(
         added_user_ids_waiting_for_profiles_.begin(),
         added_user_ids_waiting_for_profiles_.end(),
         user_id);
     if (it != added_user_ids_waiting_for_profiles_.end()) {
       added_user_ids_waiting_for_profiles_.erase(it);
       AddUser(profile->GetOriginalProfile());
     }
   }
 }
 
@@ skipping 738 matching lines @@
 
 ash::ShelfItemDelegate::PerformedAction
 ChromeLauncherController::ActivateWindowOrMinimizeIfActive(
     ui::BaseWindow* window,
     bool allow_minimize) {
   // In separated desktop mode we might have to teleport a window back to the
   // current user.
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() ==
           chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED) {
     aura::Window* native_window = window->GetNativeWindow();
-    const std::string& current_user =
+    const user_manager::UserID& current_user =
         multi_user_util::GetUserIDFromProfile(profile());
     chrome::MultiUserWindowManager* manager =
         chrome::MultiUserWindowManager::GetInstance();
     if (!manager->IsWindowOnDesktopOfUser(native_window, current_user)) {
       ash::MultiProfileUMA::RecordTeleportAction(
           ash::MultiProfileUMA::TELEPORT_WINDOW_RETURN_BY_LAUNCHER);
       manager->ShowWindowForUser(native_window, current_user);
       window->Activate();
       return ash::ShelfItemDelegate::kExistingWindowActivated;
     }
@@ skipping 59 matching lines @@
 
 void ChromeLauncherController::ShelfItemChanged(
     int index,
     const ash::ShelfItem& old_item) {
 }
 
 void ChromeLauncherController::ShelfStatusChanged() {
 }
 
 void ChromeLauncherController::ActiveUserChanged(
-    const std::string& user_email) {
+    const user_manager::UserID& user_id) {
   // Store the order of running applications for the user which gets inactive.
   RememberUnpinnedRunningApplicationOrder();
   // Coming here the default profile is already switched. All profile specific
   // resources get released and the new profile gets attached instead.
   ReleaseProfile();
   // When coming here, the active user has already be changed so that we can
   // set it as active.
   AttachProfile(ProfileManager::GetActiveUserProfile());
   // Update the V1 applications.
-  browser_status_monitor_->ActiveUserChanged(user_email);
+  browser_status_monitor_->ActiveUserChanged(user_id);
   // Switch the running applications to the new user.
-  app_window_controller_->ActiveUserChanged(user_email);
+  app_window_controller_->ActiveUserChanged(user_id);
   // Update the user specific shell properties from the new user profile.
   UpdateAppLaunchersFromPref();
   SetShelfAlignmentFromPrefs();
   SetShelfAutoHideBehaviorFromPrefs();
   SetShelfBehaviorsFromPrefs();
 #if defined(OS_CHROMEOS)
   SetVirtualKeyboardBehaviorFromPrefs();
 #endif  // defined(OS_CHROMEOS)
   // Restore the order of running, but unpinned applications for the activated
   // user.
-  RestoreUnpinnedRunningApplicationOrder(user_email);
+  RestoreUnpinnedRunningApplicationOrder(user_id);
   // Inform the system tray of the change.
   ash::Shell::GetInstance()->system_tray_delegate()->ActiveUserWasChanged();
   // Force on-screen keyboard to reset.
   if (keyboard::IsKeyboardEnabled())
     ash::Shell::GetInstance()->CreateKeyboard();
 }
 
 void ChromeLauncherController::AdditionalUserAddedToSession(Profile* profile) {
   // Switch the running applications to the new user.
   app_window_controller_->AdditionalUserAddedToSession(profile);
@@ skipping 229 matching lines @@
   for (int i = 0; i < model_->item_count(); i++) {
     ash::ShelfItemType type = model_->items()[i].type;
     if (type == ash::TYPE_WINDOWED_APP || type == ash::TYPE_PLATFORM_APP)
       list.push_back(GetAppIDForShelfID(model_->items()[i].id));
   }
   last_used_running_application_order_[
       multi_user_util::GetUserIDFromProfile(profile_)] = list;
 }
 
 void ChromeLauncherController::RestoreUnpinnedRunningApplicationOrder(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   const RunningAppListIdMap::iterator app_id_list =
       last_used_running_application_order_.find(user_id);
   if (app_id_list == last_used_running_application_order_.end())
     return;
 
   // Find the first insertion point for running applications.
   int running_index = model_->FirstRunningAppIndex();
   for (RunningAppListIds::iterator app_id = app_id_list->second.begin();
        app_id != app_id_list->second.end(); ++app_id) {
     ash::ShelfID shelf_id = GetShelfIDForAppID(*app_id);
@@ skipping 32 matching lines @@
   // If running multi user mode with separate desktops, we have to check if the
   // browser is from the active user.
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() !=
           chrome::MultiUserWindowManager::MULTI_PROFILE_MODE_SEPARATED)
     return true;
   return multi_user_util::IsProfileFromActiveUser(browser->profile());
 }
 
 bool ChromeLauncherController::ShelfBoundsChangesProbablyWithUser(
     aura::Window* root_window,
-    const std::string& user_id) const {
+    const user_manager::UserID& user_id) const {
   Profile* other_profile = multi_user_util::GetProfileFromUserID(user_id);
   DCHECK_NE(other_profile, profile_);
 
   // Note: The Auto hide state from preferences is not the same as the actual
   // visibility of the shelf. Depending on all the various states (full screen,
   // no window on desktop, multi user, ..) the shelf could be shown - or not.
   bool currently_shown = ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER ==
       GetShelfAutoHideBehaviorFromPrefs(profile_, root_window);
   bool other_shown = ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER ==
       GetShelfAutoHideBehaviorFromPrefs(other_profile, root_window);
@@ skipping 619 matching lines @@
 void ChromeLauncherController::ReleaseProfile() {
   if (app_sync_ui_state_)
     app_sync_ui_state_->RemoveObserver(this);
 
   extensions::ExtensionRegistry::Get(profile_)->RemoveObserver(this);
 
   PrefServiceSyncable::FromProfile(profile_)->RemoveObserver(this);
 
   pref_change_registrar_.RemoveAll();
 }