Rename SessionStateController -> LockStateController

ash/wm/session_lock_state_controller_impl2.h

 // 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.
 
-#ifndef ASH_WM_SESSION_STATE_CONTROLLER_IMPL2_H_
-#define ASH_WM_SESSION_STATE_CONTROLLER_IMPL2_H_
+#ifndef ASH_WM_SESSION_LOCK_STATE_CONTROLLER_IMPL2_H_
+#define ASH_WM_SESSION_LOCK_STATE_CONTROLLER_IMPL2_H_
 
 #include "ash/ash_export.h"
 #include "ash/shell_observer.h"
+#include "ash/wm/session_lock_state_controller.h"
 #include "ash/wm/session_state_animator.h"
-#include "ash/wm/session_state_controller.h"
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "ui/aura/root_window_observer.h"
 
 namespace gfx {
 class Rect;
 class Size;
 }
 
 namespace ui {
 class Layer;
 }
 
 namespace ash {
 
 namespace test {
-class SessionStateControllerImpl2Test;
+class SessionLockStateControllerImpl2Test;
 }
 
 // Displays onscreen animations and locks or suspends the system in response to
 // the power button being pressed or released.
 // Lock workflow:
 // Entry points:
 //  * StartLockAnimation (bool shutdown after lock) - starts lock that can be
 //    cancelled.
 //  * StartLockAnimationAndLockImmediately - starts uninterruptible lock
 //    animation.
 // This leads to call of either StartImmediatePreLockAnimation or
 // StartCancellablePreLockAnimation. Once they complete
 // PreLockAnimationFinished is called, and system lock is requested.
 // Once system locks and lock UI is created, OnLockStateChanged is called, and
 // StartPostLockAnimation is called. In PostLockAnimationFinished two
 // things happen : EVENT_LOCK_ANIMATION_FINISHED notification is sent (it
 // triggers third part of animation within lock UI), and check for continuing to
 // shutdown is made.
 //
 // Unlock workflow:
 // WebUI does first part of animation, and calls OnLockScreenHide(callback) that
 // triggers StartUnlockAnimationBeforeUIDestroyed(callback). Once callback is
 // called at the end of the animation, lock UI is deleted, system unlocks, and
 // OnLockStateChanged is called. It leads to
 // StartUnlockAnimationAfterUIDestroyed.
 
-class ASH_EXPORT SessionStateControllerImpl2 : public SessionStateController {
+class ASH_EXPORT SessionLockStateControllerImpl2
+    : public SessionLockStateController {
  public:
 
   // Helper class used by tests to access internal state.
   class ASH_EXPORT TestApi {
    public:
-    explicit TestApi(SessionStateControllerImpl2* controller);
+    explicit TestApi(SessionLockStateControllerImpl2* controller);
 
     virtual ~TestApi();
 
     bool lock_fail_timer_is_running() const {
       return controller_->lock_fail_timer_.IsRunning();
     }
     bool lock_to_shutdown_timer_is_running() const {
       return controller_->lock_to_shutdown_timer_.IsRunning();
     }
     bool shutdown_timer_is_running() const {
@@ skipping 19 matching lines @@
     }
     void trigger_shutdown_timeout() {
       controller_->OnPreShutdownAnimationTimeout();
       controller_->pre_shutdown_timer_.Stop();
     }
     void trigger_real_shutdown_timeout() {
       controller_->OnRealShutdownTimeout();
       controller_->real_shutdown_timer_.Stop();
     }
    private:
-    SessionStateControllerImpl2* controller_;  // not owned
+    SessionLockStateControllerImpl2* controller_;  // not owned
 
     DISALLOW_COPY_AND_ASSIGN(TestApi);
   };
 
-  SessionStateControllerImpl2();
-  virtual ~SessionStateControllerImpl2();
+  SessionLockStateControllerImpl2();
+  virtual ~SessionLockStateControllerImpl2();
 
   // RootWindowObserver override:
   virtual void OnRootWindowHostCloseRequested(
      const aura::RootWindow* root) OVERRIDE;
 
   // ShellObserver overrides:
   virtual void OnLoginStateChanged(user::LoginStatus status) OVERRIDE;
   virtual void OnAppTerminating() OVERRIDE;
   virtual void OnLockStateChanged(bool locked) OVERRIDE;
 
-  // SessionStateController overrides:
+  // SessionLockStateController overrides:
   virtual void StartLockAnimation(bool shutdown_after_lock) OVERRIDE;
 
   virtual void StartShutdownAnimation() OVERRIDE;
   virtual void StartLockAnimationAndLockImmediately() OVERRIDE;
 
   virtual bool LockRequested() OVERRIDE;
   virtual bool ShutdownRequested() OVERRIDE;
 
   virtual bool CanCancelLockAnimation() OVERRIDE;
   virtual void CancelLockAnimation() OVERRIDE;
 
   virtual bool CanCancelShutdownAnimation() OVERRIDE;
   virtual void CancelShutdownAnimation() OVERRIDE;
 
   virtual void OnStartingLock() OVERRIDE;
   virtual void RequestShutdown() OVERRIDE;
 
   virtual void OnLockScreenHide(base::Closure& callback) OVERRIDE;
   virtual void SetLockScreenDisplayedCallback(base::Closure& callback) OVERRIDE;
 
  protected:
-  friend class test::SessionStateControllerImpl2Test;
+  friend class test::SessionLockStateControllerImpl2Test;
 
  private:
   struct UnlockedStateProperties {
     bool background_is_hidden;
   };
 
   void RequestShutdownImpl();
 
   // Reverts the pre-lock animation, reports the error.
   void OnLockFailTimeout();
@@ skipping 77 matching lines @@
   // Indicates that controller displays lock animation.
   bool animating_lock_;
 
   // Indicates that lock animation can be undone.
   bool can_cancel_lock_animation_;
 
   scoped_ptr<UnlockedStateProperties> unlocked_properties_;
 
   // Started when we request that the screen be locked.  When it fires, we
   // assume that our request got dropped.
-  base::OneShotTimer<SessionStateControllerImpl2> lock_fail_timer_;
+  base::OneShotTimer<SessionLockStateControllerImpl2> lock_fail_timer_;
 
   // Started when the screen is locked while the power button is held.  Adds a
   // delay between the appearance of the lock screen and the beginning of the
   // pre-shutdown animation.
-  base::OneShotTimer<SessionStateControllerImpl2> lock_to_shutdown_timer_;
+  base::OneShotTimer<SessionLockStateControllerImpl2> lock_to_shutdown_timer_;
 
   // Started when we begin displaying the pre-shutdown animation.  When it
   // fires, we start the shutdown animation and get ready to request shutdown.
-  base::OneShotTimer<SessionStateControllerImpl2> pre_shutdown_timer_;
+  base::OneShotTimer<SessionLockStateControllerImpl2> pre_shutdown_timer_;
 
   // Started when we display the shutdown animation.  When it fires, we actually
   // request shutdown.  Gives the animation time to complete before Chrome, X,
   // etc. are shut down.
-  base::OneShotTimer<SessionStateControllerImpl2> real_shutdown_timer_;
+  base::OneShotTimer<SessionLockStateControllerImpl2> real_shutdown_timer_;
 
   base::Closure lock_screen_displayed_callback_;
 
-  DISALLOW_COPY_AND_ASSIGN(SessionStateControllerImpl2);
+  DISALLOW_COPY_AND_ASSIGN(SessionLockStateControllerImpl2);
 };
 
 }  // namespace ash
 
-#endif  // ASH_WM_SESSION_STATE_CONTROLLER_IMPL2_H_
+#endif  // ASH_WM_SESSION_LOCK_STATE_CONTROLLER_IMPL2_H_