Rename SessionStateController -> LockStateController

ash/wm/lock_state_controller_impl2.cc

 // Copyright (c) 2012 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 "ash/wm/session_state_controller_impl2.h"
+#include "ash/wm/lock_state_controller_impl2.h"
 
 #include "ash/ash_switches.h"
 #include "ash/cancel_mode.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/session_state_animator.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/timer.h"
@@ skipping 112 matching lines @@
   // Number of sequences either ended or aborted.
   int sequences_completed_;
 
   bool paused_;
 
   DISALLOW_COPY_AND_ASSIGN(AnimationFinishedObserver);
 };
 
 } // namespace
 
-SessionStateControllerImpl2::TestApi::TestApi(
-    SessionStateControllerImpl2* controller)
+LockStateControllerImpl2::TestApi::TestApi(
+    LockStateControllerImpl2* controller)
     : controller_(controller) {
 }
 
-SessionStateControllerImpl2::TestApi::~TestApi() {
+LockStateControllerImpl2::TestApi::~TestApi() {
 }
 
-SessionStateControllerImpl2::SessionStateControllerImpl2()
+LockStateControllerImpl2::LockStateControllerImpl2()
     : login_status_(user::LOGGED_IN_NONE),
       system_is_locked_(false),
       shutting_down_(false),
       shutdown_after_lock_(false),
       animating_lock_(false),
       can_cancel_lock_animation_(false) {
   Shell::GetPrimaryRootWindow()->AddRootWindowObserver(this);
 }
 
-SessionStateControllerImpl2::~SessionStateControllerImpl2() {
+LockStateControllerImpl2::~LockStateControllerImpl2() {
   Shell::GetPrimaryRootWindow()->RemoveRootWindowObserver(this);
 }
 
-void SessionStateControllerImpl2::OnLoginStateChanged(
+void LockStateControllerImpl2::OnLoginStateChanged(
     user::LoginStatus status) {
   if (status != user::LOGGED_IN_LOCKED)
     login_status_ = status;
   system_is_locked_ = (status == user::LOGGED_IN_LOCKED);
 }
 
-void SessionStateControllerImpl2::OnAppTerminating() {
+void LockStateControllerImpl2::OnAppTerminating() {
   // If we hear that Chrome is exiting but didn't request it ourselves, all we
   // can really hope for is that we'll have time to clear the screen.
   // This is also the case when the user signs off.
   if (!shutting_down_) {
     shutting_down_ = true;
     Shell* shell = ash::Shell::GetInstance();
     shell->env_filter()->set_cursor_hidden_by_filter(false);
     shell->cursor_manager()->HideCursor();
     animator_->StartAnimation(
         internal::SessionStateAnimator::kAllContainersMask,
         internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
         internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   }
 }
 
-void SessionStateControllerImpl2::OnLockStateChanged(bool locked) {
+void LockStateControllerImpl2::OnLockStateChanged(bool locked) {
   if (shutting_down_ || (system_is_locked_ == locked))
     return;
 
   system_is_locked_ = locked;
 
   if (locked) {
     StartPostLockAnimation();
     lock_fail_timer_.Stop();
   } else {
     StartUnlockAnimationAfterUIDestroyed();
   }
 }
 
-void SessionStateControllerImpl2::SetLockScreenDisplayedCallback(
+void LockStateControllerImpl2::SetLockScreenDisplayedCallback(
     base::Closure& callback) {
   lock_screen_displayed_callback_ = callback;
 }
 
-void SessionStateControllerImpl2::OnStartingLock() {
+void LockStateControllerImpl2::OnStartingLock() {
   if (shutting_down_ || system_is_locked_)
     return;
   if (animating_lock_)
     return;
   StartImmediatePreLockAnimation(false /* request_lock_on_completion */);
 }
 
-void SessionStateControllerImpl2::StartLockAnimationAndLockImmediately() {
+void LockStateControllerImpl2::StartLockAnimationAndLockImmediately() {
   if (animating_lock_)
     return;
   StartImmediatePreLockAnimation(true /* request_lock_on_completion */);
 }
 
-void SessionStateControllerImpl2::StartLockAnimation(bool shutdown_after_lock) {
+void LockStateControllerImpl2::StartLockAnimation(
+    bool shutdown_after_lock) {
   if (animating_lock_)
     return;
   shutdown_after_lock_ = shutdown_after_lock;
   can_cancel_lock_animation_ = true;
 
   StartCancellablePreLockAnimation();
 }
 
-bool SessionStateControllerImpl2::LockRequested() {
+bool LockStateControllerImpl2::LockRequested() {
   return lock_fail_timer_.IsRunning();
 }
 
-bool SessionStateControllerImpl2::ShutdownRequested() {
+bool LockStateControllerImpl2::ShutdownRequested() {
   return shutting_down_;
 }
 
-bool SessionStateControllerImpl2::CanCancelLockAnimation() {
+bool LockStateControllerImpl2::CanCancelLockAnimation() {
   return can_cancel_lock_animation_;
 }
 
-void SessionStateControllerImpl2::CancelLockAnimation() {
+void LockStateControllerImpl2::CancelLockAnimation() {
   if (!CanCancelLockAnimation())
     return;
   shutdown_after_lock_ = false;
   animating_lock_ = false;
   CancelPreLockAnimation();
 }
 
-bool SessionStateControllerImpl2::CanCancelShutdownAnimation() {
+bool LockStateControllerImpl2::CanCancelShutdownAnimation() {
   return pre_shutdown_timer_.IsRunning() ||
          shutdown_after_lock_ ||
          lock_to_shutdown_timer_.IsRunning();
 }
 
-void SessionStateControllerImpl2::StartShutdownAnimation() {
+void LockStateControllerImpl2::StartShutdownAnimation() {
   StartCancellableShutdownAnimation();
 }
 
-void SessionStateControllerImpl2::CancelShutdownAnimation() {
+void LockStateControllerImpl2::CancelShutdownAnimation() {
   if (!CanCancelShutdownAnimation())
     return;
   if (lock_to_shutdown_timer_.IsRunning()) {
     lock_to_shutdown_timer_.Stop();
     return;
   }
   if (shutdown_after_lock_) {
     shutdown_after_lock_ = false;
     return;
   }
 
   animator_->StartGlobalAnimation(
       internal::SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS,
       internal::SessionStateAnimator::ANIMATION_SPEED_REVERT_SHUTDOWN);
   pre_shutdown_timer_.Stop();
 }
 
-void SessionStateControllerImpl2::RequestShutdown() {
+void LockStateControllerImpl2::RequestShutdown() {
   if (!shutting_down_)
     RequestShutdownImpl();
 }
 
-void SessionStateControllerImpl2::RequestShutdownImpl() {
+void LockStateControllerImpl2::RequestShutdownImpl() {
   DCHECK(!shutting_down_);
   shutting_down_ = true;
 
   Shell* shell = ash::Shell::GetInstance();
   shell->env_filter()->set_cursor_hidden_by_filter(false);
   shell->cursor_manager()->HideCursor();
 
   StartShutdownAnimationImpl();
 }
 
-void SessionStateControllerImpl2::OnRootWindowHostCloseRequested(
+void LockStateControllerImpl2::OnRootWindowHostCloseRequested(
                                                 const aura::RootWindow*) {
   Shell::GetInstance()->delegate()->Exit();
 }
 
-void SessionStateControllerImpl2::OnLockFailTimeout() {
+void LockStateControllerImpl2::OnLockFailTimeout() {
   DCHECK(!system_is_locked_);
   // Undo lock animation.
   StartUnlockAnimationAfterUIDestroyed();
 }
 
-void SessionStateControllerImpl2::StartLockToShutdownTimer() {
+void LockStateControllerImpl2::StartLockToShutdownTimer() {
   shutdown_after_lock_ = false;
   lock_to_shutdown_timer_.Stop();
   lock_to_shutdown_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
-      this, &SessionStateControllerImpl2::OnLockToShutdownTimeout);
+      this, &LockStateControllerImpl2::OnLockToShutdownTimeout);
 }
 
-void SessionStateControllerImpl2::OnLockToShutdownTimeout() {
+void LockStateControllerImpl2::OnLockToShutdownTimeout() {
   DCHECK(system_is_locked_);
   StartCancellableShutdownAnimation();
 }
 
-void SessionStateControllerImpl2::StartCancellableShutdownAnimation() {
+void LockStateControllerImpl2::StartCancellableShutdownAnimation() {
   Shell* shell = ash::Shell::GetInstance();
   // Hide cursor, but let it reappear if the mouse moves.
   shell->env_filter()->set_cursor_hidden_by_filter(true);
   shell->cursor_manager()->HideCursor();
 
   animator_->StartGlobalAnimation(
       internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
       internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   StartPreShutdownAnimationTimer();
 }
 
-void SessionStateControllerImpl2::StartShutdownAnimationImpl() {
+void LockStateControllerImpl2::StartShutdownAnimationImpl() {
   animator_->StartGlobalAnimation(
       internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
       internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   StartRealShutdownTimer(true);
 }
 
-void SessionStateControllerImpl2::StartPreShutdownAnimationTimer() {
+void LockStateControllerImpl2::StartPreShutdownAnimationTimer() {
   pre_shutdown_timer_.Stop();
   pre_shutdown_timer_.Start(
       FROM_HERE,
       animator_->
           GetDuration(internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN),
       this,
-      &SessionStateControllerImpl2::OnPreShutdownAnimationTimeout);
+      &LockStateControllerImpl2::OnPreShutdownAnimationTimeout);
 }
 
-void SessionStateControllerImpl2::OnPreShutdownAnimationTimeout() {
+void LockStateControllerImpl2::OnPreShutdownAnimationTimeout() {
   shutting_down_ = true;
 
   Shell* shell = ash::Shell::GetInstance();
   shell->env_filter()->set_cursor_hidden_by_filter(false);
   shell->cursor_manager()->HideCursor();
 
   StartRealShutdownTimer(false);
 }
 
-void SessionStateControllerImpl2::StartRealShutdownTimer(
+void LockStateControllerImpl2::StartRealShutdownTimer(
     bool with_animation_time) {
   base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kShutdownRequestDelayMs);
   if (with_animation_time) {
     duration += animator_->GetDuration(
         internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   }
   real_shutdown_timer_.Start(
       FROM_HERE,
       duration,
       this,
-      &SessionStateControllerImpl2::OnRealShutdownTimeout);
+      &LockStateControllerImpl2::OnRealShutdownTimeout);
 }
 
-void SessionStateControllerImpl2::OnRealShutdownTimeout() {
+void LockStateControllerImpl2::OnRealShutdownTimeout() {
   DCHECK(shutting_down_);
 #if defined(OS_CHROMEOS)
   if (!base::chromeos::IsRunningOnChromeOS()) {
     ShellDelegate* delegate = Shell::GetInstance()->delegate();
     if (delegate) {
       delegate->Exit();
       return;
     }
   }
 #endif
   Shell::GetInstance()->delegate()->RecordUserMetricsAction(
       UMA_ACCEL_SHUT_DOWN_POWER_BUTTON);
   delegate_->RequestShutdown();
 }
 
-void SessionStateControllerImpl2::OnLockScreenHide(
+void LockStateControllerImpl2::OnLockScreenHide(
   base::Callback<void(void)>& callback) {
   StartUnlockAnimationBeforeUIDestroyed(callback);
 }
 
-void SessionStateControllerImpl2::LockAnimationCancelled() {
+void LockStateControllerImpl2::LockAnimationCancelled() {
   can_cancel_lock_animation_ = false;
   RestoreUnlockedProperties();
 }
 
-void SessionStateControllerImpl2::PreLockAnimationFinished(bool request_lock) {
+void LockStateControllerImpl2::PreLockAnimationFinished(
+    bool request_lock) {
   can_cancel_lock_animation_ = false;
 
   if (request_lock) {
     Shell::GetInstance()->delegate()->RecordUserMetricsAction(
         shutdown_after_lock_ ?
         UMA_ACCEL_LOCK_SCREEN_POWER_BUTTON :
         UMA_ACCEL_LOCK_SCREEN_LOCK_BUTTON);
     delegate_->RequestLockScreen();
   }
 
   lock_fail_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
       this,
-      &SessionStateControllerImpl2::OnLockFailTimeout);
+      &LockStateControllerImpl2::OnLockFailTimeout);
 }
 
-void SessionStateControllerImpl2::PostLockAnimationFinished() {
+void LockStateControllerImpl2::PostLockAnimationFinished() {
   animating_lock_ = false;
 
-  FOR_EACH_OBSERVER(SessionStateObserver, observers_,
-      OnSessionStateEvent(
-          SessionStateObserver::EVENT_LOCK_ANIMATION_FINISHED));
+  FOR_EACH_OBSERVER(LockStateObserver, observers_,
+      OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_FINISHED));
   if (!lock_screen_displayed_callback_.is_null()) {
     lock_screen_displayed_callback_.Run();
     lock_screen_displayed_callback_.Reset();
   }
   if (shutdown_after_lock_) {
     shutdown_after_lock_ = false;
     StartLockToShutdownTimer();
   }
 }
 
-void SessionStateControllerImpl2::UnlockAnimationAfterUIDestroyedFinished() {
+void LockStateControllerImpl2::
+UnlockAnimationAfterUIDestroyedFinished() {
   RestoreUnlockedProperties();
 }
 
-void SessionStateControllerImpl2::StartImmediatePreLockAnimation(
+void LockStateControllerImpl2::StartImmediatePreLockAnimation(
     bool request_lock_on_completion) {
   animating_lock_ = true;
 
   StoreUnlockedProperties();
 
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::PreLockAnimationFinished,
+      base::Bind(&LockStateControllerImpl2::PreLockAnimationFinished,
       base::Unretained(this), request_lock_on_completion);
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_LIFT,
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::LAUNCHER,
       internal::SessionStateAnimator::ANIMATION_FADE_OUT,
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   // Hide the screen locker containers so we can raise them later.
   animator_->StartAnimation(
       internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
       internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   AnimateBackgroundAppearanceIfNecessary(
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
 
   observer->Unpause();
 
   DispatchCancelMode();
-  FOR_EACH_OBSERVER(SessionStateObserver, observers_,
-      OnSessionStateEvent(SessionStateObserver::EVENT_LOCK_ANIMATION_STARTED));
+  FOR_EACH_OBSERVER(LockStateObserver, observers_,
+      OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_STARTED));
 }
 
-void SessionStateControllerImpl2::StartCancellablePreLockAnimation() {
+void LockStateControllerImpl2::StartCancellablePreLockAnimation() {
   animating_lock_ = true;
   StoreUnlockedProperties();
 
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::PreLockAnimationFinished,
+      base::Bind(&LockStateControllerImpl2::PreLockAnimationFinished,
       base::Unretained(this), true /* request_lock */);
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_LIFT,
       internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
       observer);
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::LAUNCHER,
       internal::SessionStateAnimator::ANIMATION_FADE_OUT,
       internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
       observer);
   // Hide the screen locker containers so we can raise them later.
   animator_->StartAnimation(
       internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
       internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   AnimateBackgroundAppearanceIfNecessary(
       internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE,
       observer);
 
   DispatchCancelMode();
-  FOR_EACH_OBSERVER(SessionStateObserver, observers_,
-      OnSessionStateEvent(
-          SessionStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
+  FOR_EACH_OBSERVER(LockStateObserver, observers_,
+      OnLockStateEvent(LockStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::CancelPreLockAnimation() {
+void LockStateControllerImpl2::CancelPreLockAnimation() {
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::LockAnimationCancelled,
+      base::Bind(&LockStateControllerImpl2::LockAnimationCancelled,
       base::Unretained(this));
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_UNDO_LIFT,
       internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
       observer);
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::LAUNCHER,
       internal::SessionStateAnimator::ANIMATION_FADE_IN,
       internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
       observer);
   AnimateBackgroundHidingIfNecessary(
       internal::SessionStateAnimator::ANIMATION_SPEED_UNDO_MOVE_WINDOWS,
       observer);
 
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::StartPostLockAnimation() {
+void LockStateControllerImpl2::StartPostLockAnimation() {
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::PostLockAnimationFinished,
+      base::Bind(&LockStateControllerImpl2::PostLockAnimationFinished,
       base::Unretained(this));
 
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN,
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::StartUnlockAnimationBeforeUIDestroyed(
+void LockStateControllerImpl2::StartUnlockAnimationBeforeUIDestroyed(
     base::Closure& callback) {
   animator_->StartAnimationWithCallback(
       internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_LIFT,
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       callback);
 }
 
-void SessionStateControllerImpl2::StartUnlockAnimationAfterUIDestroyed() {
+void LockStateControllerImpl2::StartUnlockAnimationAfterUIDestroyed() {
   base::Closure next_animation_starter =
       base::Bind(
-          &SessionStateControllerImpl2::UnlockAnimationAfterUIDestroyedFinished,
-      base::Unretained(this));
+          &LockStateControllerImpl2::
+              UnlockAnimationAfterUIDestroyedFinished,
+          base::Unretained(this));
 
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
 
   observer->Pause();
 
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
       internal::SessionStateAnimator::ANIMATION_DROP,
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   animator_->StartAnimationWithObserver(
       internal::SessionStateAnimator::LAUNCHER,
       internal::SessionStateAnimator::ANIMATION_FADE_IN,
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   AnimateBackgroundHidingIfNecessary(
       internal::SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS,
       observer);
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::StoreUnlockedProperties() {
+void LockStateControllerImpl2::StoreUnlockedProperties() {
   if (!unlocked_properties_) {
     unlocked_properties_.reset(new UnlockedStateProperties());
     unlocked_properties_->background_is_hidden = IsBackgroundHidden();
   }
   if (unlocked_properties_->background_is_hidden) {
     // Hide background so that it can be animated later.
     animator_->StartAnimation(
         internal::SessionStateAnimator::DESKTOP_BACKGROUND,
         internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
         internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
     ShowBackground();
   }
 }
 
-void SessionStateControllerImpl2::RestoreUnlockedProperties() {
+void LockStateControllerImpl2::RestoreUnlockedProperties() {
   if (!unlocked_properties_)
     return;
   if (unlocked_properties_->background_is_hidden) {
     HideBackground();
     // Restore background visibility.
     animator_->StartAnimation(
         internal::SessionStateAnimator::DESKTOP_BACKGROUND,
         internal::SessionStateAnimator::ANIMATION_FADE_IN,
         internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
   }
   unlocked_properties_.reset();
 }
 
-void SessionStateControllerImpl2::AnimateBackgroundAppearanceIfNecessary(
+void LockStateControllerImpl2::AnimateBackgroundAppearanceIfNecessary(
     internal::SessionStateAnimator::AnimationSpeed speed,
     ui::LayerAnimationObserver* observer) {
   if (unlocked_properties_.get() &&
       unlocked_properties_->background_is_hidden) {
     animator_->StartAnimationWithObserver(
         internal::SessionStateAnimator::DESKTOP_BACKGROUND,
         internal::SessionStateAnimator::ANIMATION_FADE_IN,
         speed,
         observer);
   }
 }
 
-void SessionStateControllerImpl2::AnimateBackgroundHidingIfNecessary(
+void LockStateControllerImpl2::AnimateBackgroundHidingIfNecessary(
     internal::SessionStateAnimator::AnimationSpeed speed,
     ui::LayerAnimationObserver* observer) {
   if (unlocked_properties_.get() &&
       unlocked_properties_->background_is_hidden) {
     animator_->StartAnimationWithObserver(
         internal::SessionStateAnimator::DESKTOP_BACKGROUND,
         internal::SessionStateAnimator::ANIMATION_FADE_OUT,
         speed,
         observer);
   }
 }
 
 }  // namespace ash