mash: remove the LockStateControllerDelegate.

ash/wm/lock_state_controller.h

 // Copyright 2013 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_LOCK_STATE_CONTROLLER_H_
 #define ASH_WM_LOCK_STATE_CONTROLLER_H_
 
 #include <memory>
 
 #include "ash/ash_export.h"
 #include "ash/common/shell_observer.h"
+#include "ash/public/interfaces/shutdown.mojom.h"

[James Cook, 2016/11/02 20:20:03]

Can this be forward declared?

[Elliot Glaysher, 2016/11/02 21:45:16]

Done.

 #include "ash/wm/session_state_animator.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/timer/timer.h"
 #include "ui/aura/window_tree_host_observer.h"
 
 namespace gfx {
 class Rect;
 class Size;
 }
 
+namespace service_manager {
+class Connector;
+}
+
 namespace ui {
 class Layer;
 }
 
 namespace ash {
 
 namespace test {
 class LockStateControllerTest;
 class PowerButtonControllerTest;
 }
 
-// Performs system-related functions on behalf of LockStateController.
-class ASH_EXPORT LockStateControllerDelegate {
- public:
-  LockStateControllerDelegate() {}
-  virtual ~LockStateControllerDelegate() {}
-
-  virtual void RequestShutdown() = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LockStateControllerDelegate);
-};
-
 // 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 (bool shutdown after lock) - starts
 //    uninterruptible lock animation.
 // This leads to call of either StartImmediatePreLockAnimation or
 // StartCancellablePreLockAnimation. Once they complete
@@ skipping 28 matching lines @@
   // of time that we wait after the screen locker window is shown before
   // starting the pre-shutdown animation.
   static const int kLockToShutdownTimeoutMs;
 
   // Additional time (beyond kFastCloseAnimMs) to wait after starting the
   // fast-close shutdown animation before actually requesting shutdown, to give
   // the animation time to finish.
   static const int kShutdownRequestDelayMs;
 
   // Helper class used by tests to access internal state.
   class ASH_EXPORT TestApi {

[James Cook, 2016/11/02 20:20:03]

What do you think about moving the test API to a separate class/file? (It
wouldn't need to be in this CL.)

    public:
     explicit TestApi(LockStateController* controller);
 
     virtual ~TestApi();
 
+    void SetShutdownClient(std::unique_ptr<mojom::ShutdownClient> client);
+
     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 {
@@ skipping 20 matching lines @@
       controller_->OnRealPowerTimeout();
       controller_->real_shutdown_timer_.Stop();
     }
 
    private:
     LockStateController* controller_;  // not owned
 
     DISALLOW_COPY_AND_ASSIGN(TestApi);
   };
 
-  LockStateController();
+  LockStateController(service_manager::Connector* connector);

[James Cook, 2016/11/02 20:20:03]

nit: explicit

[Elliot Glaysher, 2016/11/02 21:45:16]

Done.

   ~LockStateController() override;
 
-  void SetDelegate(std::unique_ptr<LockStateControllerDelegate> delegate);
-
   // Starts locking (with slow animation) that can be cancelled.
   // After locking and |kLockToShutdownTimeoutMs| StartShutdownAnimation()
   // will be called unless CancelShutdownAnimation() is called, if
   // |shutdown_after_lock| is true.
   void StartLockAnimation(bool shutdown_after_lock);
 
   // Starts shutting down (with slow animation) that can be cancelled.
   void StartShutdownAnimation();
 
   // Starts usual lock animation, but locks immediately.  After locking and
@@ skipping 110 matching lines @@
       ash::SessionStateAnimator::AnimationSpeed speed,
       SessionStateAnimator::AnimationSequence* animation_sequence);
 
   // Fades out wallpaper layer with |speed| if it was hidden in unlocked state.
   void AnimateWallpaperHidingIfNecessary(
       ash::SessionStateAnimator::AnimationSpeed speed,
       SessionStateAnimator::AnimationSequence* animation_sequence);
 
   std::unique_ptr<SessionStateAnimator> animator_;
 
-  std::unique_ptr<LockStateControllerDelegate> delegate_;
-
   // The current login status, or original login status from before we locked.
   LoginStatus login_status_;
 
   // Current lock status.
   bool system_is_locked_;
 
   // 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_;
 
   // Indicates that controller displays lock animation.
   bool animating_lock_;
 
   // Indicates that lock animation can be undone.
   bool can_cancel_lock_animation_;
 
   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_;
 
+  // The client that we request to shut down the machine.
+  std::unique_ptr<mojom::ShutdownClient> shutdown_client_;
+
   // 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 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 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 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 real_shutdown_timer_;
 
   base::Closure lock_screen_displayed_callback_;
 
   base::WeakPtrFactory<LockStateController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LockStateController);
 };
 
 }  // namespace ash
 
 #endif  // ASH_WM_LOCK_STATE_CONTROLLER_H_