ash/wm/lock_state_controller_unittest.cc

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