ash / wm / lock_state_controller.h [blame]

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef ASH_WM_LOCK_STATE_CONTROLLER_H_
#define ASH_WM_LOCK_STATE_CONTROLLER_H_

#include <memory>
#include <optional>

#include "ash/ash_export.h"
#include "ash/public/cpp/session/session_observer.h"
#include "ash/shutdown_reason.h"
#include "ash/wallpaper/wallpaper_constants.h"
#include "ash/wm/lock_state_observer.h"
#include "ash/wm/session_state_animator.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/timer/elapsed_timer.h"
#include "base/timer/timer.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "third_party/cros_system_api/dbus/power_manager/dbus-constants.h"
#include "ui/aura/window_tree_host_observer.h"
#include "ui/gfx/image/image.h"

namespace ash {

class ShutdownController;
enum class ShutdownReason;

// Displays onscreen animations and locks or suspends the system in response to
// the power button being pressed or released.
// Lock workflow:
// Entry point:
//  * StartLockAnimation (bool shutdown after lock) - starts lock that can be
//    cancelled.
// Once it completes, 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
// StartUnlockAnimationAfterLockUIDestroyed.
class ASH_EXPORT LockStateController : public aura::WindowTreeHostObserver,
                                       public SessionObserver {
 public:
  // A bitfield mask including NON_LOCK_SCREEN_CONTAINERS and LAUNCHER, used for
  // pre-lock hiding animation.
  static const int kPreLockContainersMask;

  LockStateController(ShutdownController* shutdown_controller,
                      PrefService* local_state);

  LockStateController(const LockStateController&) = delete;
  LockStateController& operator=(const LockStateController&) = delete;

  ~LockStateController() override;

  static void RegisterPrefs(PrefRegistrySimple* registry);

  void AddObserver(LockStateObserver* observer);
  void RemoveObserver(LockStateObserver* observer);

  // Starts locking (with slow pre-lock animation) that can be cancelled.
  void StartLockAnimation();

  // Starts locking without slow animation.
  void LockWithoutAnimation();

  // Returns true if we have requested system to lock, but haven't received
  // confirmation yet.
  bool LockRequested();

  // Cancels locking and reverts lock animation.
  void CancelLockAnimation();

  // Called when ScreenLocker is ready to close, but not yet destroyed.
  // Can be used to display "hiding" animations on unlock.
  // |callback| will be called when all animations are done.
  void OnLockScreenHide(SessionStateAnimator::AnimationCallback callback);

  // Sets up the callback that should be called once lock animation is finished.
  // Callback is guaranteed to be called once and then discarded.
  void SetLockScreenDisplayedCallback(base::OnceClosure callback);

  // Displays the shutdown animation and requests a system shutdown or system
  // restart depending on the the state of the |RebootOnShutdown| device policy.
  void RequestShutdown(ShutdownReason reason);

  // The difference between this and `RequestShutdown` is that this one starts
  // the shutdown that can be canceled. Note, please use only when necessary and
  // together with `MaybeCancelShutdownAnimation`. E.g., requesting through the
  // physical power button, while pressing the power button with different
  // duration can lead to different shutdown states.
  void RequestCancelableShutdown(ShutdownReason reason);

  // True if the real non-cancelable shutting down started.
  bool ShutdownRequested() const;

  // Reverts the shutdown animation and updates the shutdown state to canceled.
  // Then the shutdown process will not move forward. Returns true if the
  // shutdown is canceled, otherwise false.
  bool MaybeCancelShutdownAnimation();

  // Requests restart with the same animation as `RequestShutdown` and take the
  // informed restore image if forest feature is enabled, restart directly
  // otherwise. `description` is a human-readable string describing the source
  // of request the restart.
  void RequestRestart(power_manager::RequestRestartReason reason,
                      const std::string& description);

  // Requests sign out with the same animation as `RequestShutdown` and take the
  // informed restore image if forest feature is enabled, sign out directly
  // otherwise.
  void RequestSignOut();

  // aura::WindowTreeHostObserver override:
  void OnHostCloseRequested(aura::WindowTreeHost* host) override;

  // SessionObserver overrides:
  void OnChromeTerminating() override;
  void OnLockStateChanged(bool locked) override;

  void set_animator_for_test(SessionStateAnimator* animator) {
    animator_.reset(animator);
  }
  bool animating_lock_for_test() const { return animating_lock_; }

 private:
  friend class LockStateControllerTestApi;

  struct UnlockedStateProperties {
    bool wallpaper_is_hidden;
  };

  // Specifies the requested session state.
  enum class RequestedSessionState {
    kShutdown = 0,
    kCancelableShutdown,
    kRestart,
    kSignOut,
  };

  // Cancels unlock animation.
  void CancelUnlockAnimation();

  // Reverts the pre-lock animation, reports the error.
  void OnLockFailTimeout();

  void PreLockAnimation(SessionStateAnimator::AnimationSpeed speed,
                        bool request_lock_on_completion);
  void StartPostLockAnimation();
  void OnPostLockFailTimeout();
  // This method calls |callback| when animation completes.
  void StartUnlockAnimationBeforeLockUIDestroyed(base::OnceClosure callback);
  void StartUnlockAnimationAfterLockUIDestroyed();

  // These methods are called when corresponding animation completes.
  void LockAnimationCancelled(bool aborted);
  void PreLockAnimationFinished(bool request_lock, bool aborted);
  void PostLockAnimationFinished(bool aborted);
  void UnlockAnimationAfterLockUIDestroyedFinished(bool aborted);

  // Stores properties of UI that have to be temporarily modified while locking.
  void StoreUnlockedProperties();
  void RestoreUnlockedProperties();

  // Fades in wallpaper layer with |speed| if it was hidden in unlocked state.
  void AnimateWallpaperAppearanceIfNecessary(
      SessionStateAnimator::AnimationSpeed speed,
      SessionStateAnimator::AnimationSequence* animation_sequence);

  // Fades out wallpaper layer with |speed| if it was hidden in unlocked state.
  void AnimateWallpaperHidingIfNecessary(
      SessionStateAnimator::AnimationSpeed speed,
      SessionStateAnimator::AnimationSequence* animation_sequence);

  // Passed as a callback to the animation sequence that runs as part of
  // StartUnlockAnimationBeforeLockUIDestroyed. The callback will be invoked
  // after the animations complete, it will then check if the power button was
  // pressed at all during the unlock animation, and if so, immediately revert
  // the animations and notify ScreenLocker that the unlock process is to be
  // aborted.
  void OnUnlockAnimationBeforeLockUIDestroyedFinished();

  // Notifies observers.
  void OnLockStateEvent(LockStateObserver::EventType event);

  // Starts timer for undoable shutdown animation.
  void StartPreShutdownAnimationTimer();

  // Calls `StartSessionStateChangeTimer()` with
  // `RequestedSessionState::kCancelableShutdown` when
  // `cancelable_shutdown_timer_` expires.
  void OnPreShutdownAnimationTimeout();

  // Starts timer for final session state change animation. If
  // `with_animation_time` is true, it will also include time of "fade to white"
  // shutdown animation (NOTE: we are using the same animation for restart and
  // signout as well). If `requested_session_state` is shutdown related,
  // shutdown sound duration will be included in the duration calculation as
  // well.
  void StartSessionStateChangeTimer(
      bool with_animation_time,
      RequestedSessionState requested_session_state);

  // Called by `session_state_change_timer_` to start the
  // `requested_session_state` change.
  void OnSessionStateChangeTimeout(
      RequestedSessionState requested_session_state);

  // Takes a screenshot for the informed restore dialog first and then starts
  // the session state change process. `requested_session_state` indicates the
  // requested session state.
  void SessionStateChangeWithInformedRestore(
      RequestedSessionState requested_session_state);

  // Binds to a callback that will be called by the DLP manager to let us know
  // whether capturing the screenshot should `proceed` or abort due to some
  // restricted contents on the screen. `requested_session_state` indicates the
  // requested session state change.
  void OnDlpRestrictionCheckedAtScreenCapture(
      RequestedSessionState requested_session_state,
      const base::FilePath& file_path,
      bool proceed);

  // Starts the session state change process with the given
  // `requested_session_state`.
  void StartSessionStateChange(RequestedSessionState requested_session_state);

  // Triggers the session state change process when the
  // `take_screenshot_fail_timer_` times out. `requested_session_state`
  // indicates the requested session state change.
  void OnTakeScreenshotFailTimeout(
      RequestedSessionState requested_session_state);

  // Callback invoked once the image is taken. `requested_session_state`
  // indicates the requested session state after the image had been taken.
  // `file_path` indicates the path to save the informed restore image. Note:
  // `gfx::Image` is cheap to pass by value.
  void OnInformedRestoreImageTaken(
      RequestedSessionState requested_session_state,
      const base::FilePath& file_path,
      base::TimeTicks start_time,
      gfx::Image informed_restore_image);

  // Callback invoked when the informed restore image was encoded and saved.
  // `file_path` is the file path to save the informed restore image.
  void OnInformedRestoreImageSaved(base::TimeTicks start_time,
                                   const base::FilePath& file_path);

  // Called when `session_state_change_timer_` times out with `kRestart`
  // requested.
  void DoRestart(power_manager::RequestRestartReason reason,
                 const std::string& description);

  std::unique_ptr<SessionStateAnimator> animator_;

  // Current lock status.
  bool system_is_locked_ = false;

  // True if the real non-cancelable shutting down process started.
  bool shutting_down_ = false;

  // True if the requested cancelable shutdown gets canceled.
  bool shutdown_canceled_ = false;

  // The reason (e.g. user action) for a pending shutdown.
  std::optional<ShutdownReason> shutdown_reason_;

  // Callback bound on restart requested and run when
  // `session_state_change_timer_` times out.
  base::OnceClosure restart_callback_;

  // Indicates whether controller should proceed to (cancellable) shutdown after
  // locking.
  bool shutdown_after_lock_ = false;

  // Indicates that controller displays lock animation.
  bool animating_lock_ = false;

  // Indicates that controller displays unlock animation.
  bool animating_unlock_ = false;

  // Indicates that the power button has been pressed during the unlock
  // animation
  bool pb_pressed_during_unlock_ = false;

  // Indicates whether post lock animation should be immediate.
  bool post_lock_immediate_animation_ = false;

  std::unique_ptr<UnlockedStateProperties> unlocked_properties_;

  // How long has it been since the request to lock the screen?
  std::unique_ptr<base::ElapsedTimer> lock_duration_timer_;

  // Controller used to trigger the actual shutdown.
  raw_ptr<ShutdownController, DanglingUntriaged> shutdown_controller_;

  // Started when we request that the screen be locked. When it fires, we
  // assume that our request got dropped.
  base::OneShotTimer lock_fail_timer_;

  // Started when we call StartPostLockAnimation. When it fires, we assume
  // that our request got dropped.
  base::OneShotTimer post_lock_fail_timer_;

  // Started when a cancelable shutdown requested and the shutdown animation
  // triggered. When it fires, the real non-cancelable shutdown will start.
  base::OneShotTimer cancelable_shutdown_timer_;

  // Started when we display the session state change animation (NOTE, shutdown,
  // restart and signout have the same animation). When it fires, we actually
  // request the session state change. Gives the animation time to complete
  // before Chrome etc are shut down.
  base::OneShotTimer session_state_change_timer_;

  base::OnceClosure lock_screen_displayed_callback_;

  base::OnceCallback<void(bool)> start_unlock_callback_;

  // A new layer that mirrors the wallpaper layer, which will be added to the
  // layer hierarchy and help include the wallpaper into the informed restore
  // screenshot.
  std::unique_ptr<ui::Layer> mirror_wallpaper_layer_;

  // A timer tracks the time duration it takes to take the informed restore
  // image. If this timer timeouts before taking the screenshot completes, the
  // shutdown process will be triggered immediately without the informed restore
  // image. This is done to avoid the shutdown process being blocked too long to
  // be noticed by the users.
  base::OneShotTimer take_screenshot_fail_timer_;

  ScopedSessionObserver scoped_session_observer_;

  // The wallpaper blur before entering lock state. Used to restore the
  // wallpaper blur after exiting lock state.
  float saved_blur_;

  base::ObserverList<LockStateObserver>::Unchecked observers_;

  // To access the pref kLoginShutdownTimestampPrefName
  raw_ptr<PrefService> local_state_;

  // If set, it will be called once the operation on the informed restore image
  // is completed, either it was deleted or saved to the disk.
  base::OnceClosure informed_restore_image_callback_for_test_;

  // Disables the `take_screenshot_fail_timer_` for test, which means the timer
  // will never start if this is set to true.
  bool disable_screenshot_timeout_for_test_ = false;

  base::WeakPtrFactory<LockStateController> weak_ptr_factory_{this};
};

}  // namespace ash

#endif  // ASH_WM_LOCK_STATE_CONTROLLER_H_