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

chrome/browser/ui/ash/multi_user/multi_user_window_manager_chromeos.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/multi_user/multi_user_window_manager_chromeos.h"
 
 #include "ash/ash_switches.h"
 #include "ash/multi_profile_uma.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_state_delegate.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_notification_blocker_chromeos.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/ash/multi_user/user_switch_animator_chromeos.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "components/user_manager/user_id.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/events/event.h"
 #include "ui/message_center/message_center.h"
@@ skipping 141 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AnimationSetter);
 };
 
 // This class keeps track of all applications which were started for a user.
 // When an app gets created, the window will be tagged for that user. Note
 // that the destruction does not need to be tracked here since the universal
 // window observer will take care of that.
 class AppObserver : public extensions::AppWindowRegistry::Observer {
  public:
-  explicit AppObserver(const std::string& user_id) : user_id_(user_id) {}
+  explicit AppObserver(const user_manager::UserID& user_id) : user_id_(user_id) {}
   ~AppObserver() override {}
 
   // AppWindowRegistry::Observer overrides:
   void OnAppWindowAdded(extensions::AppWindow* app_window) override {
     aura::Window* window = app_window->GetNativeWindow();
     DCHECK(window);
     MultiUserWindowManagerChromeOS::GetInstance()->SetWindowOwner(window,
                                                                   user_id_);
   }
 
  private:
-  std::string user_id_;
+  const user_manager::UserID user_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AppObserver);
 };
 
 MultiUserWindowManagerChromeOS::MultiUserWindowManagerChromeOS(
-    const std::string& current_user_id)
+    const user_manager::UserID& current_user_id)
     : current_user_id_(current_user_id),
+      null_user_id_(std::string(), std::string()),
       notification_blocker_(new MultiUserNotificationBlockerChromeOS(
           message_center::MessageCenter::Get(), current_user_id)),
       suppress_visibility_changes_(false),
       animation_speed_(ANIMATION_SPEED_NORMAL) {
 }
 
 MultiUserWindowManagerChromeOS::~MultiUserWindowManagerChromeOS() {
   // When the MultiUserWindowManager gets destroyed, ash::Shell is mostly gone.
   // As such we should not try to finalize any outstanding user animations.
   // Note that the destruction of the object can be done later.
@@ skipping 44 matching lines @@
                  content::NotificationService::AllSources());
 
   // Add an app window observer & all already running apps.
   Profile* profile = multi_user_util::GetProfileFromUserID(current_user_id_);
   if (profile)
     AddUser(profile);
 }
 
 void MultiUserWindowManagerChromeOS::SetWindowOwner(
     aura::Window* window,
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   // Make sure the window is valid and there was no owner yet.
   DCHECK(window);
   DCHECK(!user_id.empty());
   if (GetWindowOwner(window) == user_id)
     return;
   DCHECK(GetWindowOwner(window).empty());
   window_to_entry_[window] = new WindowEntry(user_id);
 
   // Remember the initial visibility of the window.
   window_to_entry_[window]->set_show(window->IsVisible());
@@ skipping 11 matching lines @@
   // will add the children but not the owner to the transient children map.
   AddTransientOwnerRecursive(window, window);
 
   // Notify entry adding.
   FOR_EACH_OBSERVER(Observer, observers_, OnOwnerEntryAdded(window));
 
   if (!IsWindowOnDesktopOfUser(window, current_user_id_))
     SetWindowVisibility(window, false, 0);
 }
 
