Home | History | Annotate | Download | only in wm 
      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
   1071