ash : Decouple power button controller and session state controller.

ash/wm/session_state_controller.h

Index: ash/wm/session_state_controller.h
diff --git a/ash/wm/session_state_controller.h b/ash/wm/session_state_controller.h
new file mode 100644
index 0000000000000000000000000000000000000000..666786df8dbab683152155f5bcd03e380c96039c
--- /dev/null
+++ b/ash/wm/session_state_controller.h
@@ -0,0 +1,286 @@
+// 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_H_
+#define ASH_WM_SESSION_STATE_CONTROLLER_H_
+
+#include "ash/ash_export.h"
+#include "ash/shell_observer.h"
+#include "ash/wm/session_state_animator.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 PowerButtonControllerTest;
+}
+
+namespace internal {

[Daniel Erat, 2012/10/11 15:08:30]

why do you need all of these in the header instead of in an anonymous namespace
in the .cc file?  some of these names, like kSlowCloseAnimMs, seem too generic
to expose publicly in the internal namespace.

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

I will have two implementations that would reuse these constants.

[Daniel Erat, 2012/10/11 16:16:42]

please make them be protected static members of the SessionStateController
class, then.

+// Amount of time that the power button needs to be held before we lock the
+// screen.
+const int kLockTimeoutMs = 400;
+
+// Amount of time that the power button needs to be held before we shut down.
+const int kShutdownTimeoutMs = 400;
+
+// Amount of time to wait for our lock requests to be honored before giving up.
+const int kLockFailTimeoutMs = 4000;
+
+// When the button has been held continuously from the unlocked state, amount of
+// time that we wait after the screen locker window is shown before starting the
+// pre-shutdown animation.
+const int kLockToShutdownTimeoutMs = 150;
+
+// Amount of time taken to scale the snapshot of the screen down to a
+// slightly-smaller size once the user starts holding the power button.  Used
+// for both the pre-lock and pre-shutdown animations.
+const int kSlowCloseAnimMs = 400;
+
+// Amount of time taken to scale the snapshot of the screen back to its original
+// size when the button is released.
+const int kUndoSlowCloseAnimMs = 100;
+
+// Amount of time taken to scale the snapshot down to a point in the center of
+// the screen once the screen has been locked or we've been notified that the
+// system is shutting down.
+const int kFastCloseAnimMs = 150;
+
+// Additional time (beyond kFastCloseAnimMs) to wait after starting the
+// fast-close shutdown animation before actually requesting shutdown, to give
+// the animation time to finish.
+const int kShutdownRequestDelayMs = 50;
+}
+
+// Performs system-related functions on behalf of SessionStateController.
+class ASH_EXPORT SessionStateControllerDelegate {
+ public:
+  SessionStateControllerDelegate() {}
+  virtual ~SessionStateControllerDelegate() {}
+
+  virtual void RequestLockScreen() = 0;
+  virtual void RequestShutdown() = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SessionStateControllerDelegate);
+};
+
+// Displays onscreen animations and locks or suspends the system in response to
+// the power button being pressed or released.
+class ASH_EXPORT SessionStateController : public aura::RootWindowObserver,
+                                          public ShellObserver {
+ public:
+
+  // Helper class used by tests to access internal state.
+  class ASH_EXPORT TestApi {
+   public:
+    explicit TestApi(SessionStateController* controller);
+
+    virtual ~TestApi();
+
+    bool lock_timer_is_running() const {
+      return controller_->lock_timer_.IsRunning();
+    }
+    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 {
+      return controller_->pre_shutdown_timer_.IsRunning();
+    }
+    bool real_shutdown_timer_is_running() const {
+      return controller_->real_shutdown_timer_.IsRunning();
+    }
+
+    void trigger_lock_timeout() {
+      controller_->OnLockTimeout();
+      controller_->lock_timer_.Stop();
+    }
+    void trigger_lock_fail_timeout() {
+      controller_->OnLockFailTimeout();
+      controller_->lock_fail_timer_.Stop();
+    }
+    void trigger_lock_to_shutdown_timeout() {
+      controller_->OnLockToShutdownTimeout();
+      controller_->lock_to_shutdown_timer_.Stop();
+    }
+    void trigger_shutdown_timeout() {
+      controller_->OnPreShutdownAnimationTimeout();
+      controller_->pre_shutdown_timer_.Stop();
+    }
+    void trigger_real_shutdown_timeout() {
+      controller_->OnRealShutdownTimeout();
+      controller_->real_shutdown_timer_.Stop();
+    }
+   private:
+    SessionStateController* controller_;  // not owned
+
+    DISALLOW_COPY_AND_ASSIGN(TestApi);
+  };
+
+  SessionStateController();
+  virtual ~SessionStateController();
+
+  void set_delegate(SessionStateControllerDelegate* delegate) {
+    delegate_.reset(delegate);
+  }
+
+  // Returns true iff when we're in state when user session can be locked.
+  virtual bool IsEligibleForLock();

[Daniel Erat, 2012/10/11 15:08:30]

can this and many other similar methods be const?

why are all of these methods virtual?

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Same as above - there would be two actual implementations of
session_state_controller, and these would become =0.

+
+  // Returns true if system is locked.
+  virtual bool IsLocked();
+
+  // Starts locking (with slow animation) that can be cancelled.
+  // After locking and |kLockToShutdownTimeoutMs| StartCancellableShutdown()
+  // will be called unless CancelShutdown() is called.
+  virtual void StartCancellableLock();
+
+  // Starts shutting down (with slow animation) that can be cancelled.
+  virtual void StartCancellableShutdown();
+
+  // Starts shutdown that can not be undone.
+  virtual void ShutdownImmediately();
+
+  // Starts usual lock animation, but lock immediately.
+  virtual void StartLockAnimationButLockImmediately();

[Daniel Erat, 2012/10/11 15:08:30]

nit: s/But/And/

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+
+  // Returns true if we have requested system to lock, but havan't recieved

[Daniel Erat, 2012/10/11 15:08:30]

nit: s/havan't/haven't/

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+  // confirmation yet.
+  virtual bool IsTryingToLock();
+
+  // Returns true if we are within cancellable lock timeframe or trying to lock.
+  virtual bool IsLocking();

[Daniel Erat, 2012/10/11 15:08:30]

i think that the IsTryingToLock() vs. IsLocking() vs. CanCancelLock()
distinction is confusing.

how about 

CanCancelLock() -> InLockTimeout()
IsTryingToLock() -> LockRequested()
StartCancellableLock() -> StartLockTimeout()
CancelLock() -> CancelLockTimeout()
remove IsLocking()

?

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+
+  // Returns true if we are shutting down.
+  virtual bool IsShuttingDown();
+
+  // Returns true if we are within cancellable lock timeframe.
+  virtual bool CanCancelLock();
+
+  // Cancels locking and reverts lock animation.
+  virtual void CancelLock();
+
+  // Cancels locking and reverts lock animation with slightly different
+  // parameters. Seems to be some bug, but refactoring should keep all bugs.

[Daniel Erat, 2012/10/11 15:08:30]

add a TODO to remove this; put the explanation there

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+  virtual void CancelLockWithOtherAnimation();
+
+  // Returns true if we are within cancellable shutdown timeframe.
+  virtual bool CanCancelShutdown();

[Daniel Erat, 2012/10/11 15:08:30]

i recommend the same thing here:

CanCancelShutdown() -> InShutdownTimeout()
CancelShutdown() -> CancelShutdownTimeout()

this makes it clearer from the title that we're just canceling a pre-shutdown
timeout rather than somehow actually canceling shutdown.

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+
+  // Cancels shutting down and reverts shutdown animation.
+  virtual void CancelShutdown();
+
+

[Daniel Erat, 2012/10/11 15:08:30]

nit: delete extra blank line

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+  // Called when Chrome gets a request to display the lock screen.
+  virtual void OnStartingLock();
+
+  // Displays the shutdown animation and requests shutdown when it's done.
+  virtual void RequestShutdown();
+
+

[Daniel Erat, 2012/10/11 15:08:30]

nit: delete extra blank line

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+  // RootWindowObserver override:
+  virtual void OnRootWindowHostCloseRequested(
+                                   const aura::RootWindow* root) OVERRIDE;

[Daniel Erat, 2012/10/11 15:08:30]

nit: fix indenting

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+
+  // ShellObserver overrides:
+  virtual void OnLoginStateChanged(user::LoginStatus status) OVERRIDE;
+  virtual void OnAppTerminating() OVERRIDE;
+  virtual void OnLockStateChanged(bool locked) OVERRIDE;
+
+ protected:
+  friend class test::PowerButtonControllerTest;
+
+  bool LoggedInAsNonGuest() const;
+
+

[Daniel Erat, 2012/10/11 15:08:30]

nit: delete extra blank line

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+ private:
+  void RequestShutdownImpl();
+
+  // Timer stuff.

[Daniel Erat, 2012/10/11 15:08:30]

nit: delete unnecessary comment

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+
+  // Starts lock timer.
+  void StartLockTimer();
+
+  // Requests that the screen be locked and starts |lock_fail_timer_|.
+  void OnLockTimeout();
+
+  // Reverts the pre-lock animation, reports the error.
+  void OnLockFailTimeout();
+
+  // Starts timer for gap between lock and shutdown.
+  void StartLockToShutdownTimer();
+  // Calls StartCancellableShutdown().

[Daniel Erat, 2012/10/11 15:08:30]

nit: add blank line before this one

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+  void OnLockToShutdownTimeout();
+
+  // Starts timer for undoable shutdown animation.
+  void StartPreShutdownAnimationTimer();
+  // Calls RequestShutdownImpl();

[Daniel Erat, 2012/10/11 15:08:30]

nit: add blank line before this one

[Denis Kuznetsov (DE-MUC), 2012/10/11 16:14:38]

Done.

+  void OnPreShutdownAnimationTimeout();
+
+  // Starts timer for final shutdown animation.
+  void StartRealShutdownTimer();
+  // Requests that the machine be shut down.
+  void OnRealShutdownTimeout();
+
+  // The current login status.
+  user::LoginStatus login_status_;
+
+  // Original login status during locked.  LOGGED_IN_NONE if it's not locked.
+  user::LoginStatus unlocked_login_status_;
+
+  // Are we in the process of shutting the machine down?
+  bool shutting_down_;
+
+  // Indicates whether controller should proceed to (cancellable) shutdown after
+  // locking.
+  bool shutdown_after_lock_;
+
+  // Started when the user first presses the power button while in a
+  // logged-in-as-a-non-guest-user, unlocked state.  When it fires, we lock the
+  // screen.
+  base::OneShotTimer<SessionStateController> lock_timer_;
+
+  // Started when we request that the screen be locked.  When it fires, we
+  // assume that our request got dropped.
+  base::OneShotTimer<SessionStateController> 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<SessionStateController> 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<SessionStateController> 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<SessionStateController> real_shutdown_timer_;
+
+  scoped_ptr<internal::SessionStateAnimator> animator_;
+
+  scoped_ptr<SessionStateControllerDelegate> delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(SessionStateController);
+};
+
+}  // namespace ash
+
+#endif  // ASH_WM_SESSION_STATE_CONTROLLER_H_