ash/wm/session_state_controller_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ash/wm/session_state_controller_impl.h"
   6
   7 #include "ash/ash_switches.h"
   8 #include "ash/cancel_mode.h"
   9 #include "ash/shell.h"
  10 #include "ash/shell_delegate.h"
  11 #include "ash/shell_window_ids.h"
  12 #include "ash/wm/session_state_animator.h"
  13 #include "base/command_line.h"
  14 #include "ui/aura/root_window.h"
  15 #include "ui/views/corewm/compound_event_filter.h"
  16
  17 #if defined(OS_CHROMEOS)
  18 #include "base/chromeos/chromeos_version.h"
  19 #endif
  20
  21 namespace ash {
  22
  23 SessionStateControllerImpl::TestApi::TestApi(
  24     SessionStateControllerImpl* controller)
  25     : controller_(controller) {
  26 }
  27
  28 SessionStateControllerImpl::TestApi::~TestApi() {
  29 }
  30
  31 SessionStateControllerImpl::SessionStateControllerImpl()
  32     : login_status_(user::LOGGED_IN_NONE),
  33       system_is_locked_(false),
  34       shutting_down_(false),
  35       shutdown_after_lock_(false) {
  36   Shell::GetPrimaryRootWindow()->AddRootWindowObserver(this);
  37 }
  38
  39 SessionStateControllerImpl::~SessionStateControllerImpl() {
  40   Shell::GetPrimaryRootWindow()->RemoveRootWindowObserver(this);
  41 }
  42
  43 void SessionStateControllerImpl::OnLoginStateChanged(user::LoginStatus status) {
  44   if (status != user::LOGGED_IN_LOCKED)
  45     login_status_ = status;
  46   system_is_locked_ = (status == user::LOGGED_IN_LOCKED);
  47 }
  48
  49 void SessionStateControllerImpl::OnAppTerminating() {
  50   // If we hear that Chrome is exiting but didn't request it ourselves, all we
  51   // can really hope for is that we'll have time to clear the screen.
  52   if (!shutting_down_) {
  53     shutting_down_ = true;
  54     Shell* shell = ash::Shell::GetInstance();
  55     shell->env_filter()->set_cursor_hidden_by_filter(false);
  56     shell->cursor_manager()->HideCursor();
  57     animator_->StartAnimation(
  58         internal::SessionStateAnimator::kAllContainersMask,
  59         internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
  60         internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
  61   }
  62 }
  63
  64 void SessionStateControllerImpl::OnLockStateChanged(bool locked) {
  65   if (shutting_down_ || (system_is_locked_ == locked))
  66     return;
  67
  68   system_is_locked_ = locked;
  69
  70   if (locked) {
  71     animator_->StartAnimation(
  72         internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
  73         internal::SessionStateAnimator::ANIMATION_FADE_IN,
  74         internal::SessionStateAnimator::ANIMATION_SPEED_SHOW_LOCK_SCREEN);
  75     DispatchCancelMode();
  76     FOR_EACH_OBSERVER(LockStateObserver, observers_,
  77         OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_STARTED));
  78     lock_timer_.Stop();
  79     lock_fail_timer_.Stop();
  80
  81     if (shutdown_after_lock_) {
  82       shutdown_after_lock_ = false;
  83       StartLockToShutdownTimer();
  84     }
  85   } else {
  86     animator_->StartAnimation(
  87         internal::SessionStateAnimator::DESKTOP_BACKGROUND |
  88         internal::SessionStateAnimator::LAUNCHER |
  89         internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
  90         internal::SessionStateAnimator::ANIMATION_RESTORE,
  91         internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
  92   }
  93 }
  94
  95 void SessionStateControllerImpl::OnStartingLock() {
  96   if (shutting_down_ || system_is_locked_)
  97     return;
  98
  99   animator_->StartAnimation(
 100       internal::SessionStateAnimator::LAUNCHER,
 101       internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
 102       internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
 103
 104   animator_->StartAnimation(
 105       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
 106       internal::SessionStateAnimator::ANIMATION_FULL_CLOSE,
 107       internal::SessionStateAnimator::ANIMATION_SPEED_FAST);
 108
 109   DispatchCancelMode();
 110   FOR_EACH_OBSERVER(LockStateObserver, observers_,
 111       OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_STARTED));
 112
 113   // Hide the screen locker containers so we can make them fade in later.
 114   animator_->StartAnimation(
 115       internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
 116       internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
 117       internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
 118 }
 119
 120 void SessionStateControllerImpl::StartLockAnimationAndLockImmediately() {
 121   animator_->StartAnimation(
 122       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
 123       internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE,
 124       internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
 125   DispatchCancelMode();
 126   FOR_EACH_OBSERVER(LockStateObserver, observers_,
 127       OnLockStateEvent(LockStateObserver::EVENT_LOCK_ANIMATION_STARTED));
 128   OnLockTimeout();
 129 }
 130
 131 void SessionStateControllerImpl::StartLockAnimation(bool shutdown_after_lock) {
 132   shutdown_after_lock_ = shutdown_after_lock;
 133
 134   animator_->StartAnimation(
 135       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
 136       internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE,
 137       internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
 138   DispatchCancelMode();
 139   FOR_EACH_OBSERVER(LockStateObserver, observers_,
 140       OnLockStateEvent(LockStateObserver::EVENT_PRELOCK_ANIMATION_STARTED));
 141   StartLockTimer();
 142 }
 143
 144 void SessionStateControllerImpl::StartShutdownAnimation() {
 145   animator_->StartAnimation(
 146       internal::SessionStateAnimator::kAllContainersMask,
 147       internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE,
 148       internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
 149
 150   StartPreShutdownAnimationTimer();
 151 }
 152
 153 bool SessionStateControllerImpl::LockRequested() {
 154   return lock_fail_timer_.IsRunning();
 155 }
 156
 157 bool SessionStateControllerImpl::ShutdownRequested() {
 158   return shutting_down_;
 159 }
 160
 161 bool SessionStateControllerImpl::CanCancelLockAnimation() {
 162   return lock_timer_.IsRunning();
 163 }
 164
 165 void SessionStateControllerImpl::CancelLockAnimation() {
 166   if (!CanCancelLockAnimation())
 167     return;
 168   shutdown_after_lock_ = false;
 169   animator_->StartAnimation(
 170       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
 171       internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE,
 172       internal::SessionStateAnimator::ANIMATION_SPEED_REVERT);
 173   lock_timer_.Stop();
 174 }
 175
 176 bool SessionStateControllerImpl::CanCancelShutdownAnimation() {
 177   return pre_shutdown_timer_.IsRunning() ||
 178          shutdown_after_lock_ ||
 179          lock_to_shutdown_timer_.IsRunning();
 180 }
 181
 182 void SessionStateControllerImpl::CancelShutdownAnimation() {
 183   if (!CanCancelShutdownAnimation())
 184     return;
 185   if (lock_to_shutdown_timer_.IsRunning()) {
 186     lock_to_shutdown_timer_.Stop();
 187     return;
 188   }
 189   if (shutdown_after_lock_) {
 190     shutdown_after_lock_ = false;
 191     return;
 192   }
 193
 194   if (system_is_locked_) {
 195     // If we've already started shutdown transition at lock screen
 196     // desktop background needs to be restored immediately.
 197     animator_->StartAnimation(
 198         internal::SessionStateAnimator::DESKTOP_BACKGROUND,
 199         internal::SessionStateAnimator::ANIMATION_RESTORE,
 200         internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
 201     animator_->StartAnimation(
 202         internal::SessionStateAnimator::kAllLockScreenContainersMask,
 203         internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE,
 204         internal::SessionStateAnimator::ANIMATION_SPEED_REVERT);
 205   } else {
 206     animator_->StartAnimation(
 207         internal::SessionStateAnimator::kAllContainersMask,
 208         internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE,
 209         internal::SessionStateAnimator::ANIMATION_SPEED_REVERT);
 210   }
 211   pre_shutdown_timer_.Stop();
 212 }
 213
 214 void SessionStateControllerImpl::RequestShutdown() {
 215   if (!shutting_down_)
 216     RequestShutdownImpl();
 217 }
 218
 219 void SessionStateControllerImpl::RequestShutdownImpl() {
 220   DCHECK(!shutting_down_);
 221   shutting_down_ = true;
 222
 223   Shell* shell = ash::Shell::GetInstance();
 224   shell->env_filter()->set_cursor_hidden_by_filter(false);
 225   shell->cursor_manager()->HideCursor();
 226
 227   if (login_status_ != user::LOGGED_IN_NONE) {
 228     // Hide the other containers before starting the animation.
 229     // ANIMATION_FULL_CLOSE will make the screen locker windows partially
 230     // transparent, and we don't want the other windows to show through.
 231     animator_->StartAnimation(
 232         internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
 233         internal::SessionStateAnimator::LAUNCHER,
 234         internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY,
 235         internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
 236     animator_->StartAnimation(
 237         internal::SessionStateAnimator::kAllLockScreenContainersMask,
 238         internal::SessionStateAnimator::ANIMATION_FULL_CLOSE,
 239         internal::SessionStateAnimator::ANIMATION_SPEED_FAST);
 240   } else {
 241     animator_->StartAnimation(
 242         internal::SessionStateAnimator::kAllContainersMask,
 243         internal::SessionStateAnimator::ANIMATION_FULL_CLOSE,
 244         internal::SessionStateAnimator::ANIMATION_SPEED_FAST);
 245   }
 246   StartRealShutdownTimer();
 247 }
 248
 249 void SessionStateControllerImpl::OnRootWindowHostCloseRequested(
 250                                                 const aura::RootWindow*) {
 251   Shell::GetInstance()->delegate()->Exit();
 252 }
 253
 254 void SessionStateControllerImpl::StartLockTimer() {
 255   lock_timer_.Stop();
 256   lock_timer_.Start(
 257       FROM_HERE,
 258       animator_->GetDuration(
 259           internal::SessionStateAnimator::ANIMATION_SPEED_UNDOABLE),
 260       this, &SessionStateControllerImpl::OnLockTimeout);
 261 }
 262
 263 void SessionStateControllerImpl::OnLockTimeout() {
 264   delegate_->RequestLockScreen();
 265   lock_fail_timer_.Start(
 266       FROM_HERE,
 267       base::TimeDelta::FromMilliseconds(kLockFailTimeoutMs),
 268       this, &SessionStateControllerImpl::OnLockFailTimeout);
 269 }
 270
 271 void SessionStateControllerImpl::OnLockFailTimeout() {
 272   DCHECK(!system_is_locked_);
 273   // Undo lock animation.
 274   animator_->StartAnimation(
 275       internal::SessionStateAnimator::LAUNCHER |
 276       internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
 277       internal::SessionStateAnimator::ANIMATION_RESTORE,
 278       internal::SessionStateAnimator::ANIMATION_SPEED_IMMEDIATE);
 279 }
 280
 281 void SessionStateControllerImpl::StartLockToShutdownTimer() {
 282   shutdown_after_lock_ = false;
 283   lock_to_shutdown_timer_.Stop();
 284   lock_to_shutdown_timer_.Start(
 285       FROM_HERE,
 286       base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
 287       this, &SessionStateControllerImpl::OnLockToShutdownTimeout);
 288 }
 289
 290
 291 void SessionStateControllerImpl::OnLockToShutdownTimeout() {
 292   DCHECK(system_is_locked_);
 293   StartShutdownAnimation();
 294 }
 295
 296 void SessionStateControllerImpl::StartPreShutdownAnimationTimer() {
 297   pre_shutdown_timer_.Stop();
 298   pre_shutdown_timer_.Start(
 299       FROM_HERE,
 300       base::TimeDelta::FromMilliseconds(kShutdownTimeoutMs),
 301       this, &SessionStateControllerImpl::OnPreShutdownAnimationTimeout);
 302 }
 303
 304 void SessionStateControllerImpl::OnPreShutdownAnimationTimeout() {
 305   if (!shutting_down_)
 306     RequestShutdownImpl();
 307 }
 308
 309 void SessionStateControllerImpl::StartRealShutdownTimer() {
 310   base::TimeDelta duration =
 311       base::TimeDelta::FromMilliseconds(kShutdownRequestDelayMs);
 312   duration += animator_->GetDuration(
 313       internal::SessionStateAnimator::ANIMATION_SPEED_FAST);
 314
 315   real_shutdown_timer_.Start(
 316       FROM_HERE,
 317       duration,
 318       this, &SessionStateControllerImpl::OnRealShutdownTimeout);
 319 }
 320
 321 void SessionStateControllerImpl::OnRealShutdownTimeout() {
 322   DCHECK(shutting_down_);
 323 #if defined(OS_CHROMEOS)
 324   if (!base::chromeos::IsRunningOnChromeOS()) {
 325     ShellDelegate* delegate = Shell::GetInstance()->delegate();
 326     if (delegate) {
 327       delegate->Exit();
 328       return;
 329     }
 330   }
 331 #endif
 332   delegate_->RequestShutdown();
 333 }
 334
 335 void SessionStateControllerImpl::OnLockScreenHide(base::Closure& callback) {
 336   callback.Run();
 337 }
 338
 339 void SessionStateControllerImpl::SetLockScreenDisplayedCallback(
 340     base::Closure& callback) {
 341   NOTIMPLEMENTED();
 342 }
 343
 344 }  // namespace ash