TrayUser::GetTrayIndex method removed as not necessary. Swich->Switch renamed.

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 28 matching lines @@
     ash::Shell::GetInstance()->mru_window_tracker()->SetIgnoreActivations(
         false);
   }
  private:
 
   DISALLOW_COPY_AND_ASSIGN(UserChangeActionDisabler);
 };
 
 }  // namespace
 
-UserSwichAnimatorChromeOS::UserSwichAnimatorChromeOS(
+UserSwitchAnimatorChromeOS::UserSwitchAnimatorChromeOS(
     MultiUserWindowManagerChromeOS* owner,
     const std::string& new_user_id,
     int animation_speed_ms)
     : owner_(owner),
       new_user_id_(new_user_id),
       animation_speed_ms_(animation_speed_ms),
       animation_step_(ANIMATION_STEP_HIDE_OLD_USER),
       screen_cover_(GetScreenCover(NULL)) {
   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(
-            &UserSwichAnimatorChromeOS::AdvanceUserTransitionAnimation,
+            &UserSwitchAnimatorChromeOS::AdvanceUserTransitionAnimation,
             base::Unretained(this)),
         true));
     user_changed_animation_timer_->Reset();
   }
 }
 
-UserSwichAnimatorChromeOS::~UserSwichAnimatorChromeOS() {
+UserSwitchAnimatorChromeOS::~UserSwitchAnimatorChromeOS() {
   FinalizeAnimation();
 }
 
 // static
-bool UserSwichAnimatorChromeOS::CoversScreen(aura::Window* window) {
+bool UserSwitchAnimatorChromeOS::CoversScreen(aura::Window* window) {
   // Full screen covers the screen naturally. Since a normal window can have the
   // same size as the work area, we only compare the bounds against the work
   // area.
   if (ash::wm::GetWindowState(window)->IsFullscreen())
     return true;
   gfx::Rect bounds = window->GetBoundsInRootWindow();
   gfx::Rect work_area = gfx::Screen::GetScreenFor(window)->
       GetDisplayNearestWindow(window).work_area();
   bounds.Intersect(work_area);
   return work_area == bounds;
 }
 
-void UserSwichAnimatorChromeOS::AdvanceUserTransitionAnimation() {
+void UserSwitchAnimatorChromeOS::AdvanceUserTransitionAnimation() {
   DCHECK_NE(animation_step_, ANIMATION_STEP_ENDED);
 
   TransitionWallpaper(animation_step_);
   TransitionUserShelf(animation_step_);
   TransitionWindows(animation_step_);
 
   // Advance to the next step.
   switch (animation_step_) {
     case ANIMATION_STEP_HIDE_OLD_USER:
       animation_step_ = ANIMATION_STEP_SHOW_NEW_USER;
       break;
     case ANIMATION_STEP_SHOW_NEW_USER:
       animation_step_ = ANIMATION_STEP_FINALIZE;
       break;
     case ANIMATION_STEP_FINALIZE:
       user_changed_animation_timer_.reset();
       animation_step_ = ANIMATION_STEP_ENDED;
       break;
     case ANIMATION_STEP_ENDED:
       NOTREACHED();
       break;
   }
 }
 
-void UserSwichAnimatorChromeOS::CancelAnimation() {
+void UserSwitchAnimatorChromeOS::CancelAnimation() {
   animation_step_ = ANIMATION_STEP_ENDED;
 }
 
-void UserSwichAnimatorChromeOS::FinalizeAnimation() {
+void UserSwitchAnimatorChromeOS::FinalizeAnimation() {
   user_changed_animation_timer_.reset();
   while (ANIMATION_STEP_ENDED != animation_step_)
     AdvanceUserTransitionAnimation();
 }
 
-void UserSwichAnimatorChromeOS::TransitionWallpaper(
+void UserSwitchAnimatorChromeOS::TransitionWallpaper(
     AnimationStep animation_step) {
   // Handle the wallpaper switch.
   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(
@@ skipping 10 matching lines @@
     if (screen_cover_ == NEW_USER_COVERS_SCREEN)
       chromeos::WallpaperManager::Get()->SetUserWallpaperNow(new_user_id_);
 
     // Coming here the wallpaper user id is the final result. No matter how we
     // got here.
     wallpaper_user_id_ = new_user_id_;
     wallpaper_delegate->SetAnimationDurationOverride(0);
   }
 }
 
-void UserSwichAnimatorChromeOS::TransitionUserShelf(
+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_);
@@ skipping 47 matching lines @@
     } 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 UserSwichAnimatorChromeOS::TransitionWindows(
+void UserSwitchAnimatorChromeOS::TransitionWindows(
     AnimationStep animation_step) {
   // Disable the window position manager and the MRU window tracker temporarily.
   UserChangeActionDisabler disabler;
 
   if (animation_step == ANIMATION_STEP_HIDE_OLD_USER ||
       (animation_step == ANIMATION_STEP_FINALIZE &&
        screen_cover_ == BOTH_USERS_COVER_SCREEN)) {
     // We need to show/hide the windows in the same order as they were created
     // in their parent window(s) to keep the layer / window hierarchy in sync.
     // To achieve that we first collect all parent windows and then enumerate
@@ skipping 85 matching lines @@
           client->ActivateWindow(window);
       }
     }
 
     // This is called directly here to make sure notification_blocker will see
     // the new window status.
     owner_->notification_blocker()->ActiveUserChanged(new_user_id_);
   }
 }
 
-UserSwichAnimatorChromeOS::TransitioningScreenCover
-UserSwichAnimatorChromeOS::GetScreenCover(aura::Window* root_window) {
+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_) &&
                CoversScreen(window)) {
       if (cover == OLD_USER_COVERS_SCREEN)
         return BOTH_USERS_COVER_SCREEN;
       else
         cover = NEW_USER_COVERS_SCREEN;
     }
   }
   return cover;
 }
 
 }  // namespace chrome