mash: remove the LockStateControllerDelegate.

ash/wm/lock_state_controller.cc

 // 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.
 
 #include "ash/wm/lock_state_controller.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "ash/cancel_mode.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/shell_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "ash/public/cpp/shell_window_ids.h"
+#include "ash/public/interfaces/shutdown.mojom.h"
 #include "ash/shell.h"
 #include "ash/wm/session_state_animator.h"
 #include "ash/wm/session_state_animator_impl.h"
+#include "ash/wm/shutdown_client_proxy.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/timer/timer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/views/controls/menu/menu_controller.h"
@@ skipping 39 matching lines @@
 
 const int LockStateController::kLockFailTimeoutMs = 8000 * kTimeoutMultiplier;
 const int LockStateController::kLockToShutdownTimeoutMs = 150;
 const int LockStateController::kShutdownRequestDelayMs = 50;
 
 LockStateController::TestApi::TestApi(LockStateController* controller)
     : controller_(controller) {}
 
 LockStateController::TestApi::~TestApi() {}
 
-LockStateController::LockStateController()
+void LockStateController::TestApi::SetShutdownClient(
+    std::unique_ptr<mojom::ShutdownClient> client) {
+  controller_->shutdown_client_ = std::move(client);
+}
+
+LockStateController::LockStateController(service_manager::Connector* connector)
     : animator_(new SessionStateAnimatorImpl()),
       login_status_(LoginStatus::NOT_LOGGED_IN),
       system_is_locked_(false),
       shutting_down_(false),
       shutdown_after_lock_(false),
       animating_lock_(false),
       can_cancel_lock_animation_(false),
+      shutdown_client_(new ShutdownClientProxy(connector)),
       weak_ptr_factory_(this) {
   Shell::GetPrimaryRootWindow()->GetHost()->AddObserver(this);
 }
 
 LockStateController::~LockStateController() {
   Shell::GetPrimaryRootWindow()->GetHost()->RemoveObserver(this);
 }
 
-void LockStateController::SetDelegate(
-    std::unique_ptr<LockStateControllerDelegate> delegate) {
-  delegate_ = std::move(delegate);
-}
-
 void LockStateController::StartLockAnimation(bool shutdown_after_lock) {
   if (animating_lock_)
     return;
   shutdown_after_lock_ = shutdown_after_lock;
   can_cancel_lock_animation_ = true;
 
   StartCancellablePreLockAnimation();
 }
 
 void LockStateController::StartShutdownAnimation() {
@@ skipping 209 matching lines @@
 #if defined(OS_CHROMEOS)
   if (!base::SysInfo::IsRunningOnChromeOS()) {
     ShellDelegate* delegate = WmShell::Get()->delegate();
     if (delegate) {
       delegate->Exit();
       return;
     }
   }
 #endif
   WmShell::Get()->RecordUserMetricsAction(UMA_ACCEL_SHUT_DOWN_POWER_BUTTON);
-  delegate_->RequestShutdown();
+
+  // Connect to the browser to tell it to shutdown the computer. It will either

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

Thanks for the detailed docs and TODO.

+  // shut down or restart the computer based on the device settings.
+  //
+  // TODO(erg): Once CrosSettings has been moved out of chrome/,
+  // LockStateController should become a preference observer of it, and we
+  // should move the current content_browser implementation here.
+  // crbug.com/628792
+  shutdown_client_->RequestShutdown();
 }
 
 void LockStateController::StartCancellableShutdownAnimation() {
   Shell* shell = Shell::GetInstance();
   // Hide cursor, but let it reappear if the mouse moves.
   shell->cursor_manager()->HideCursor();
 
   animator_->StartAnimation(
       SessionStateAnimator::ROOT_CONTAINER,
       SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS,
@@ skipping 237 matching lines @@
     SessionStateAnimator::AnimationSpeed speed,
     SessionStateAnimator::AnimationSequence* animation_sequence) {
   if (unlocked_properties_.get() && unlocked_properties_->wallpaper_is_hidden) {
     animation_sequence->StartAnimation(SessionStateAnimator::WALLPAPER,
                                        SessionStateAnimator::ANIMATION_FADE_OUT,
                                        speed);
   }
 }
 
 }  // namespace ash