-const std::string& MultiUserWindowManagerChromeOS::GetWindowOwner(
+const user_manager::UserID& MultiUserWindowManagerChromeOS::GetWindowOwner(
     aura::Window* window) const {
   WindowToEntryMap::const_iterator it = window_to_entry_.find(window);
   return it != window_to_entry_.end() ? it->second->owner()
-                                      : base::EmptyString();
+                                      : user_manager::EmptyUserID();
 }
 
 void MultiUserWindowManagerChromeOS::ShowWindowForUser(
     aura::Window* window,
-    const std::string& user_id) {
-  std::string previous_owner(GetUserPresentingWindow(window));
+    const user_manager::UserID& user_id) {
+  user_manager::UserID previous_owner(GetUserPresentingWindow(window));
   if (!ShowWindowForUserIntern(window, user_id))
     return;
   // The window switched to a new desktop and we have to switch to that desktop,
   // but only when it was on the visible desktop and the the target is not the
   // visible desktop.
   if (user_id == current_user_id_ || previous_owner != current_user_id_)
     return;
 
   ash::Shell::GetInstance()->session_state_delegate()->SwitchActiveUser(
       user_id);
 }
 
 bool MultiUserWindowManagerChromeOS::AreWindowsSharedAmongUsers() const {
   WindowToEntryMap::const_iterator it = window_to_entry_.begin();
   for (; it != window_to_entry_.end(); ++it) {
     if (it->second->owner() != it->second->show_for_user())
       return true;
   }
   return false;
 }
 
 void MultiUserWindowManagerChromeOS::GetOwnersOfVisibleWindows(
-    std::set<std::string>* user_ids) const {
+    std::set<user_manager::UserID>* user_ids) const {
   for (WindowToEntryMap::const_iterator it = window_to_entry_.begin();
        it != window_to_entry_.end();
        ++it) {
     if (it->first->IsVisible())
       user_ids->insert(it->second->owner());
   }
 }
 
 bool MultiUserWindowManagerChromeOS::IsWindowOnDesktopOfUser(
     aura::Window* window,
-    const std::string& user_id) const {
-  const std::string& presenting_user = GetUserPresentingWindow(window);
+    const user_manager::UserID& user_id) const {
+  const user_manager::UserID& presenting_user = GetUserPresentingWindow(window);
   return presenting_user.empty() || presenting_user == user_id;
 }
 
-const std::string& MultiUserWindowManagerChromeOS::GetUserPresentingWindow(
+const user_manager::UserID& MultiUserWindowManagerChromeOS::GetUserPresentingWindow(
     aura::Window* window) const {
   WindowToEntryMap::const_iterator it = window_to_entry_.find(window);
   // If the window is not owned by anyone it is shown on all desktops and we
   // return the empty string.
   if (it == window_to_entry_.end())
-    return base::EmptyString();
+    return user_manager::EmptyUserID();
+
   // Otherwise we ask the object for its desktop.
   return it->second->show_for_user();
 }
 
 void MultiUserWindowManagerChromeOS::AddUser(content::BrowserContext* context) {
   Profile* profile = Profile::FromBrowserContext(context);
-  const std::string& user_id = multi_user_util::GetUserIDFromProfile(profile);
+  const user_manager::UserID& user_id = multi_user_util::GetUserIDFromProfile(profile);
   if (user_id_to_app_observer_.find(user_id) != user_id_to_app_observer_.end())
     return;
 
   user_id_to_app_observer_[user_id] = new AppObserver(user_id);
   extensions::AppWindowRegistry::Get(profile)
       ->AddObserver(user_id_to_app_observer_[user_id]);
 
   // Account all existing application windows of this user accordingly.
   const extensions::AppWindowRegistry::AppWindowList& app_windows =
       extensions::AppWindowRegistry::Get(profile)->app_windows();
@@ skipping 27 matching lines @@
 
 void MultiUserWindowManagerChromeOS::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void MultiUserWindowManagerChromeOS::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void MultiUserWindowManagerChromeOS::ActiveUserChanged(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   // This needs to be set before the animation starts.
   current_user_id_ = user_id;
 
   // Here to avoid a very nasty race condition, we must destruct any previously
   // created animation before creating a new one. Otherwise, the newly
   // constructed will hide all windows of the old user in the first step of the
   // animation only to be reshown again by the destructor of the old animation.
   animation_.reset();
   animation_.reset(
       new UserSwitchAnimatorChromeOS(
@@ skipping 96 matching lines @@
 
 void MultiUserWindowManagerChromeOS::SetAnimationSpeedForTest(
     MultiUserWindowManagerChromeOS::AnimationSpeed speed) {
   animation_speed_ = speed;
 }
 
 bool MultiUserWindowManagerChromeOS::IsAnimationRunningForTest() {
   return animation_.get() != NULL && !animation_->IsAnimationFinished();
 }
 
-const std::string& MultiUserWindowManagerChromeOS::GetCurrentUserForTest()
+const user_manager::UserID& MultiUserWindowManagerChromeOS::GetCurrentUserForTest()
     const {
   return current_user_id_;
 }
 
 bool MultiUserWindowManagerChromeOS::ShowWindowForUserIntern(
     aura::Window* window,
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   // If there is either no owner, or the owner is the current user, no action
   // is required.
-  const std::string& owner = GetWindowOwner(window);
+  const user_manager::UserID& owner = GetWindowOwner(window);
   if (owner.empty() ||
       (owner == user_id && IsWindowOnDesktopOfUser(window, user_id)))
     return false;
 
   bool minimized = ash::wm::GetWindowState(window)->IsMinimized();
   // Check that we are not trying to transfer ownership of a minimized window.
   if (user_id != owner && minimized)
     return false;
 
   if (minimized) {
@@ skipping 33 matching lines @@
   // Note that in some cases (e.g. unit test) windows might not have a root
   // window.
   if (!visible && window->GetRootWindow()) {
     // Get the system modal container for the window's root window.
     aura::Window* system_modal_container =
         window->GetRootWindow()->GetChildById(
             ash::kShellWindowId_SystemModalContainer);
     if (window->parent() == system_modal_container) {
       // The window is system modal and we need to find the parent which owns
       // it so that we can switch to the desktop accordingly.
-      std::string user_id = GetUserPresentingWindow(window);
+      user_manager::UserID user_id = GetUserPresentingWindow(window);
       if (user_id.empty()) {
         aura::Window* owning_window = GetOwningWindowInTransientChain(window);
         DCHECK(owning_window);
         user_id = GetUserPresentingWindow(owning_window);
         DCHECK(!user_id.empty());
       }
       ash::Shell::GetInstance()->session_state_delegate()->SwitchActiveUser(
           user_id);
       return;
     }
@@ skipping 128 matching lines @@
   DCHECK_EQ(visible, window->IsVisible());
 }
 
 int MultiUserWindowManagerChromeOS::GetAdjustedAnimationTimeInMS(
     int default_time_in_ms) const {
   return animation_speed_ == ANIMATION_SPEED_NORMAL ? default_time_in_ms :
       (animation_speed_ == ANIMATION_SPEED_FAST ? 10 : 0);
 }
 
 }  // namespace chrome