Rename SessionStateController -> LockStateController

ash/wm/session_lock_state_controller_impl2.cc

Index: ash/wm/session_lock_state_controller_impl2.cc
diff --git a/ash/wm/session_state_controller_impl2.cc b/ash/wm/session_lock_state_controller_impl2.cc
similarity index 79%
rename from ash/wm/session_state_controller_impl2.cc
rename to ash/wm/session_lock_state_controller_impl2.cc
index f21a8d7d6ba95aab7871215618ebfc879cc7a1b2..2cdb34e24ece3b484613a3954d0d91c5d4aef143 100644
--- a/ash/wm/session_state_controller_impl2.cc
+++ b/ash/wm/session_lock_state_controller_impl2.cc
@@ -2,7 +2,7 @@
 // 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/session_lock_state_controller_impl2.h"
 
 #include "ash/ash_switches.h"
 #include "ash/cancel_mode.h"
@@ -135,15 +135,15 @@ class AnimationFinishedObserver : public ui::LayerAnimationObserver {
 
 } // namespace
 
-SessionStateControllerImpl2::TestApi::TestApi(
-    SessionStateControllerImpl2* controller)
+SessionLockStateControllerImpl2::TestApi::TestApi(
+    SessionLockStateControllerImpl2* controller)
     : controller_(controller) {
 }
 
-SessionStateControllerImpl2::TestApi::~TestApi() {
+SessionLockStateControllerImpl2::TestApi::~TestApi() {
 }
 
-SessionStateControllerImpl2::SessionStateControllerImpl2()
+SessionLockStateControllerImpl2::SessionLockStateControllerImpl2()
     : login_status_(user::LOGGED_IN_NONE),
       system_is_locked_(false),
       shutting_down_(false),
@@ -153,18 +153,18 @@ SessionStateControllerImpl2::SessionStateControllerImpl2()
   Shell::GetPrimaryRootWindow()->AddRootWindowObserver(this);
 }
 
