| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 24980006:
ash: Remove old lock animation implementation. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src