This CL replaces std::string user_id in ash/* with AccountId.

chrome/browser/ui/ash/multi_user/user_switch_animator_chromeos.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/ui/ash/multi_user/user_switch_animator_chromeos.h"
 
 #include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/root_window_controller.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
@@ skipping 84 matching lines @@
   if (itr != window_list->end()) {
     window_list->erase(itr);
     window_list->push_back(active_window);
   }
 }
 
 }  // namespace
 
 UserSwitchAnimatorChromeOS::UserSwitchAnimatorChromeOS(
     MultiUserWindowManagerChromeOS* owner,
-    const std::string& new_user_id,
+    const AccountId& new_account_id,
     int animation_speed_ms)
     : owner_(owner),
-      new_user_id_(new_user_id),
+      new_account_id_(new_account_id),
       animation_speed_ms_(animation_speed_ms),
       animation_step_(ANIMATION_STEP_HIDE_OLD_USER),
       screen_cover_(GetScreenCover(NULL)),
-      windows_by_user_id_() {
+      windows_by_account_id_() {
   BuildUserToWindowsListMap();
   AdvanceUserTransitionAnimation();
 
   if (!animation_speed_ms_) {
     FinalizeAnimation();
   } else {
     user_changed_animation_timer_.reset(new base::Timer(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(animation_speed_ms_),
         base::Bind(
@@ skipping 63 matching lines @@
   ash::UserWallpaperDelegate* wallpaper_delegate =
       ash::Shell::GetInstance()->user_wallpaper_delegate();
   if (animation_step == ANIMATION_STEP_HIDE_OLD_USER) {
     // Set the wallpaper cross dissolve animation duration to our complete
     // animation cycle for a fade in and fade out.
     int duration =
         NO_USER_COVERS_SCREEN == screen_cover_ ? (2 * animation_speed_ms_) : 0;
     wallpaper_delegate->SetAnimationDurationOverride(
         std::max(duration, kMinimalAnimationTimeMS));
     if (screen_cover_ != NEW_USER_COVERS_SCREEN) {
-      chromeos::WallpaperManager::Get()->SetUserWallpaperNow(new_user_id_);
-      wallpaper_user_id_ =
+      chromeos::WallpaperManager::Get()->SetUserWallpaperNow(
+          new_account_id_.GetUserEmail());
+      wallpaper_user_id_for_test_ =
           (NO_USER_COVERS_SCREEN == screen_cover_ ? "->" : "") +
-          new_user_id_;
+          new_account_id_.GetUserEmail();
     }
   } else if (animation_step == ANIMATION_STEP_FINALIZE) {
     // Revert the wallpaper cross dissolve animation duration back to the
     // default.
     if (screen_cover_ == NEW_USER_COVERS_SCREEN)
-      chromeos::WallpaperManager::Get()->SetUserWallpaperNow(new_user_id_);
+      chromeos::WallpaperManager::Get()->SetUserWallpaperNow(
+          new_account_id_.GetUserEmail());
 
     // Coming here the wallpaper user id is the final result. No matter how we
     // got here.
-    wallpaper_user_id_ = new_user_id_;
+    wallpaper_user_id_for_test_ = new_account_id_.GetUserEmail();
     wallpaper_delegate->SetAnimationDurationOverride(0);
   }
 }
 
 void UserSwitchAnimatorChromeOS::TransitionUserShelf(
     AnimationStep animation_step) {
   ChromeLauncherController* chrome_launcher_controller =
       ChromeLauncherController::instance();
   // The shelf animation duration override.
   int duration_override = animation_speed_ms_;
   // Handle the shelf order of items. This is done once the old user is hidden.
   if (animation_step == ANIMATION_STEP_SHOW_NEW_USER) {
     // Some unit tests have no ChromeLauncherController.
     if (chrome_launcher_controller)
-      chrome_launcher_controller->ActiveUserChanged(new_user_id_);
+      chrome_launcher_controller->ActiveUserChanged(
+          new_account_id_.GetUserEmail());
     // Hide the black rectangle on top of each shelf again.
     aura::Window::Windows root_windows = ash::Shell::GetAllRootWindows();
     for (aura::Window::Windows::const_iterator iter = root_windows.begin();
          iter != root_windows.end(); ++iter) {
       ash::ShelfWidget* shelf =
           ash::RootWindowController::ForWindow(*iter)->shelf();
       shelf->HideShelfBehindBlackBar(false, duration_override);
     }
     // We kicked off the shelf animation above and the override can be
     // removed.
@@ skipping 23 matching lines @@
        iter != root_windows.end(); ++iter) {
     // Hiding the shelf will cause a resize on a maximized window.
     // If the shelf is then shown for the following user in the same location,
     // the window gets resized again. Since each resize can cause a considerable
     // CPU usage and therefore effect jank, we should avoid hiding the shelf if
     // the start and end location are the same and cover the shelf instead with
     // a black rectangle on top.
     if (GetScreenCover(*iter) != NO_USER_COVERS_SCREEN &&
         (!chrome_launcher_controller ||
          !chrome_launcher_controller->ShelfBoundsChangesProbablyWithUser(
-             *iter, new_user_id_))) {
+             *iter, new_account_id_.GetUserEmail()))) {
       ash::ShelfWidget* shelf =
           ash::RootWindowController::ForWindow(*iter)->shelf();
       shelf->HideShelfBehindBlackBar(true, duration_override);
     } else {
       // This shelf change is only part of the animation and will be updated by
       // ChromeLauncherController::ActiveUserChanged() to the new users value.
       // Note that the user preference will not be changed.
       ash::Shell::GetInstance()->SetShelfAutoHideBehavior(
           ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN, *iter);
     }
   }
 }
 
 void UserSwitchAnimatorChromeOS::TransitionWindows(
     AnimationStep animation_step) {
   // Disable the window position manager and the MRU window tracker temporarily.
   UserChangeActionDisabler disabler;
 
   // Animation duration.
   int duration = std::max(kMinimalAnimationTimeMS, 2 * animation_speed_ms_);
 
   switch (animation_step) {
     case ANIMATION_STEP_HIDE_OLD_USER: {
       // Hide the old users.
-      for (auto& user_pair : windows_by_user_id_) {
-        auto& show_for_user_id = user_pair.first;
-        if (show_for_user_id == new_user_id_)
+      for (auto& user_pair : windows_by_account_id_) {
+        auto& show_for_account_id = user_pair.first;
+        if (show_for_account_id == new_account_id_)
           continue;
 
         bool found_foreground_maximized_window = false;
 
         // We hide the windows such that the MRU window is the last one to be
         // hidden, at which point all other windows have already been hidden,
         // and hence the FocusController will not be able to find a next
         // activateable window to restore focus to, and so we don't change
         // window order (crbug.com/424307).
         PutMruWindowLast(&(user_pair.second));
         for (auto& window : user_pair.second) {
           auto window_state = ash::wm::GetWindowState(window);
 
           // Minimized visiting windows (minimized windows with an owner
-          // different than that of the for_show_user_id) should retrun to their
+          // different than that of the for_show_account_id) should retrun to
+          // their
           // original owners' desktops.
           MultiUserWindowManagerChromeOS::WindowToEntryMap::const_iterator itr =
               owner_->window_to_entry().find(window);
           DCHECK(itr != owner_->window_to_entry().end());
-          if (show_for_user_id != itr->second->owner() &&
+          if (show_for_account_id != itr->second->owner() &&
               window_state->IsMinimized()) {
             owner_->ShowWindowForUserIntern(window, itr->second->owner());
             window_state->Unminimize();
             continue;
           }
 
           if (!found_foreground_maximized_window && CoversScreen(window) &&
               screen_cover_ == BOTH_USERS_COVER_SCREEN) {
             // Maximized windows should be hidden, but visually kept visible
             // in order to prevent showing the background while the animation is
             // in progress. Therefore we detach the old layer and recreate fresh
             // ones. The old layers will be destructed at the animation step
             // |ANIMATION_STEP_FINALIZE|.
             // old_layers_.push_back(wm::RecreateLayers(window));
             // We only want to do this for the first (foreground) maximized
             // window we encounter.
             found_foreground_maximized_window = true;
             ui::LayerTreeOwner* old_layer =
                 wm::RecreateLayers(window).release();
             window->layer()->parent()->StackAtBottom(old_layer->root());
             new MaximizedWindowAnimationWatcher(window->layer()->GetAnimator(),
                                                 old_layer);
           }
 
           owner_->SetWindowVisibility(window, false, duration);
         }
       }
 
       // Show new user.
-      auto new_user_itr = windows_by_user_id_.find(new_user_id_);
-      if (new_user_itr == windows_by_user_id_.end())
+      auto new_user_itr = windows_by_account_id_.find(new_account_id_);
+      if (new_user_itr == windows_by_account_id_.end())
         return;
 
       for (auto& window : new_user_itr->second) {
         auto entry = owner_->window_to_entry().find(window);
         DCHECK(entry != owner_->window_to_entry().end());
 
         if (entry->second->show())
           owner_->SetWindowVisibility(window, true, duration);
       }
 
       break;
     }
     case ANIMATION_STEP_SHOW_NEW_USER: {
       // In order to make the animation look better, we had to move the code
       // that shows the new user to the previous step. Hence, we do nothing
       // here.
       break;
     }
     case ANIMATION_STEP_FINALIZE: {
       // Reactivate the MRU window of the new user.
       ash::MruWindowTracker::WindowList mru_list =
           ash::Shell::GetInstance()->mru_window_tracker()->BuildMruWindowList();
       if (!mru_list.empty()) {
         aura::Window* window = mru_list[0];
         ash::wm::WindowState* window_state = ash::wm::GetWindowState(window);
-        if (owner_->IsWindowOnDesktopOfUser(window, new_user_id_) &&
+        if (owner_->IsWindowOnDesktopOfUser(window, new_account_id_) &&
             !window_state->IsMinimized()) {
           // Several unit tests come here without an activation client.
           aura::client::ActivationClient* client =
               aura::client::GetActivationClient(window->GetRootWindow());
           if (client)
             client->ActivateWindow(window);
         }
       } else {
         // If the new user has no windows at all in his MRU windows list, we
         // must deactivate any active window (by setting the active window to
         // |nullptr|).
         aura::Window* root_window = ash::Shell::GetPrimaryRootWindow();
         aura::client::ActivationClient* client =
             aura::client::GetActivationClient(root_window);
         if (client)
           client->ActivateWindow(nullptr);
       }
 
-      owner_->notification_blocker()->ActiveUserChanged(new_user_id_);
+      owner_->notification_blocker()->ActiveUserChanged(new_account_id_);
       break;
     }
     case ANIMATION_STEP_ENDED:
       NOTREACHED();
       break;
   }
 }
 
 UserSwitchAnimatorChromeOS::TransitioningScreenCover
 UserSwitchAnimatorChromeOS::GetScreenCover(aura::Window* root_window) {
   TransitioningScreenCover cover = NO_USER_COVERS_SCREEN;
   for (MultiUserWindowManagerChromeOS::WindowToEntryMap::const_iterator it_map =
            owner_->window_to_entry().begin();
        it_map != owner_->window_to_entry().end();
        ++it_map) {
     aura::Window* window = it_map->first;
     if (root_window && window->GetRootWindow() != root_window)
       continue;
     if (window->IsVisible() && CoversScreen(window)) {
       if (cover == NEW_USER_COVERS_SCREEN)
         return BOTH_USERS_COVER_SCREEN;
       else
         cover = OLD_USER_COVERS_SCREEN;
-    } else if (owner_->IsWindowOnDesktopOfUser(window, new_user_id_) &&
+    } else if (owner_->IsWindowOnDesktopOfUser(window, new_account_id_) &&
                CoversScreen(window)) {
       if (cover == OLD_USER_COVERS_SCREEN)
         return BOTH_USERS_COVER_SCREEN;
       else
         cover = NEW_USER_COVERS_SCREEN;
     }
   }
   return cover;
 }
 
 void UserSwitchAnimatorChromeOS::BuildUserToWindowsListMap() {
   // This is to be called only at the time this animation is constructed.
-  DCHECK(windows_by_user_id_.empty());
+  DCHECK(windows_by_account_id_.empty());
 
   // For each unique parent window, we enumerate its children windows, and
   // for each child if it's in the |window_to_entry()| map, we add it to the
-  // |windows_by_user_id_| map.
+  // |windows_by_account_id_| map.
   // This gives us a list of windows per each user that is in the same order
   // they were created in their parent windows.
   std::set<aura::Window*> parent_windows;
   auto& window_to_entry_map = owner_->window_to_entry();
   for (auto& window_entry_pair : window_to_entry_map) {
     aura::Window* parent_window = window_entry_pair.first->parent();
     if (parent_windows.find(parent_window) == parent_windows.end()) {
       parent_windows.insert(parent_window);
       for (auto& child_window : parent_window->children()) {
         auto itr = window_to_entry_map.find(child_window);
         if (itr != window_to_entry_map.end()) {
-          windows_by_user_id_[itr->second->show_for_user()].push_back(
+          windows_by_account_id_[itr->second->show_for_user()].push_back(
               child_window);
         }
       }
     }
   }
 }
 
 }  // namespace chrome