-SessionStateControllerImpl2::~SessionStateControllerImpl2() {
+SessionLockStateControllerImpl2::~SessionLockStateControllerImpl2() {
   Shell::GetPrimaryRootWindow()->RemoveRootWindowObserver(this);
 }
 
-void SessionStateControllerImpl2::OnLoginStateChanged(
+void SessionLockStateControllerImpl2::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 SessionLockStateControllerImpl2::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.
@@ -180,7 +180,7 @@ void SessionStateControllerImpl2::OnAppTerminating() {
   }
 }
 
-void SessionStateControllerImpl2::OnLockStateChanged(bool locked) {
+void SessionLockStateControllerImpl2::OnLockStateChanged(bool locked) {
   if (shutting_down_ || (system_is_locked_ == locked))
     return;
 
@@ -194,12 +194,12 @@ void SessionStateControllerImpl2::OnLockStateChanged(bool locked) {
   }
 }
 
-void SessionStateControllerImpl2::SetLockScreenDisplayedCallback(
+void SessionLockStateControllerImpl2::SetLockScreenDisplayedCallback(
     base::Closure& callback) {
   lock_screen_displayed_callback_ = callback;
 }
 
-void SessionStateControllerImpl2::OnStartingLock() {
+void SessionLockStateControllerImpl2::OnStartingLock() {
   if (shutting_down_ || system_is_locked_)
     return;
   if (animating_lock_)
@@ -207,13 +207,14 @@ void SessionStateControllerImpl2::OnStartingLock() {
   StartImmediatePreLockAnimation(false /* request_lock_on_completion */);
 }
 
-void SessionStateControllerImpl2::StartLockAnimationAndLockImmediately() {
+void SessionLockStateControllerImpl2::StartLockAnimationAndLockImmediately() {
   if (animating_lock_)
     return;
   StartImmediatePreLockAnimation(true /* request_lock_on_completion */);
 }
 
-void SessionStateControllerImpl2::StartLockAnimation(bool shutdown_after_lock) {
+void SessionLockStateControllerImpl2::StartLockAnimation(
+    bool shutdown_after_lock) {
   if (animating_lock_)
     return;
   shutdown_after_lock_ = shutdown_after_lock;
@@ -222,19 +223,19 @@ void SessionStateControllerImpl2::StartLockAnimation(bool shutdown_after_lock) {
   StartCancellablePreLockAnimation();
 }
 
-bool SessionStateControllerImpl2::LockRequested() {
+bool SessionLockStateControllerImpl2::LockRequested() {
   return lock_fail_timer_.IsRunning();
 }
 
-bool SessionStateControllerImpl2::ShutdownRequested() {
+bool SessionLockStateControllerImpl2::ShutdownRequested() {
   return shutting_down_;
 }
 
-bool SessionStateControllerImpl2::CanCancelLockAnimation() {
+bool SessionLockStateControllerImpl2::CanCancelLockAnimation() {
   return can_cancel_lock_animation_;
 }
 
-void SessionStateControllerImpl2::CancelLockAnimation() {
+void SessionLockStateControllerImpl2::CancelLockAnimation() {
   if (!CanCancelLockAnimation())
     return;
   shutdown_after_lock_ = false;
@@ -242,17 +243,17 @@ void SessionStateControllerImpl2::CancelLockAnimation() {
   CancelPreLockAnimation();
 }
 
-bool SessionStateControllerImpl2::CanCancelShutdownAnimation() {
+bool SessionLockStateControllerImpl2::CanCancelShutdownAnimation() {
   return pre_shutdown_timer_.IsRunning() ||
          shutdown_after_lock_ ||
          lock_to_shutdown_timer_.IsRunning();
 }
 
-void SessionStateControllerImpl2::StartShutdownAnimation() {
+void SessionLockStateControllerImpl2::StartShutdownAnimation() {
   StartCancellableShutdownAnimation();
 }
 
-void SessionStateControllerImpl2::CancelShutdownAnimation() {
+void SessionLockStateControllerImpl2::CancelShutdownAnimation() {
   if (!CanCancelShutdownAnimation())
     return;
   if (lock_to_shutdown_timer_.IsRunning()) {
@@ -270,12 +271,12 @@ void SessionStateControllerImpl2::CancelShutdownAnimation() {
   pre_shutdown_timer_.Stop();
 }
 
-void SessionStateControllerImpl2::RequestShutdown() {
+void SessionLockStateControllerImpl2::RequestShutdown() {
   if (!shutting_down_)
     RequestShutdownImpl();
 }
 
-void SessionStateControllerImpl2::RequestShutdownImpl() {
+void SessionLockStateControllerImpl2::RequestShutdownImpl() {
   DCHECK(!shutting_down_);
   shutting_down_ = true;
 
@@ -286,32 +287,32 @@ void SessionStateControllerImpl2::RequestShutdownImpl() {
   StartShutdownAnimationImpl();
 }
 
-void SessionStateControllerImpl2::OnRootWindowHostCloseRequested(
+void SessionLockStateControllerImpl2::OnRootWindowHostCloseRequested(
                                                 const aura::RootWindow*) {
   Shell::GetInstance()->delegate()->Exit();
 }
 
-void SessionStateControllerImpl2::OnLockFailTimeout() {
+void SessionLockStateControllerImpl2::OnLockFailTimeout() {
   DCHECK(!system_is_locked_);
   // Undo lock animation.
   StartUnlockAnimationAfterUIDestroyed();
 }
 
-void SessionStateControllerImpl2::StartLockToShutdownTimer() {
+void SessionLockStateControllerImpl2::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, &SessionLockStateControllerImpl2::OnLockToShutdownTimeout);
 }
 
-void SessionStateControllerImpl2::OnLockToShutdownTimeout() {
+void SessionLockStateControllerImpl2::OnLockToShutdownTimeout() {
   DCHECK(system_is_locked_);
   StartCancellableShutdownAnimation();
 }
 
-void SessionStateControllerImpl2::StartCancellableShutdownAnimation() {
+void SessionLockStateControllerImpl2::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);
@@ -323,24 +324,24 @@ void SessionStateControllerImpl2::StartCancellableShutdownAnimation() {
   StartPreShutdownAnimationTimer();
 }
 
-void SessionStateControllerImpl2::StartShutdownAnimationImpl() {
+void SessionLockStateControllerImpl2::StartShutdownAnimationImpl() {
   animator_->StartGlobalAnimation(
       internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
       internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
   StartRealShutdownTimer(true);
 }
 
-void SessionStateControllerImpl2::StartPreShutdownAnimationTimer() {
+void SessionLockStateControllerImpl2::StartPreShutdownAnimationTimer() {
   pre_shutdown_timer_.Stop();
   pre_shutdown_timer_.Start(
       FROM_HERE,
       animator_->
           GetDuration(internal::SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN),
       this,
-      &SessionStateControllerImpl2::OnPreShutdownAnimationTimeout);
+      &SessionLockStateControllerImpl2::OnPreShutdownAnimationTimeout);
 }
 
-void SessionStateControllerImpl2::OnPreShutdownAnimationTimeout() {
+void SessionLockStateControllerImpl2::OnPreShutdownAnimationTimeout() {
   shutting_down_ = true;
 
   Shell* shell = ash::Shell::GetInstance();
@@ -350,7 +351,7 @@ void SessionStateControllerImpl2::OnPreShutdownAnimationTimeout() {
   StartRealShutdownTimer(false);
 }
 
-void SessionStateControllerImpl2::StartRealShutdownTimer(
+void SessionLockStateControllerImpl2::StartRealShutdownTimer(
     bool with_animation_time) {
   base::TimeDelta duration =
       base::TimeDelta::FromMilliseconds(kShutdownRequestDelayMs);
@@ -362,10 +363,10 @@ void SessionStateControllerImpl2::StartRealShutdownTimer(
       FROM_HERE,
       duration,
       this,
-      &SessionStateControllerImpl2::OnRealShutdownTimeout);
+      &SessionLockStateControllerImpl2::OnRealShutdownTimeout);
 }
 
-void SessionStateControllerImpl2::OnRealShutdownTimeout() {
+void SessionLockStateControllerImpl2::OnRealShutdownTimeout() {
   DCHECK(shutting_down_);
 #if defined(OS_CHROMEOS)
   if (!base::chromeos::IsRunningOnChromeOS()) {
@@ -381,17 +382,18 @@ void SessionStateControllerImpl2::OnRealShutdownTimeout() {
   delegate_->RequestShutdown();
 }
 
-void SessionStateControllerImpl2::OnLockScreenHide(
+void SessionLockStateControllerImpl2::OnLockScreenHide(
   base::Callback<void(void)>& callback) {
   StartUnlockAnimationBeforeUIDestroyed(callback);
 }
 
-void SessionStateControllerImpl2::LockAnimationCancelled() {
+void SessionLockStateControllerImpl2::LockAnimationCancelled() {
   can_cancel_lock_animation_ = false;
   RestoreUnlockedProperties();
 }
 
-void SessionStateControllerImpl2::PreLockAnimationFinished(bool request_lock) {
+void SessionLockStateControllerImpl2::PreLockAnimationFinished(
+    bool request_lock) {
   can_cancel_lock_animation_ = false;
 
   if (request_lock) {
@@ -406,15 +408,15 @@ void SessionStateControllerImpl2::PreLockAnimationFinished(bool request_lock) {
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
       this,
-      &SessionStateControllerImpl2::OnLockFailTimeout);
+      &SessionLockStateControllerImpl2::OnLockFailTimeout);
 }
 
-void SessionStateControllerImpl2::PostLockAnimationFinished() {
+void SessionLockStateControllerImpl2::PostLockAnimationFinished() {
   animating_lock_ = false;
 
-  FOR_EACH_OBSERVER(SessionStateObserver, observers_,
-      OnSessionStateEvent(
-          SessionStateObserver::EVENT_LOCK_ANIMATION_FINISHED));
+  FOR_EACH_OBSERVER(SessionLockStateObserver, observers_,
+      OnSessionLockStateEvent(
+          SessionLockStateObserver::EVENT_LOCK_ANIMATION_FINISHED));
   if (!lock_screen_displayed_callback_.is_null()) {
     lock_screen_displayed_callback_.Run();
     lock_screen_displayed_callback_.Reset();
@@ -425,18 +427,19 @@ void SessionStateControllerImpl2::PostLockAnimationFinished() {
   }
 }
 
-void SessionStateControllerImpl2::UnlockAnimationAfterUIDestroyedFinished() {
+void SessionLockStateControllerImpl2::
+UnlockAnimationAfterUIDestroyedFinished() {
   RestoreUnlockedProperties();
 }
 
-void SessionStateControllerImpl2::StartImmediatePreLockAnimation(
+void SessionLockStateControllerImpl2::StartImmediatePreLockAnimation(
     bool request_lock_on_completion) {
   animating_lock_ = true;
 
   StoreUnlockedProperties();
 
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::PreLockAnimationFinished,
+      base::Bind(&SessionLockStateControllerImpl2::PreLockAnimationFinished,
       base::Unretained(this), request_lock_on_completion);
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
@@ -465,16 +468,17 @@ void SessionStateControllerImpl2::StartImmediatePreLockAnimation(
   observer->Unpause();
 
   DispatchCancelMode();
-  FOR_EACH_OBSERVER(SessionStateObserver, observers_,
-      OnSessionStateEvent(SessionStateObserver::EVENT_LOCK_ANIMATION_STARTED));
+  FOR_EACH_OBSERVER(SessionLockStateObserver, observers_,
+      OnSessionLockStateEvent(
+          SessionLockStateObserver::EVENT_LOCK_ANIMATION_STARTED));
 }
 
-void SessionStateControllerImpl2::StartCancellablePreLockAnimation() {
+void SessionLockStateControllerImpl2::StartCancellablePreLockAnimation() {
   animating_lock_ = true;
   StoreUnlockedProperties();
 
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::PreLockAnimationFinished,
+      base::Bind(&SessionLockStateControllerImpl2::PreLockAnimationFinished,
       base::Unretained(this), true /* request_lock */);
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
@@ -501,15 +505,15 @@ void SessionStateControllerImpl2::StartCancellablePreLockAnimation() {
       observer);
 
   DispatchCancelMode();
-  FOR_EACH_OBSERVER(SessionStateObserver, observers_,
-      OnSessionStateEvent(
-          SessionStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
+  FOR_EACH_OBSERVER(SessionLockStateObserver, observers_,
+      OnSessionLockStateEvent(
+          SessionLockStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::CancelPreLockAnimation() {
+void SessionLockStateControllerImpl2::CancelPreLockAnimation() {
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::LockAnimationCancelled,
+      base::Bind(&SessionLockStateControllerImpl2::LockAnimationCancelled,
       base::Unretained(this));
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
@@ -533,9 +537,9 @@ void SessionStateControllerImpl2::CancelPreLockAnimation() {
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::StartPostLockAnimation() {
+void SessionLockStateControllerImpl2::StartPostLockAnimation() {
   base::Closure next_animation_starter =
-      base::Bind(&SessionStateControllerImpl2::PostLockAnimationFinished,
+      base::Bind(&SessionLockStateControllerImpl2::PostLockAnimationFinished,
       base::Unretained(this));
 
   AnimationFinishedObserver* observer =
@@ -550,7 +554,7 @@ void SessionStateControllerImpl2::StartPostLockAnimation() {
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::StartUnlockAnimationBeforeUIDestroyed(
+void SessionLockStateControllerImpl2::StartUnlockAnimationBeforeUIDestroyed(
     base::Closure& callback) {
   animator_->StartAnimationWithCallback(
       internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
@@ -559,11 +563,12 @@ void SessionStateControllerImpl2::StartUnlockAnimationBeforeUIDestroyed(
       callback);
 }
 
-void SessionStateControllerImpl2::StartUnlockAnimationAfterUIDestroyed() {
+void SessionLockStateControllerImpl2::StartUnlockAnimationAfterUIDestroyed() {
   base::Closure next_animation_starter =
       base::Bind(
-          &SessionStateControllerImpl2::UnlockAnimationAfterUIDestroyedFinished,
-      base::Unretained(this));
+          &SessionLockStateControllerImpl2::
+              UnlockAnimationAfterUIDestroyedFinished,
+          base::Unretained(this));
 
   AnimationFinishedObserver* observer =
       new AnimationFinishedObserver(next_animation_starter);
@@ -586,7 +591,7 @@ void SessionStateControllerImpl2::StartUnlockAnimationAfterUIDestroyed() {
   observer->Unpause();
 }
 
-void SessionStateControllerImpl2::StoreUnlockedProperties() {
+void SessionLockStateControllerImpl2::StoreUnlockedProperties() {
   if (!unlocked_properties_) {
     unlocked_properties_.reset(new UnlockedStateProperties());
     unlocked_properties_->background_is_hidden = IsBackgroundHidden();
@@ -601,7 +606,7 @@ void SessionStateControllerImpl2::StoreUnlockedProperties() {
   }
 }
 
-void SessionStateControllerImpl2::RestoreUnlockedProperties() {
+void SessionLockStateControllerImpl2::RestoreUnlockedProperties() {
   if (!unlocked_properties_)
     return;
   if (unlocked_properties_->background_is_hidden) {
@@ -615,7 +620,7 @@ void SessionStateControllerImpl2::RestoreUnlockedProperties() {
   unlocked_properties_.reset();
 }
 
-void SessionStateControllerImpl2::AnimateBackgroundAppearanceIfNecessary(
+void SessionLockStateControllerImpl2::AnimateBackgroundAppearanceIfNecessary(
     internal::SessionStateAnimator::AnimationSpeed speed,
     ui::LayerAnimationObserver* observer) {
   if (unlocked_properties_.get() &&
@@ -628,7 +633,7 @@ void SessionStateControllerImpl2::AnimateBackgroundAppearanceIfNecessary(
   }
 }
 
-void SessionStateControllerImpl2::AnimateBackgroundHidingIfNecessary(
+void SessionLockStateControllerImpl2::AnimateBackgroundHidingIfNecessary(
     internal::SessionStateAnimator::AnimationSpeed speed,
     ui::LayerAnimationObserver* observer) {
   if (unlocked_properties_.get() &&