| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/ash_switches.h" | |
| 6 #include "ash/session_state_delegate.h" | |
| 7 #include "ash/shell.h" | |
| 8 #include "ash/shell_window_ids.h" | |
| 9 #include "ash/test/ash_test_base.h" | |
| 10 #include "ash/test/test_shell_delegate.h" | |
| 11 #include "ash/wm/lock_state_controller.h" | |
| 12 #include "ash/wm/lock_state_controller_impl2.h" | |
| 13 #include "ash/wm/power_button_controller.h" | |
| 14 #include "ash/wm/session_state_animator.h" | |
| 15 #include "base/command_line.h" | |
| 16 #include "base/memory/scoped_ptr.h" | |
| 17 #include "base/time/time.h" | |
| 18 #include "ui/aura/env.h" | |
| 19 #include "ui/aura/root_window.h" | |
| 20 #include "ui/aura/test/event_generator.h" | |
| 21 #include "ui/compositor/layer_animator.h" | |
| 22 #include "ui/compositor/scoped_animation_duration_scale_mode.h" | |
| 23 #include "ui/compositor/scoped_layer_animation_settings.h" | |
| 24 #include "ui/gfx/rect.h" | |
| 25 #include "ui/gfx/size.h" | |
| 26 | |
| 27 #if defined(OS_WIN) | |
| 28 #include "base/win/windows_version.h" | |
| 29 #endif | |
| 30 | |
| 31 namespace ash { | |
| 32 | |
| 33 using internal::SessionStateAnimator; | |
| 34 | |
| 35 namespace test { | |
| 36 | |
| 37 namespace { | |
| 38 | |
| 39 bool cursor_visible() { | |
| 40 return ash::Shell::GetInstance()->cursor_manager()->IsCursorVisible(); | |
| 41 } | |
| 42 | |
| 43 void CheckCalledCallback(bool* flag) { | |
| 44 if (flag) | |
| 45 (*flag) = true; | |
| 46 } | |
| 47 | |
| 48 aura::Window* GetContainer(int container ) { | |
| 49 aura::RootWindow* root_window = Shell::GetPrimaryRootWindow(); | |
| 50 return Shell::GetContainer(root_window, container); | |
| 51 } | |
| 52 | |
| 53 bool IsBackgroundHidden() { | |
| 54 return !GetContainer(internal::kShellWindowId_DesktopBackgroundContainer)-> | |
| 55 IsVisible(); | |
| 56 } | |
| 57 | |
| 58 void ShowBackground() { | |
| 59 ui::ScopedLayerAnimationSettings settings( | |
| 60 GetContainer(internal::kShellWindowId_DesktopBackgroundContainer)-> | |
| 61 layer()->GetAnimator()); | |
| 62 settings.SetTransitionDuration(base::TimeDelta()); | |
| 63 GetContainer(internal::kShellWindowId_DesktopBackgroundContainer)->Show(); | |
| 64 } | |
| 65 | |
| 66 void HideBackground() { | |
| 67 ui::ScopedLayerAnimationSettings settings( | |
| 68 GetContainer(internal::kShellWindowId_DesktopBackgroundContainer)-> | |
| 69 layer()->GetAnimator()); | |
| 70 settings.SetTransitionDuration(base::TimeDelta()); | |
| 71 GetContainer(internal::kShellWindowId_DesktopBackgroundContainer)->Hide(); | |
| 72 } | |
| 73 | |
| 74 } // namespace | |
| 75 | |
| 76 // Fake implementation of PowerButtonControllerDelegate that just logs requests | |
| 77 // to lock the screen and shut down the device. | |
| 78 class TestLockStateControllerDelegate : public LockStateControllerDelegate { | |
| 79 public: | |
| 80 TestLockStateControllerDelegate() | |
| 81 : num_lock_requests_(0), | |
| 82 num_shutdown_requests_(0) {} | |
| 83 | |
| 84 int num_lock_requests() const { return num_lock_requests_; } | |
| 85 int num_shutdown_requests() const { return num_shutdown_requests_; } | |
| 86 | |
| 87 // LockStateControllerDelegate implementation. | |
| 88 virtual void RequestLockScreen() OVERRIDE { | |
| 89 num_lock_requests_++; | |
| 90 } | |
| 91 virtual void RequestShutdown() OVERRIDE { | |
| 92 num_shutdown_requests_++; | |
| 93 } | |
| 94 | |
| 95 private: | |
| 96 int num_lock_requests_; | |
| 97 int num_shutdown_requests_; | |
| 98 | |
| 99 DISALLOW_COPY_AND_ASSIGN(TestLockStateControllerDelegate); | |
| 100 }; | |
| 101 | |
| 102 class LockStateControllerImpl2Test : public AshTestBase { | |
| 103 public: | |
| 104 LockStateControllerImpl2Test() : controller_(NULL), delegate_(NULL) {} | |
| 105 virtual ~LockStateControllerImpl2Test() {} | |
| 106 | |
| 107 virtual void SetUp() OVERRIDE { | |
| 108 CHECK(!CommandLine::ForCurrentProcess()->HasSwitch( | |
| 109 ash::switches::kAshDisableNewLockAnimations)); | |
| 110 | |
| 111 AshTestBase::SetUp(); | |
| 112 | |
| 113 // We would control animations in a fine way: | |
| 114 animation_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode( | |
| 115 ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION)); | |
| 116 // TODO(antrim) : restore | |
| 117 // animator_helper_ = ui::test::CreateLayerAnimatorHelperForTest(); | |
| 118 | |
| 119 // Temporary disable animations so that observer is always called, and | |
| 120 // no leaks happen during tests. | |
| 121 animation_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode( | |
| 122 ui::ScopedAnimationDurationScaleMode::ZERO_DURATION)); | |
| 123 // TODO(antrim): once there is a way to mock time and run animations, make | |
| 124 // sure that animations are finished even in simple tests. | |
| 125 | |
| 126 delegate_ = new TestLockStateControllerDelegate; | |
| 127 controller_ = Shell::GetInstance()->power_button_controller(); | |
| 128 lock_state_controller_ = static_cast<LockStateControllerImpl2*>( | |
| 129 Shell::GetInstance()->lock_state_controller()); | |
| 130 lock_state_controller_->SetDelegate(delegate_); // transfers ownership | |
| 131 test_api_.reset( | |
| 132 new LockStateControllerImpl2::TestApi(lock_state_controller_)); | |
| 133 animator_api_.reset( | |
| 134 new SessionStateAnimator::TestApi(lock_state_controller_-> | |
| 135 animator_.get())); | |
| 136 shell_delegate_ = reinterpret_cast<TestShellDelegate*>( | |
| 137 ash::Shell::GetInstance()->delegate()); | |
| 138 session_state_delegate_ = Shell::GetInstance()->session_state_delegate(); | |
| 139 } | |
| 140 | |
| 141 virtual void TearDown() { | |
| 142 // TODO(antrim) : restore | |
| 143 // animator_helper_->AdvanceUntilDone(); | |
| 144 AshTestBase::TearDown(); | |
| 145 } | |
| 146 | |
| 147 protected: | |
| 148 void GenerateMouseMoveEvent() { | |
| 149 aura::test::EventGenerator generator( | |
| 150 Shell::GetPrimaryRootWindow()); | |
| 151 generator.MoveMouseTo(10, 10); | |
| 152 } | |
| 153 | |
| 154 int NumShutdownRequests() { | |
| 155 return delegate_->num_shutdown_requests() + | |
| 156 shell_delegate_->num_exit_requests(); | |
| 157 } | |
| 158 | |
| 159 void Advance(SessionStateAnimator::AnimationSpeed speed) { | |
| 160 // TODO (antrim) : restore | |
| 161 // animator_helper_->Advance(SessionStateAnimator::GetDuration(speed)); | |
| 162 } | |
| 163 | |
| 164 void AdvancePartially(SessionStateAnimator::AnimationSpeed speed, | |
| 165 float factor) { | |
| 166 // TODO (antrim) : restore | |
| 167 // base::TimeDelta duration = SessionStateAnimator::GetDuration(speed); | |
| 168 // base::TimeDelta partial_duration = | |
| 169 // base::TimeDelta::FromInternalValue(duration.ToInternalValue() * factor); | |
| 170 // animator_helper_->Advance(partial_duration); | |
| 171 } | |
| 172 | |
| 173 void ExpectPreLockAnimationStarted() { | |
| 174 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 175 EXPECT_TRUE( | |
| 176 animator_api_->ContainersAreAnimated( | |
| 177 SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS, | |
| 178 SessionStateAnimator::ANIMATION_LIFT)); | |
| 179 EXPECT_TRUE( | |
| 180 animator_api_->ContainersAreAnimated( | |
| 181 SessionStateAnimator::LAUNCHER, | |
| 182 SessionStateAnimator::ANIMATION_FADE_OUT)); | |
| 183 EXPECT_TRUE( | |
| 184 animator_api_->ContainersAreAnimated( | |
| 185 SessionStateAnimator::LOCK_SCREEN_CONTAINERS, | |
| 186 SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY)); | |
| 187 EXPECT_TRUE(test_api_->is_animating_lock()); | |
| 188 } | |
| 189 | |
| 190 void ExpectPreLockAnimationCancel() { | |
| 191 EXPECT_TRUE( | |
| 192 animator_api_->ContainersAreAnimated( | |
| 193 SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS, | |
| 194 SessionStateAnimator::ANIMATION_DROP)); | |
| 195 EXPECT_TRUE( | |
| 196 animator_api_->ContainersAreAnimated( | |
| 197 SessionStateAnimator::LAUNCHER, | |
| 198 SessionStateAnimator::ANIMATION_FADE_IN)); | |
| 199 } | |
| 200 | |
| 201 void ExpectPreLockAnimationFinished() { | |
| 202 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 203 EXPECT_TRUE( | |
| 204 animator_api_->ContainersAreAnimated( | |
| 205 SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS, | |
| 206 SessionStateAnimator::ANIMATION_LIFT)); | |
| 207 EXPECT_TRUE( | |
| 208 animator_api_->ContainersAreAnimated( | |
| 209 SessionStateAnimator::LAUNCHER, | |
| 210 SessionStateAnimator::ANIMATION_FADE_OUT)); | |
| 211 EXPECT_TRUE( | |
| 212 animator_api_->ContainersAreAnimated( | |
| 213 SessionStateAnimator::LOCK_SCREEN_CONTAINERS, | |
| 214 SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY)); | |
| 215 } | |
| 216 | |
| 217 void ExpectPostLockAnimationStarted() { | |
| 218 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 219 EXPECT_TRUE( | |
| 220 animator_api_->ContainersAreAnimated( | |
| 221 SessionStateAnimator::LOCK_SCREEN_CONTAINERS, | |
| 222 SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN)); | |
| 223 } | |
| 224 | |
| 225 void ExpectPastLockAnimationFinished() { | |
| 226 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 227 EXPECT_TRUE( | |
| 228 animator_api_->ContainersAreAnimated( | |
| 229 SessionStateAnimator::LOCK_SCREEN_CONTAINERS, | |
| 230 SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN)); | |
| 231 } | |
| 232 | |
| 233 void ExpectUnlockBeforeUIDestroyedAnimationStarted() { | |
| 234 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 235 EXPECT_TRUE( | |
| 236 animator_api_->ContainersAreAnimated( | |
| 237 SessionStateAnimator::LOCK_SCREEN_CONTAINERS, | |
| 238 SessionStateAnimator::ANIMATION_LIFT)); | |
| 239 } | |
| 240 | |
| 241 void ExpectUnlockBeforeUIDestroyedAnimationFinished() { | |
| 242 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 243 EXPECT_TRUE( | |
| 244 animator_api_->ContainersAreAnimated( | |
| 245 SessionStateAnimator::LOCK_SCREEN_CONTAINERS, | |
| 246 SessionStateAnimator::ANIMATION_LIFT)); | |
| 247 } | |
| 248 | |
| 249 void ExpectUnlockAfterUIDestroyedAnimationStarted() { | |
| 250 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 251 EXPECT_TRUE( | |
| 252 animator_api_->ContainersAreAnimated( | |
| 253 SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS, | |
| 254 SessionStateAnimator::ANIMATION_DROP)); | |
| 255 EXPECT_TRUE( | |
| 256 animator_api_->ContainersAreAnimated( | |
| 257 SessionStateAnimator::LAUNCHER, | |
| 258 SessionStateAnimator::ANIMATION_FADE_IN)); | |
| 259 } | |
| 260 | |
| 261 void ExpectUnlockAfterUIDestroyedAnimationFinished() { | |
| 262 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 263 EXPECT_TRUE( | |
| 264 animator_api_->ContainersAreAnimated( | |
| 265 SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS, | |
| 266 SessionStateAnimator::ANIMATION_DROP)); | |
| 267 EXPECT_TRUE( | |
| 268 animator_api_->ContainersAreAnimated( | |
| 269 SessionStateAnimator::LAUNCHER, | |
| 270 SessionStateAnimator::ANIMATION_FADE_IN)); | |
| 271 } | |
| 272 | |
| 273 void ExpectShutdownAnimationStarted() { | |
| 274 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 275 EXPECT_TRUE( | |
| 276 animator_api_->RootWindowIsAnimated( | |
| 277 SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS)); | |
| 278 } | |
| 279 | |
| 280 void ExpectShutdownAnimationFinished() { | |
| 281 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 282 EXPECT_TRUE( | |
| 283 animator_api_->RootWindowIsAnimated( | |
| 284 SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS)); | |
| 285 } | |
| 286 | |
| 287 void ExpectShutdownAnimationCancel() { | |
| 288 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 289 EXPECT_TRUE( | |
| 290 animator_api_->RootWindowIsAnimated( | |
| 291 SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS)); | |
| 292 } | |
| 293 | |
| 294 void ExpectBackgroundIsShowing() { | |
| 295 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 296 EXPECT_TRUE( | |
| 297 animator_api_->ContainersAreAnimated( | |
| 298 SessionStateAnimator::DESKTOP_BACKGROUND, | |
| 299 SessionStateAnimator::ANIMATION_FADE_IN)); | |
| 300 } | |
| 301 | |
| 302 void ExpectBackgroundIsHiding() { | |
| 303 //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating()); | |
| 304 EXPECT_TRUE( | |
| 305 animator_api_->ContainersAreAnimated( | |
| 306 SessionStateAnimator::DESKTOP_BACKGROUND, | |
| 307 SessionStateAnimator::ANIMATION_FADE_OUT)); | |
| 308 } | |
| 309 | |
| 310 void ExpectUnlockedState() { | |
| 311 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 312 EXPECT_FALSE(session_state_delegate_->IsScreenLocked()); | |
| 313 | |
| 314 aura::Window::Windows containers; | |
| 315 | |
| 316 SessionStateAnimator::GetContainers( | |
| 317 SessionStateAnimator::LAUNCHER | | |
| 318 SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS, | |
| 319 &containers); | |
| 320 for (aura::Window::Windows::const_iterator it = containers.begin(); | |
| 321 it != containers.end(); ++it) { | |
| 322 aura::Window* window = *it; | |
| 323 ui::Layer* layer = window->layer(); | |
| 324 EXPECT_EQ(1.0f, layer->opacity()); | |
| 325 EXPECT_EQ(0.0f, layer->layer_brightness()); | |
| 326 EXPECT_EQ(0.0f, layer->layer_saturation()); | |
| 327 EXPECT_EQ(gfx::Transform(), layer->transform()); | |
| 328 } | |
| 329 } | |
| 330 | |
| 331 void ExpectLockedState() { | |
| 332 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 333 EXPECT_TRUE(session_state_delegate_->IsScreenLocked()); | |
| 334 | |
| 335 aura::Window::Windows containers; | |
| 336 | |
| 337 SessionStateAnimator::GetContainers( | |
| 338 SessionStateAnimator::LOCK_SCREEN_RELATED_CONTAINERS | | |
| 339 SessionStateAnimator::LOCK_SCREEN_CONTAINERS, | |
| 340 &containers); | |
| 341 for (aura::Window::Windows::const_iterator it = containers.begin(); | |
| 342 it != containers.end(); ++it) { | |
| 343 aura::Window* window = *it; | |
| 344 ui::Layer* layer = window->layer(); | |
| 345 EXPECT_EQ(1.0f, layer->opacity()); | |
| 346 EXPECT_EQ(0.0f, layer->layer_brightness()); | |
| 347 EXPECT_EQ(0.0f, layer->layer_saturation()); | |
| 348 EXPECT_EQ(gfx::Transform(), layer->transform()); | |
| 349 } | |
| 350 } | |
| 351 | |
| 352 void PressPowerButton() { | |
| 353 controller_->OnPowerButtonEvent(true, base::TimeTicks::Now()); | |
| 354 //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta()); | |
| 355 } | |
| 356 | |
| 357 void ReleasePowerButton() { | |
| 358 controller_->OnPowerButtonEvent(false, base::TimeTicks::Now()); | |
| 359 //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta()); | |
| 360 } | |
| 361 | |
| 362 void PressLockButton() { | |
| 363 controller_->OnLockButtonEvent(true, base::TimeTicks::Now()); | |
| 364 } | |
| 365 | |
| 366 void ReleaseLockButton() { | |
| 367 controller_->OnLockButtonEvent(false, base::TimeTicks::Now()); | |
| 368 } | |
| 369 | |
| 370 void SystemLocks() { | |
| 371 lock_state_controller_->OnLockStateChanged(true); | |
| 372 session_state_delegate_->LockScreen(); | |
| 373 //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta()); | |
| 374 } | |
| 375 | |
| 376 void SuccessfulAuthentication(bool* call_flag) { | |
| 377 base::Closure closure = base::Bind(&CheckCalledCallback, call_flag); | |
| 378 lock_state_controller_->OnLockScreenHide(closure); | |
| 379 //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta()); | |
| 380 } | |
| 381 | |
| 382 void SystemUnlocks() { | |
| 383 lock_state_controller_->OnLockStateChanged(false); | |
| 384 session_state_delegate_->UnlockScreen(); | |
| 385 //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta()); | |
| 386 } | |
| 387 | |
| 388 void Initialize(bool legacy_button, user::LoginStatus status) { | |
| 389 controller_->set_has_legacy_power_button_for_test(legacy_button); | |
| 390 lock_state_controller_->OnLoginStateChanged(status); | |
| 391 SetUserLoggedIn(status != user::LOGGED_IN_NONE); | |
| 392 if (status == user::LOGGED_IN_GUEST) | |
| 393 SetCanLockScreen(false); | |
| 394 lock_state_controller_->OnLockStateChanged(false); | |
| 395 } | |
| 396 | |
| 397 PowerButtonController* controller_; // not owned | |
| 398 LockStateControllerImpl2* lock_state_controller_; // not owned | |
| 399 TestLockStateControllerDelegate* delegate_; // not owned | |
| 400 TestShellDelegate* shell_delegate_; // not owned | |
| 401 SessionStateDelegate* session_state_delegate_; // not owned | |
| 402 | |
| 403 scoped_ptr<ui::ScopedAnimationDurationScaleMode> animation_duration_mode_; | |
| 404 scoped_ptr<LockStateControllerImpl2::TestApi> test_api_; | |
| 405 scoped_ptr<SessionStateAnimator::TestApi> animator_api_; | |
| 406 // TODO(antrim) : restore | |
| 407 // scoped_ptr<ui::test::AnimationContainerTestHelper> animator_helper_; | |
| 408 | |
| 409 private: | |
| 410 DISALLOW_COPY_AND_ASSIGN(LockStateControllerImpl2Test); | |
| 411 }; | |
| 412 | |
| 413 // Test the lock-to-shutdown flow for non-Chrome-OS hardware that doesn't | |
| 414 // correctly report power button releases. We should lock immediately the first | |
| 415 // time the button is pressed and shut down when it's pressed from the locked | |
| 416 // state. | |
| 417 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 418 TEST_F(LockStateControllerImpl2Test, DISABLED_LegacyLockAndShutDown) { | |
| 419 Initialize(true, user::LOGGED_IN_USER); | |
| 420 | |
| 421 ExpectUnlockedState(); | |
| 422 | |
| 423 // We should request that the screen be locked immediately after seeing the | |
| 424 // power button get pressed. | |
| 425 PressPowerButton(); | |
| 426 | |
| 427 ExpectPreLockAnimationStarted(); | |
| 428 | |
| 429 EXPECT_FALSE(test_api_->is_lock_cancellable()); | |
| 430 | |
| 431 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 432 | |
| 433 ExpectPreLockAnimationFinished(); | |
| 434 EXPECT_EQ(1, delegate_->num_lock_requests()); | |
| 435 | |
| 436 // Notify that we locked successfully. | |
| 437 lock_state_controller_->OnStartingLock(); | |
| 438 // We had that animation already. | |
| 439 //TODO (antrim) : restore | |
| 440 // EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 441 | |
| 442 SystemLocks(); | |
| 443 | |
| 444 ExpectPostLockAnimationStarted(); | |
| 445 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 446 ExpectPastLockAnimationFinished(); | |
| 447 | |
| 448 // We shouldn't progress towards the shutdown state, however. | |
| 449 EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running()); | |
| 450 EXPECT_FALSE(test_api_->shutdown_timer_is_running()); | |
| 451 | |
| 452 ReleasePowerButton(); | |
| 453 | |
| 454 // Hold the button again and check that we start shutting down. | |
| 455 PressPowerButton(); | |
| 456 | |
| 457 ExpectShutdownAnimationStarted(); | |
| 458 | |
| 459 EXPECT_EQ(0, NumShutdownRequests()); | |
| 460 // Make sure a mouse move event won't show the cursor. | |
| 461 GenerateMouseMoveEvent(); | |
| 462 EXPECT_FALSE(cursor_visible()); | |
| 463 | |
| 464 EXPECT_TRUE(test_api_->real_shutdown_timer_is_running()); | |
| 465 test_api_->trigger_real_shutdown_timeout(); | |
| 466 EXPECT_EQ(1, NumShutdownRequests()); | |
| 467 } | |
| 468 | |
| 469 // Test that we start shutting down immediately if the power button is pressed | |
| 470 // while we're not logged in on an unofficial system. | |
| 471 TEST_F(LockStateControllerImpl2Test, LegacyNotLoggedIn) { | |
| 472 Initialize(true, user::LOGGED_IN_NONE); | |
| 473 | |
| 474 PressPowerButton(); | |
| 475 ExpectShutdownAnimationStarted(); | |
| 476 | |
| 477 EXPECT_TRUE(test_api_->real_shutdown_timer_is_running()); | |
| 478 } | |
| 479 | |
| 480 // Test that we start shutting down immediately if the power button is pressed | |
| 481 // while we're logged in as a guest on an unofficial system. | |
| 482 TEST_F(LockStateControllerImpl2Test, LegacyGuest) { | |
| 483 Initialize(true, user::LOGGED_IN_GUEST); | |
| 484 | |
| 485 PressPowerButton(); | |
| 486 ExpectShutdownAnimationStarted(); | |
| 487 | |
| 488 EXPECT_TRUE(test_api_->real_shutdown_timer_is_running()); | |
| 489 } | |
| 490 | |
| 491 // When we hold the power button while the user isn't logged in, we should shut | |
| 492 // down the machine directly. | |
| 493 TEST_F(LockStateControllerImpl2Test, ShutdownWhenNotLoggedIn) { | |
| 494 Initialize(false, user::LOGGED_IN_NONE); | |
| 495 | |
| 496 // Press the power button and check that we start the shutdown timer. | |
| 497 PressPowerButton(); | |
| 498 EXPECT_FALSE(test_api_->is_animating_lock()); | |
| 499 EXPECT_TRUE(test_api_->shutdown_timer_is_running()); | |
| 500 ExpectShutdownAnimationStarted(); | |
| 501 | |
| 502 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN, 0.5f); | |
| 503 | |
| 504 // Release the power button before the shutdown timer fires. | |
| 505 ReleasePowerButton(); | |
| 506 | |
| 507 EXPECT_FALSE(test_api_->shutdown_timer_is_running()); | |
| 508 ExpectShutdownAnimationCancel(); | |
| 509 | |
| 510 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_REVERT, 0.5f); | |
| 511 | |
| 512 // Press the button again and make the shutdown timeout fire this time. | |
| 513 // Check that we start the timer for actually requesting the shutdown. | |
| 514 PressPowerButton(); | |
| 515 | |
| 516 EXPECT_TRUE(test_api_->shutdown_timer_is_running()); | |
| 517 | |
| 518 Advance(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN); | |
| 519 ExpectShutdownAnimationFinished(); | |
| 520 test_api_->trigger_shutdown_timeout(); | |
| 521 | |
| 522 EXPECT_TRUE(test_api_->real_shutdown_timer_is_running()); | |
| 523 EXPECT_EQ(0, NumShutdownRequests()); | |
| 524 | |
| 525 // When the timout fires, we should request a shutdown. | |
| 526 test_api_->trigger_real_shutdown_timeout(); | |
| 527 | |
| 528 EXPECT_EQ(1, NumShutdownRequests()); | |
| 529 } | |
| 530 | |
| 531 // Test that we lock the screen and deal with unlocking correctly. | |
| 532 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 533 TEST_F(LockStateControllerImpl2Test, DISABLED_LockAndUnlock) { | |
| 534 Initialize(false, user::LOGGED_IN_USER); | |
| 535 | |
| 536 ExpectUnlockedState(); | |
| 537 | |
| 538 // Press the power button and check that the lock timer is started and that we | |
| 539 // start lifting the non-screen-locker containers. | |
| 540 PressPowerButton(); | |
| 541 | |
| 542 ExpectPreLockAnimationStarted(); | |
| 543 EXPECT_TRUE(test_api_->is_lock_cancellable()); | |
| 544 EXPECT_EQ(0, delegate_->num_lock_requests()); | |
| 545 | |
| 546 Advance(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE); | |
| 547 ExpectPreLockAnimationFinished(); | |
| 548 | |
| 549 EXPECT_EQ(1, delegate_->num_lock_requests()); | |
| 550 | |
| 551 // Notify that we locked successfully. | |
| 552 lock_state_controller_->OnStartingLock(); | |
| 553 // We had that animation already. | |
| 554 //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating()); | |
| 555 | |
| 556 SystemLocks(); | |
| 557 | |
| 558 ExpectPostLockAnimationStarted(); | |
| 559 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 560 ExpectPastLockAnimationFinished(); | |
| 561 | |
| 562 // When we release the power button, the lock-to-shutdown timer should be | |
| 563 // stopped. | |
| 564 ExpectLockedState(); | |
| 565 EXPECT_TRUE(test_api_->lock_to_shutdown_timer_is_running()); | |
| 566 ReleasePowerButton(); | |
| 567 ExpectLockedState(); | |
| 568 EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running()); | |
| 569 | |
| 570 // Notify that the screen has been unlocked. We should show the | |
| 571 // non-screen-locker windows. | |
| 572 bool called = false; | |
| 573 SuccessfulAuthentication(&called); | |
| 574 | |
| 575 ExpectUnlockBeforeUIDestroyedAnimationStarted(); | |
| 576 EXPECT_FALSE(called); | |
| 577 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 578 ExpectUnlockBeforeUIDestroyedAnimationFinished(); | |
| 579 | |
| 580 EXPECT_TRUE(called); | |
| 581 | |
| 582 SystemUnlocks(); | |
| 583 | |
| 584 ExpectUnlockAfterUIDestroyedAnimationStarted(); | |
| 585 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 586 ExpectUnlockAfterUIDestroyedAnimationFinished(); | |
| 587 | |
| 588 ExpectUnlockedState(); | |
| 589 } | |
| 590 | |
| 591 // Test that we deal with cancelling lock correctly. | |
| 592 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 593 TEST_F(LockStateControllerImpl2Test, DISABLED_LockAndCancel) { | |
| 594 Initialize(false, user::LOGGED_IN_USER); | |
| 595 | |
| 596 ExpectUnlockedState(); | |
| 597 | |
| 598 // Press the power button and check that the lock timer is started and that we | |
| 599 // start lifting the non-screen-locker containers. | |
| 600 PressPowerButton(); | |
| 601 | |
| 602 ExpectPreLockAnimationStarted(); | |
| 603 EXPECT_TRUE(test_api_->is_lock_cancellable()); | |
| 604 | |
| 605 // forward only half way through | |
| 606 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5f); | |
| 607 | |
| 608 gfx::Transform transform_before_button_released = | |
| 609 GetContainer(internal::kShellWindowId_DefaultContainer)-> | |
| 610 layer()->transform(); | |
| 611 | |
| 612 // Release the button before the lock timer fires. | |
| 613 ReleasePowerButton(); | |
| 614 | |
| 615 ExpectPreLockAnimationCancel(); | |
| 616 | |
| 617 gfx::Transform transform_after_button_released = | |
| 618 GetContainer(internal::kShellWindowId_DefaultContainer)-> | |
| 619 layer()->transform(); | |
| 620 // Expect no flickering, animation should proceed from mid-state. | |
| 621 EXPECT_EQ(transform_before_button_released, transform_after_button_released); | |
| 622 | |
| 623 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 624 ExpectUnlockedState(); | |
| 625 EXPECT_EQ(0, delegate_->num_lock_requests()); | |
| 626 } | |
| 627 | |
| 628 // Test that we deal with cancelling lock correctly. | |
| 629 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 630 TEST_F(LockStateControllerImpl2Test, | |
| 631 DISABLED_LockAndCancelAndLockAgain) { | |
| 632 Initialize(false, user::LOGGED_IN_USER); | |
| 633 | |
| 634 ExpectUnlockedState(); | |
| 635 | |
| 636 // Press the power button and check that the lock timer is started and that we | |
| 637 // start lifting the non-screen-locker containers. | |
| 638 PressPowerButton(); | |
| 639 | |
| 640 ExpectPreLockAnimationStarted(); | |
| 641 EXPECT_TRUE(test_api_->is_lock_cancellable()); | |
| 642 | |
| 643 // forward only half way through | |
| 644 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5f); | |
| 645 | |
| 646 // Release the button before the lock timer fires. | |
| 647 ReleasePowerButton(); | |
| 648 ExpectPreLockAnimationCancel(); | |
| 649 | |
| 650 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, 0.5f); | |
| 651 | |
| 652 PressPowerButton(); | |
| 653 ExpectPreLockAnimationStarted(); | |
| 654 EXPECT_TRUE(test_api_->is_lock_cancellable()); | |
| 655 | |
| 656 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.6f); | |
| 657 | |
| 658 EXPECT_EQ(0, delegate_->num_lock_requests()); | |
| 659 ExpectPreLockAnimationStarted(); | |
| 660 | |
| 661 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.6f); | |
| 662 ExpectPreLockAnimationFinished(); | |
| 663 EXPECT_EQ(1, delegate_->num_lock_requests()); | |
| 664 } | |
| 665 | |
| 666 // Hold the power button down from the unlocked state to eventual shutdown. | |
| 667 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 668 TEST_F(LockStateControllerImpl2Test, DISABLED_LockToShutdown) { | |
| 669 Initialize(false, user::LOGGED_IN_USER); | |
| 670 | |
| 671 // Hold the power button and lock the screen. | |
| 672 PressPowerButton(); | |
| 673 EXPECT_TRUE(test_api_->is_animating_lock()); | |
| 674 | |
| 675 Advance(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE); | |
| 676 SystemLocks(); | |
| 677 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 678 | |
| 679 // When the lock-to-shutdown timeout fires, we should start the shutdown | |
| 680 // timer. | |
| 681 EXPECT_TRUE(test_api_->lock_to_shutdown_timer_is_running()); | |
| 682 | |
| 683 test_api_->trigger_lock_to_shutdown_timeout(); | |
| 684 | |
| 685 ExpectShutdownAnimationStarted(); | |
| 686 EXPECT_TRUE(test_api_->shutdown_timer_is_running()); | |
| 687 | |
| 688 // Fire the shutdown timeout and check that we request shutdown. | |
| 689 Advance(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN); | |
| 690 ExpectShutdownAnimationFinished(); | |
| 691 test_api_->trigger_shutdown_timeout(); | |
| 692 | |
| 693 EXPECT_TRUE(test_api_->real_shutdown_timer_is_running()); | |
| 694 EXPECT_EQ(0, NumShutdownRequests()); | |
| 695 test_api_->trigger_real_shutdown_timeout(); | |
| 696 EXPECT_EQ(1, NumShutdownRequests()); | |
| 697 } | |
| 698 | |
| 699 // Hold the power button down from the unlocked state to eventual shutdown, | |
| 700 // then release the button while system does locking. | |
| 701 TEST_F(LockStateControllerImpl2Test, CancelLockToShutdown) { | |
| 702 Initialize(false, user::LOGGED_IN_USER); | |
| 703 | |
| 704 PressPowerButton(); | |
| 705 | |
| 706 // Hold the power button and lock the screen. | |
| 707 EXPECT_TRUE(test_api_->is_animating_lock()); | |
| 708 | |
| 709 Advance(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE); | |
| 710 SystemLocks(); | |
| 711 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, 0.5f); | |
| 712 | |
| 713 // Power button is released while system attempts to lock. | |
| 714 ReleasePowerButton(); | |
| 715 | |
| 716 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 717 | |
| 718 EXPECT_FALSE(lock_state_controller_->ShutdownRequested()); | |
| 719 EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running()); | |
| 720 EXPECT_FALSE(test_api_->shutdown_timer_is_running()); | |
| 721 } | |
| 722 | |
| 723 // Test that we handle the case where lock requests are ignored. | |
| 724 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 725 TEST_F(LockStateControllerImpl2Test, DISABLED_Lock) { | |
| 726 // We require animations to have a duration for this test. | |
| 727 ui::ScopedAnimationDurationScaleMode normal_duration_mode( | |
| 728 ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION); | |
| 729 | |
| 730 Initialize(false, user::LOGGED_IN_USER); | |
| 731 | |
| 732 // Hold the power button and lock the screen. | |
| 733 PressPowerButton(); | |
| 734 ExpectPreLockAnimationStarted(); | |
| 735 | |
| 736 Advance(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE); | |
| 737 | |
| 738 EXPECT_EQ(1, delegate_->num_lock_requests()); | |
| 739 EXPECT_TRUE(test_api_->lock_fail_timer_is_running()); | |
| 740 // We shouldn't start the lock-to-shutdown timer until the screen has actually | |
| 741 // been locked and this was animated. | |
| 742 EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running()); | |
| 743 | |
| 744 // Act as if the request timed out. We should restore the windows. | |
| 745 test_api_->trigger_lock_fail_timeout(); | |
| 746 | |
| 747 ExpectUnlockAfterUIDestroyedAnimationStarted(); | |
| 748 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 749 ExpectUnlockAfterUIDestroyedAnimationFinished(); | |
| 750 ExpectUnlockedState(); | |
| 751 } | |
| 752 | |
| 753 // Test the basic operation of the lock button (not logged in). | |
| 754 TEST_F(LockStateControllerImpl2Test, LockButtonBasicNotLoggedIn) { | |
| 755 // The lock button shouldn't do anything if we aren't logged in. | |
| 756 Initialize(false, user::LOGGED_IN_NONE); | |
| 757 | |
| 758 PressLockButton(); | |
| 759 EXPECT_FALSE(test_api_->is_animating_lock()); | |
| 760 ReleaseLockButton(); | |
| 761 EXPECT_EQ(0, delegate_->num_lock_requests()); | |
| 762 } | |
| 763 | |
| 764 // Test the basic operation of the lock button (guest). | |
| 765 TEST_F(LockStateControllerImpl2Test, LockButtonBasicGuest) { | |
| 766 // The lock button shouldn't do anything when we're logged in as a guest. | |
| 767 Initialize(false, user::LOGGED_IN_GUEST); | |
| 768 | |
| 769 PressLockButton(); | |
| 770 EXPECT_FALSE(test_api_->is_animating_lock()); | |
| 771 ReleaseLockButton(); | |
| 772 EXPECT_EQ(0, delegate_->num_lock_requests()); | |
| 773 } | |
| 774 | |
| 775 // Test the basic operation of the lock button. | |
| 776 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 777 TEST_F(LockStateControllerImpl2Test, DISABLED_LockButtonBasic) { | |
| 778 // If we're logged in as a regular user, we should start the lock timer and | |
| 779 // the pre-lock animation. | |
| 780 Initialize(false, user::LOGGED_IN_USER); | |
| 781 | |
| 782 PressLockButton(); | |
| 783 ExpectPreLockAnimationStarted(); | |
| 784 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5f); | |
| 785 | |
| 786 // If the button is released immediately, we shouldn't lock the screen. | |
| 787 ReleaseLockButton(); | |
| 788 ExpectPreLockAnimationCancel(); | |
| 789 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 790 | |
| 791 ExpectUnlockedState(); | |
| 792 EXPECT_EQ(0, delegate_->num_lock_requests()); | |
| 793 | |
| 794 // Press the button again and let the lock timeout fire. We should request | |
| 795 // that the screen be locked. | |
| 796 PressLockButton(); | |
| 797 ExpectPreLockAnimationStarted(); | |
| 798 Advance(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE); | |
| 799 EXPECT_EQ(1, delegate_->num_lock_requests()); | |
| 800 | |
| 801 // Pressing the lock button while we have a pending lock request shouldn't do | |
| 802 // anything. | |
| 803 ReleaseLockButton(); | |
| 804 PressLockButton(); | |
| 805 ExpectPreLockAnimationFinished(); | |
| 806 ReleaseLockButton(); | |
| 807 | |
| 808 // Pressing the button also shouldn't do anything after the screen is locked. | |
| 809 SystemLocks(); | |
| 810 ExpectPostLockAnimationStarted(); | |
| 811 | |
| 812 PressLockButton(); | |
| 813 ReleaseLockButton(); | |
| 814 ExpectPostLockAnimationStarted(); | |
| 815 | |
| 816 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 817 ExpectPastLockAnimationFinished(); | |
| 818 | |
| 819 PressLockButton(); | |
| 820 ReleaseLockButton(); | |
| 821 ExpectPastLockAnimationFinished(); | |
| 822 } | |
| 823 | |
| 824 // Test that the power button takes priority over the lock button. | |
| 825 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 826 TEST_F(LockStateControllerImpl2Test, | |
| 827 DISABLED_PowerButtonPreemptsLockButton) { | |
| 828 Initialize(false, user::LOGGED_IN_USER); | |
| 829 | |
| 830 // While the lock button is down, hold the power button. | |
| 831 PressLockButton(); | |
| 832 ExpectPreLockAnimationStarted(); | |
| 833 PressPowerButton(); | |
| 834 ExpectPreLockAnimationStarted(); | |
| 835 | |
| 836 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5f); | |
| 837 | |
| 838 // The lock timer shouldn't be stopped when the lock button is released. | |
| 839 ReleaseLockButton(); | |
| 840 ExpectPreLockAnimationStarted(); | |
| 841 ReleasePowerButton(); | |
| 842 ExpectPreLockAnimationCancel(); | |
| 843 | |
| 844 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 845 ExpectUnlockedState(); | |
| 846 | |
| 847 // Now press the power button first and then the lock button. | |
| 848 PressPowerButton(); | |
| 849 ExpectPreLockAnimationStarted(); | |
| 850 PressLockButton(); | |
| 851 ExpectPreLockAnimationStarted(); | |
| 852 | |
| 853 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5f); | |
| 854 | |
| 855 // Releasing the power button should stop the lock timer. | |
| 856 ReleasePowerButton(); | |
| 857 ExpectPreLockAnimationCancel(); | |
| 858 ReleaseLockButton(); | |
| 859 ExpectPreLockAnimationCancel(); | |
| 860 } | |
| 861 | |
| 862 // When the screen is locked without going through the usual power-button | |
| 863 // slow-close path (e.g. via the wrench menu), test that we still show the | |
| 864 // fast-close animation. | |
| 865 TEST_F(LockStateControllerImpl2Test, LockWithoutButton) { | |
| 866 Initialize(false, user::LOGGED_IN_USER); | |
| 867 lock_state_controller_->OnStartingLock(); | |
| 868 | |
| 869 ExpectPreLockAnimationStarted(); | |
| 870 EXPECT_FALSE(test_api_->is_lock_cancellable()); | |
| 871 | |
| 872 // TODO(antrim): After time-faking is fixed, let the pre-lock animation | |
| 873 // complete here and check that delegate_->num_lock_requests() is 0 to | |
| 874 // prevent http://crbug.com/172487 from regressing. | |
| 875 } | |
| 876 | |
| 877 // When we hear that the process is exiting but we haven't had a chance to | |
| 878 // display an animation, we should just blank the screen. | |
| 879 TEST_F(LockStateControllerImpl2Test, ShutdownWithoutButton) { | |
| 880 Initialize(false, user::LOGGED_IN_USER); | |
| 881 lock_state_controller_->OnAppTerminating(); | |
| 882 | |
| 883 EXPECT_TRUE( | |
| 884 animator_api_->ContainersAreAnimated( | |
| 885 SessionStateAnimator::kAllContainersMask, | |
| 886 SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY)); | |
| 887 GenerateMouseMoveEvent(); | |
| 888 EXPECT_FALSE(cursor_visible()); | |
| 889 } | |
| 890 | |
| 891 // Test that we display the fast-close animation and shut down when we get an | |
| 892 // outside request to shut down (e.g. from the login or lock screen). | |
| 893 TEST_F(LockStateControllerImpl2Test, RequestShutdownFromLoginScreen) { | |
| 894 Initialize(false, user::LOGGED_IN_NONE); | |
| 895 | |
| 896 lock_state_controller_->RequestShutdown(); | |
| 897 | |
| 898 ExpectShutdownAnimationStarted(); | |
| 899 Advance(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN); | |
| 900 | |
| 901 GenerateMouseMoveEvent(); | |
| 902 EXPECT_FALSE(cursor_visible()); | |
| 903 | |
| 904 EXPECT_EQ(0, NumShutdownRequests()); | |
| 905 EXPECT_TRUE(test_api_->real_shutdown_timer_is_running()); | |
| 906 test_api_->trigger_real_shutdown_timeout(); | |
| 907 EXPECT_EQ(1, NumShutdownRequests()); | |
| 908 } | |
| 909 | |
| 910 TEST_F(LockStateControllerImpl2Test, RequestShutdownFromLockScreen) { | |
| 911 Initialize(false, user::LOGGED_IN_USER); | |
| 912 | |
| 913 SystemLocks(); | |
| 914 Advance(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN); | |
| 915 ExpectPastLockAnimationFinished(); | |
| 916 | |
| 917 lock_state_controller_->RequestShutdown(); | |
| 918 | |
| 919 ExpectShutdownAnimationStarted(); | |
| 920 Advance(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN); | |
| 921 | |
| 922 GenerateMouseMoveEvent(); | |
| 923 EXPECT_FALSE(cursor_visible()); | |
| 924 | |
| 925 EXPECT_EQ(0, NumShutdownRequests()); | |
| 926 EXPECT_TRUE(test_api_->real_shutdown_timer_is_running()); | |
| 927 test_api_->trigger_real_shutdown_timeout(); | |
| 928 EXPECT_EQ(1, NumShutdownRequests()); | |
| 929 } | |
| 930 | |
| 931 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 932 TEST_F(LockStateControllerImpl2Test, | |
| 933 DISABLED_RequestAndCancelShutdownFromLockScreen) { | |
| 934 Initialize(false, user::LOGGED_IN_USER); | |
| 935 | |
| 936 SystemLocks(); | |
| 937 Advance(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN); | |
| 938 ExpectLockedState(); | |
| 939 | |
| 940 // Press the power button and check that we start the shutdown timer. | |
| 941 PressPowerButton(); | |
| 942 EXPECT_FALSE(test_api_->is_animating_lock()); | |
| 943 EXPECT_TRUE(test_api_->shutdown_timer_is_running()); | |
| 944 | |
| 945 ExpectShutdownAnimationStarted(); | |
| 946 | |
| 947 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN, 0.5f); | |
| 948 | |
| 949 float grayscale_before_button_release = | |
| 950 Shell::GetPrimaryRootWindow()->layer()->layer_grayscale(); | |
| 951 | |
| 952 // Release the power button before the shutdown timer fires. | |
| 953 ReleasePowerButton(); | |
| 954 | |
| 955 EXPECT_FALSE(test_api_->shutdown_timer_is_running()); | |
| 956 | |
| 957 ExpectShutdownAnimationCancel(); | |
| 958 | |
| 959 float grayscale_after_button_release = | |
| 960 Shell::GetPrimaryRootWindow()->layer()->layer_grayscale(); | |
| 961 // Expect no flickering in undo animation. | |
| 962 EXPECT_EQ(grayscale_before_button_release, grayscale_after_button_release); | |
| 963 | |
| 964 Advance(SessionStateAnimator::ANIMATION_SPEED_REVERT); | |
| 965 ExpectLockedState(); | |
| 966 } | |
| 967 | |
| 968 // Test that we ignore power button presses when the screen is turned off. | |
| 969 TEST_F(LockStateControllerImpl2Test, IgnorePowerButtonIfScreenIsOff) { | |
| 970 Initialize(false, user::LOGGED_IN_USER); | |
| 971 | |
| 972 // When the screen brightness is at 0%, we shouldn't do anything in response | |
| 973 // to power button presses. | |
| 974 controller_->OnScreenBrightnessChanged(0.0); | |
| 975 | |
| 976 PressPowerButton(); | |
| 977 EXPECT_FALSE(test_api_->is_animating_lock()); | |
| 978 ReleasePowerButton(); | |
| 979 | |
| 980 // After increasing the brightness to 10%, we should start the timer like | |
| 981 // usual. | |
| 982 controller_->OnScreenBrightnessChanged(10.0); | |
| 983 | |
| 984 PressPowerButton(); | |
| 985 EXPECT_TRUE(test_api_->is_animating_lock()); | |
| 986 } | |
| 987 | |
| 988 // Test that hidden background appears and revers correctly on lock/cancel. | |
| 989 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 990 TEST_F(LockStateControllerImpl2Test, | |
| 991 DISABLED_TestHiddenBackgroundLockCancel) { | |
| 992 Initialize(false, user::LOGGED_IN_USER); | |
| 993 HideBackground(); | |
| 994 | |
| 995 EXPECT_TRUE(IsBackgroundHidden()); | |
| 996 ExpectUnlockedState(); | |
| 997 PressPowerButton(); | |
| 998 | |
| 999 ExpectPreLockAnimationStarted(); | |
| 1000 EXPECT_FALSE(IsBackgroundHidden()); | |
| 1001 ExpectBackgroundIsShowing(); | |
| 1002 | |
| 1003 // Forward only half way through. | |
| 1004 AdvancePartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5f); | |
| 1005 | |
| 1006 // Release the button before the lock timer fires. | |
| 1007 ReleasePowerButton(); | |
| 1008 ExpectPreLockAnimationCancel(); | |
| 1009 ExpectBackgroundIsHiding(); | |
| 1010 EXPECT_FALSE(IsBackgroundHidden()); | |
| 1011 | |
| 1012 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 1013 | |
| 1014 ExpectUnlockedState(); | |
| 1015 EXPECT_TRUE(IsBackgroundHidden()); | |
| 1016 } | |
| 1017 | |
| 1018 // Test that hidden background appears and revers correctly on lock/unlock. | |
| 1019 // TODO(antrim): Reenable this: http://crbug.com/167048 | |
| 1020 TEST_F(LockStateControllerImpl2Test, | |
| 1021 DISABLED_TestHiddenBackgroundLockUnlock) { | |
| 1022 Initialize(false, user::LOGGED_IN_USER); | |
| 1023 HideBackground(); | |
| 1024 | |
| 1025 EXPECT_TRUE(IsBackgroundHidden()); | |
| 1026 ExpectUnlockedState(); | |
| 1027 | |
| 1028 // Press the power button and check that the lock timer is started and that we | |
| 1029 // start lifting the non-screen-locker containers. | |
| 1030 PressPowerButton(); | |
| 1031 | |
| 1032 ExpectPreLockAnimationStarted(); | |
| 1033 EXPECT_FALSE(IsBackgroundHidden()); | |
| 1034 ExpectBackgroundIsShowing(); | |
| 1035 | |
| 1036 Advance(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE); | |
| 1037 | |
| 1038 ExpectPreLockAnimationFinished(); | |
| 1039 | |
| 1040 SystemLocks(); | |
| 1041 | |
| 1042 ReleasePowerButton(); | |
| 1043 | |
| 1044 ExpectPostLockAnimationStarted(); | |
| 1045 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 1046 ExpectPastLockAnimationFinished(); | |
| 1047 | |
| 1048 ExpectLockedState(); | |
| 1049 | |
| 1050 SuccessfulAuthentication(NULL); | |
| 1051 | |
| 1052 ExpectUnlockBeforeUIDestroyedAnimationStarted(); | |
| 1053 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 1054 ExpectUnlockBeforeUIDestroyedAnimationFinished(); | |
| 1055 | |
| 1056 SystemUnlocks(); | |
| 1057 | |
| 1058 ExpectUnlockAfterUIDestroyedAnimationStarted(); | |
| 1059 ExpectBackgroundIsHiding(); | |
| 1060 EXPECT_FALSE(IsBackgroundHidden()); | |
| 1061 | |
| 1062 Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS); | |
| 1063 ExpectUnlockAfterUIDestroyedAnimationFinished(); | |
| 1064 EXPECT_TRUE(IsBackgroundHidden()); | |
| 1065 | |
| 1066 ExpectUnlockedState(); | |
| 1067 } | |
| 1068 | |
| 1069 } // namespace test | |
| 1070 } // 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