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/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 mojom {
+class ShutdownClient;
+}
+
 namespace test {
 class LockStateControllerTest;
+class LockStateControllerTestApi;
 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 27 matching lines @@
   // 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.
   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 {
-   public:
-    explicit TestApi(LockStateController* 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 {
-      return controller_->pre_shutdown_timer_.IsRunning();
-    }
-    bool real_shutdown_timer_is_running() const {
-      return controller_->real_shutdown_timer_.IsRunning();
-    }
-    bool is_animating_lock() const { return controller_->animating_lock_; }
-    bool is_lock_cancellable() const {
-      return controller_->CanCancelLockAnimation();
-    }
-
-    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_->OnRealPowerTimeout();
-      controller_->real_shutdown_timer_.Stop();
-    }
-
-   private:
-    LockStateController* controller_;  // not owned
-
-    DISALLOW_COPY_AND_ASSIGN(TestApi);
-  };
-
-  LockStateController();
+  explicit LockStateController(service_manager::Connector* connector);
   ~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 44 matching lines @@
   void OnAppTerminating() override;
   void OnLockStateChanged(bool locked) override;
 
   void set_animator_for_test(SessionStateAnimator* animator) {
     animator_.reset(animator);
   }
 
  private:
   friend class test::PowerButtonControllerTest;
   friend class test::LockStateControllerTest;
+  friend class test::LockStateControllerTestApi;
 
   struct UnlockedStateProperties {
     bool wallpaper_is_hidden;
   };
 
   // Reverts the pre-lock animation, reports the error.
   void OnLockFailTimeout();
 
   // Starts timer for gap between lock and shutdown.
   void StartLockToShutdownTimer();
@@ skipping 46 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_