Fix black background when locking with fullscreen window:

ash/wm/session_state_controller_impl2_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/wm/session_state_controller_impl2.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
+#include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/cursor_manager.h"
 #include "ash/wm/power_button_controller.h"
 #include "ash/wm/session_state_animator.h"
 #include "ash/wm/session_state_controller.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/event_generator.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace ash {
+
+using internal::SessionStateAnimator;
+
 namespace test {
+
 namespace {
+
 bool cursor_visible() {
   return ash::Shell::GetInstance()->cursor_manager()->IsCursorVisible();
 }
 
 void CheckCalledCallback(bool* flag) {
-  (*flag) = true;
+  if (flag)
+    (*flag) = true;
 }
+
+aura::Window* GetBackground() {
+  aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
+  return Shell::GetContainer(root_window,
+      internal::kShellWindowId_DesktopBackgroundContainer);
 }
 
+bool IsBackgroundHidden() {
+  return !GetBackground()->IsVisible();
+}
+
+void ShowBackground() {
+  ui::ScopedLayerAnimationSettings settings(
+      GetBackground()->layer()->GetAnimator());
+  settings.SetTransitionDuration(base::TimeDelta());
+  GetBackground()->Show();
+}
+
+void HideBackground() {
+  ui::ScopedLayerAnimationSettings settings(
+      GetBackground()->layer()->GetAnimator());
+  settings.SetTransitionDuration(base::TimeDelta());
+  GetBackground()->Hide();
+}
+
+} // namespace
+
 // Fake implementation of PowerButtonControllerDelegate that just logs requests
 // to lock the screen and shut down the device.
 class TestSessionStateControllerDelegate :
     public SessionStateControllerDelegate {
  public:
   TestSessionStateControllerDelegate()
       : num_lock_requests_(0),
         num_shutdown_requests_(0) {}
 
   int num_lock_requests() const { return num_lock_requests_; }
@@ skipping 17 matching lines @@
 class SessionStateControllerImpl2Test : public AshTestBase {
  public:
   SessionStateControllerImpl2Test() : controller_(NULL), delegate_(NULL) {}
   virtual ~SessionStateControllerImpl2Test() {}
 
   void SetUp() OVERRIDE {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         ash::switches::kAshNewLockAnimationsEnabled);
 
     AshTestBase::SetUp();
+
+    // We would control animations in a fine way:
+    ui::LayerAnimator::set_disable_animations_for_test(false);
+    animator_helper_ = ui::LayerAnimator::CreateAnimatorHelperForTest();
+
     delegate_ = new TestSessionStateControllerDelegate;
     controller_ = Shell::GetInstance()->power_button_controller();
     state_controller_ = static_cast<SessionStateControllerImpl2*>(
         Shell::GetInstance()->session_state_controller());
     state_controller_->SetDelegate(delegate_);  // transfers ownership
     test_api_.reset(
         new SessionStateControllerImpl2::TestApi(state_controller_));
     animator_api_.reset(
-        new internal::SessionStateAnimator::TestApi(state_controller_->
+        new SessionStateAnimator::TestApi(state_controller_->
             animator_.get()));
     shell_delegate_ = reinterpret_cast<TestShellDelegate*>(
         ash::Shell::GetInstance()->delegate());
   }
 
+  void TearDown() {
+    animator_helper_->ForwardWhileRunning();
+    AshTestBase::TearDown();
+  }
+
  protected:
   void GenerateMouseMoveEvent() {
     aura::test::EventGenerator generator(
         Shell::GetPrimaryRootWindow());
     generator.MoveMouseTo(10, 10);
   }
 
   int NumShutdownRequests() {
     return delegate_->num_shutdown_requests() +
            shell_delegate_->num_exit_requests();
   }
 
+  void Forward(SessionStateAnimator::AnimationSpeed speed) {
+    animator_helper_->Forward(SessionStateAnimator::GetDuration(speed));
+  }
+
+  void ForwardPartially(SessionStateAnimator::AnimationSpeed speed,
+                        float factor) {
+    base::TimeDelta duration = SessionStateAnimator::GetDuration(speed);
+    base::TimeDelta partial_duration =
+        base::TimeDelta::FromInternalValue(duration.ToInternalValue() * factor);
+    animator_helper_->Forward(partial_duration);
+  }
+
+  void ExpectLockPartOneAnimationStarted() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_LIFT));
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LAUNCHER,
+            SessionStateAnimator::ANIMATION_FADE_OUT));
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY));
+    EXPECT_TRUE(test_api_->is_animating_lock());
+  }
+
+  void ExpectLockPartOneAnimationUndo() {
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_DROP));
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LAUNCHER,
+            SessionStateAnimator::ANIMATION_FADE_IN));
+  }
+
+  void ExpectLockPartOneAnimationFinished() {
+    EXPECT_FALSE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_LIFT));
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LAUNCHER,
+            SessionStateAnimator::ANIMATION_FADE_OUT));
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY));
+  }
+
+  void ExpectLockPartTwoAnimationStarted() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN));
+  }
+
+  void ExpectLockPartTwoAnimationFinished() {
+    EXPECT_FALSE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN));
+  }
+
+  void ExpectUnlockPartOneAnimationStarted() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_LIFT));
+  }
+
+  void ExpectUnlockPartOneAnimationFinished() {
+    EXPECT_FALSE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_LIFT));
+  }
+
+  void ExpectUnlockPartTwoAnimationStarted() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_DROP));
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LAUNCHER,
+            SessionStateAnimator::ANIMATION_FADE_IN));
+  }
+
+  void ExpectUnlockPartTwoAnimationFinished() {
+    EXPECT_FALSE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+            SessionStateAnimator::ANIMATION_DROP));
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::LAUNCHER,
+            SessionStateAnimator::ANIMATION_FADE_IN));
+  }
+
+  void ExpectShutdownAnimationStarted() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->RootWindowIsAnimated(
+            SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
+  }
+
+  void ExpectShutdownAnimationFinished()  {
+    EXPECT_FALSE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->RootWindowIsAnimated(
+            SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
+  }
+
+  void ExpectShutdownAnimationUndo() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->RootWindowIsAnimated(
+            SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS));
+  }
+
+  void ExpectBackgroundIsShowing() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::DESKTOP_BACKGROUND,
+            SessionStateAnimator::ANIMATION_FADE_IN));
+  }
+
+  void ExpectBackgroundIsHiding() {
+    EXPECT_TRUE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(
+        animator_api_->ContainersAreAnimated(
+            SessionStateAnimator::DESKTOP_BACKGROUND,
+            SessionStateAnimator::ANIMATION_FADE_OUT));
+  }
+
+  void ExpectUnlockedState() {
+    EXPECT_FALSE(animator_helper_->IsAnimating());
+    EXPECT_FALSE(shell_delegate_->IsScreenLocked());
+
+    aura::Window::Windows containers;
+
+    SessionStateAnimator::GetContainers(
+        SessionStateAnimator::LAUNCHER |
+        SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
+        &containers);
+    for (aura::Window::Windows::const_iterator it = containers.begin();
+         it != containers.end(); ++it) {
+      aura::Window* window = *it;
+      ui::Layer* layer = window->layer();
+      EXPECT_EQ(1.0, layer->opacity());
+      EXPECT_EQ(0.0, layer->layer_brightness());
+      EXPECT_EQ(0.0, layer->layer_saturation());
+      EXPECT_EQ(gfx::Transform(), layer->transform());
+    }
+  }
+
+  void ExpectLockedState() {
+    EXPECT_FALSE(animator_helper_->IsAnimating());
+    EXPECT_TRUE(shell_delegate_->IsScreenLocked());
+
+    aura::Window::Windows containers;
+
+    SessionStateAnimator::GetContainers(
+        SessionStateAnimator::LOCK_SCREEN_RELATED_CONTAINERS |
+        SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
+        &containers);
+    for (aura::Window::Windows::const_iterator it = containers.begin();
+         it != containers.end(); ++it) {
+      aura::Window* window = *it;
+      ui::Layer* layer = window->layer();
+      EXPECT_EQ(1.0, layer->opacity());
+      EXPECT_EQ(0.0, layer->layer_brightness());
+      EXPECT_EQ(0.0, layer->layer_saturation());
+      EXPECT_EQ(gfx::Transform(), layer->transform());
+    }
+  }
+
+  void PressPowerButton() {
+    controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
+    animator_helper_->Ping();
+  }
+
+  void ReleasePowerButton() {
+    controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
+    animator_helper_->Ping();
+  }
+
+  void PressLockButton() {
+    controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
+  }
+
+  void ReleaseLockButton() {
+    controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
+  }
+
+  void SystemLocks() {
+    state_controller_->OnLockStateChanged(true);
+    shell_delegate_->LockScreen();
+    animator_helper_->Ping();
+  }
+
+  void SuccessfulAuthentication(bool* call_flag) {
+    base::Closure closure = base::Bind(&CheckCalledCallback, call_flag);
+    state_controller_->OnLockScreenHide(closure);
+    animator_helper_->Ping();
+  }
+
+  void SystemUnlocks() {
+    state_controller_->OnLockStateChanged(false);
+    shell_delegate_->UnlockScreen();
+    animator_helper_->Ping();
+  }
+
+  void Initialize(bool legacy_button, user::LoginStatus status) {
+    controller_->set_has_legacy_power_button_for_test(legacy_button);
+    state_controller_->OnLoginStateChanged(status);
+    SetUserLoggedIn(status != user::LOGGED_IN_NONE);
+    if (status == user::LOGGED_IN_GUEST)
+      SetCanLockScreen(false);
+    state_controller_->OnLockStateChanged(false);
+  }
+
   PowerButtonController* controller_;  // not owned
   SessionStateControllerImpl2* state_controller_;  // not owned
   TestSessionStateControllerDelegate* delegate_;  // not owned
   TestShellDelegate* shell_delegate_;  // not owned
 
   scoped_ptr<SessionStateControllerImpl2::TestApi> test_api_;
-  scoped_ptr<internal::SessionStateAnimator::TestApi> animator_api_;
+  scoped_ptr<SessionStateAnimator::TestApi> animator_api_;
+  scoped_ptr<ui::test::AnimationContainerTestHelper> animator_helper_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SessionStateControllerImpl2Test);
 };
 
 // Test the lock-to-shutdown flow for non-Chrome-OS hardware that doesn't
 // correctly report power button releases.  We should lock immediately the first
 // time the button is pressed and shut down when it's pressed from the locked
 // state.
 TEST_F(SessionStateControllerImpl2Test, LegacyLockAndShutDown) {
-  controller_->set_has_legacy_power_button_for_test(true);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(false);
+  Initialize(true, user::LOGGED_IN_USER);
+
+  ExpectUnlockedState();
 
   // We should request that the screen be locked immediately after seeing the
   // power button get pressed.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
+  PressPowerButton();
 
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
+  ExpectLockPartOneAnimationStarted();
+
+  EXPECT_FALSE(test_api_->is_lock_undoable());
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+
+  ExpectLockPartOneAnimationFinished();
   EXPECT_EQ(1, delegate_->num_lock_requests());
 
   // Notify that we locked successfully.
   state_controller_->OnStartingLock();
+  // We had that animation already.
+  EXPECT_FALSE(animator_helper_->IsAnimating());
 
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY));
+  SystemLocks();
 
-
-  // Notify that the lock window is visible.  We should make it fade in.
-  state_controller_->OnLockStateChanged(true);
-  shell_delegate_->LockScreen();
-
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN));
+  ExpectLockPartTwoAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectLockPartTwoAnimationFinished();
 
   // We shouldn't progress towards the shutdown state, however.
   EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running());
   EXPECT_FALSE(test_api_->shutdown_timer_is_running());
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
+
+  ReleasePowerButton();
 
   // Hold the button again and check that we start shutting down.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
+  PressPowerButton();
+
+  ExpectShutdownAnimationStarted();
+
   EXPECT_EQ(0, NumShutdownRequests());
-
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
   // Make sure a mouse move event won't show the cursor.
   GenerateMouseMoveEvent();
   EXPECT_FALSE(cursor_visible());
+
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
   test_api_->trigger_real_shutdown_timeout();
   EXPECT_EQ(1, NumShutdownRequests());
 }
 
 // Test that we start shutting down immediately if the power button is pressed
 // while we're not logged in on an unofficial system.
 TEST_F(SessionStateControllerImpl2Test, LegacyNotLoggedIn) {
-  controller_->set_has_legacy_power_button_for_test(true);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_NONE);
-  state_controller_->OnLockStateChanged(false);
-  SetUserLoggedIn(false);
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
+  Initialize(true, user::LOGGED_IN_NONE);
+
+  PressPowerButton();
+  ExpectShutdownAnimationStarted();
+
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
 }
 
 // Test that we start shutting down immediately if the power button is pressed
 // while we're logged in as a guest on an unofficial system.
 TEST_F(SessionStateControllerImpl2Test, LegacyGuest) {
-  controller_->set_has_legacy_power_button_for_test(true);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_GUEST);
-  state_controller_->OnLockStateChanged(false);
-  SetCanLockScreen(false);
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
+  Initialize(true, user::LOGGED_IN_GUEST);
+
+  PressPowerButton();
+  ExpectShutdownAnimationStarted();
+
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
 }
 
 // When we hold the power button while the user isn't logged in, we should shut
 // down the machine directly.
 TEST_F(SessionStateControllerImpl2Test, ShutdownWhenNotLoggedIn) {
-  controller_->set_has_legacy_power_button_for_test(false);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_NONE);
-  state_controller_->OnLockStateChanged(false);
-  SetUserLoggedIn(false);
+  Initialize(false, user::LOGGED_IN_NONE);
 
   // Press the power button and check that we start the shutdown timer.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
+  PressPowerButton();
+  EXPECT_FALSE(test_api_->is_animating_lock());
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
+  ExpectShutdownAnimationStarted();
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN, 0.5);
 
   // Release the power button before the shutdown timer fires.
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
+  ReleasePowerButton();
+
   EXPECT_FALSE(test_api_->shutdown_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS));
+  ExpectShutdownAnimationUndo();
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_REVERT, 0.5);
 
   // Press the button again and make the shutdown timeout fire this time.
   // Check that we start the timer for actually requesting the shutdown.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
+  PressPowerButton();
+
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+  ExpectShutdownAnimationFinished();
   test_api_->trigger_shutdown_timeout();
+
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
   EXPECT_EQ(0, NumShutdownRequests());
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
 
   // When the timout fires, we should request a shutdown.
   test_api_->trigger_real_shutdown_timeout();
+
   EXPECT_EQ(1, NumShutdownRequests());
 }
 
 // Test that we lock the screen and deal with unlocking correctly.
 TEST_F(SessionStateControllerImpl2Test, LockAndUnlock) {
-  controller_->set_has_legacy_power_button_for_test(false);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(false);
-
-  // We should initially be showing the screen locker containers, since they
-  // also contain login-related windows that we want to show during the
-  // logging-in animation.
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_RESTORE));
+  Initialize(false, user::LOGGED_IN_USER);
+
+  ExpectUnlockedState();
 
   // Press the power button and check that the lock timer is started and that we
   // start lifting the non-screen-locker containers.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  EXPECT_FALSE(test_api_->shutdown_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
-
-  // Release the button before the lock timer fires.
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_DROP));
-
-  // Press the button and fire the lock timer.  We should request that the
-  // screen be locked, but we should still be in the lift animation.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
+  PressPowerButton();
+
+  ExpectLockPartOneAnimationStarted();
+  EXPECT_TRUE(test_api_->is_lock_undoable());
   EXPECT_EQ(0, delegate_->num_lock_requests());
-  test_api_->trigger_lock_timeout();
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
+  ExpectLockPartOneAnimationFinished();
+
   EXPECT_EQ(1, delegate_->num_lock_requests());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
 
   // Notify that we locked successfully.
   state_controller_->OnStartingLock();
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY));
-
-  // Notify that the lock window is visible.  We should make it raise in.
-  state_controller_->OnLockStateChanged(true);
-  shell_delegate_->LockScreen();
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN));
+  // We had that animation already.
+  EXPECT_FALSE(animator_helper_->IsAnimating());
+
+  SystemLocks();
+
+  ExpectLockPartTwoAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectLockPartTwoAnimationFinished();
 
   // When we release the power button, the lock-to-shutdown timer should be
   // stopped.
+  ExpectLockedState();
   EXPECT_TRUE(test_api_->lock_to_shutdown_timer_is_running());
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
+  ReleasePowerButton();
+  ExpectLockedState();
   EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running());
 
   // Notify that the screen has been unlocked.  We should show the
   // non-screen-locker windows.
-  state_controller_->OnLockStateChanged(false);
-  shell_delegate_->UnlockScreen();
   bool called = false;
-  base::Closure closure = base::Bind(&CheckCalledCallback, &called);
-  state_controller_->OnLockScreenHide(closure);
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
+  SuccessfulAuthentication(&called);
+
+  ExpectUnlockPartOneAnimationStarted();
+  EXPECT_FALSE(called);
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectUnlockPartOneAnimationFinished();
+
   EXPECT_TRUE(called);
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_DROP));
+
+  SystemUnlocks();
+
+  ExpectUnlockPartTwoAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectUnlockPartTwoAnimationFinished();
+
+  ExpectUnlockedState();
+}
+
+// Test that we deal with cancelling lock correctly.
+TEST_F(SessionStateControllerImpl2Test, LockAndCancel) {
+  Initialize(false, user::LOGGED_IN_USER);
+
+  ExpectUnlockedState();
+
+  // Press the power button and check that the lock timer is started and that we
+  // start lifting the non-screen-locker containers.
+  PressPowerButton();
+
+  ExpectLockPartOneAnimationStarted();
+  EXPECT_TRUE(test_api_->is_lock_undoable());
+
+  // forward only half way through
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5);
+
+  // Release the button before the lock timer fires.
+  ReleasePowerButton();
+  ExpectLockPartOneAnimationUndo();
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+
+  ExpectUnlockedState();
+  EXPECT_EQ(0, delegate_->num_lock_requests());
+}
+
+// Test that we deal with cancelling lock correctly.
+TEST_F(SessionStateControllerImpl2Test, LockAndCancelAndLockAgain) {
+  Initialize(false, user::LOGGED_IN_USER);
+
+  ExpectUnlockedState();
+
+  // Press the power button and check that the lock timer is started and that we
+  // start lifting the non-screen-locker containers.
+  PressPowerButton();
+
+  ExpectLockPartOneAnimationStarted();
+  EXPECT_TRUE(test_api_->is_lock_undoable());
+
+  // forward only half way through
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5);
+
+  // Release the button before the lock timer fires.
+  ReleasePowerButton();
+  ExpectLockPartOneAnimationUndo();
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, 0.5);
+
+  PressPowerButton();
+  ExpectLockPartOneAnimationStarted();
+  EXPECT_TRUE(test_api_->is_lock_undoable());
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.6);
+
+  EXPECT_EQ(0, delegate_->num_lock_requests());
+  ExpectLockPartOneAnimationStarted();
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.6);
+  ExpectLockPartOneAnimationFinished();
+  EXPECT_EQ(1, delegate_->num_lock_requests());
 }
 
 // Hold the power button down from the unlocked state to eventual shutdown.
 TEST_F(SessionStateControllerImpl2Test, LockToShutdown) {
-  controller_->set_has_legacy_power_button_for_test(false);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(false);
+  Initialize(false, user::LOGGED_IN_USER);
 
   // Hold the power button and lock the screen.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  test_api_->trigger_lock_timeout();
-  state_controller_->OnStartingLock();
-  state_controller_->OnLockStateChanged(true);
-  shell_delegate_->LockScreen();
+  PressPowerButton();
+  EXPECT_TRUE(test_api_->is_animating_lock());
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
+  SystemLocks();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
 
   // When the lock-to-shutdown timeout fires, we should start the shutdown
   // timer.
   EXPECT_TRUE(test_api_->lock_to_shutdown_timer_is_running());
+
   test_api_->trigger_lock_to_shutdown_timeout();
+
+  ExpectShutdownAnimationStarted();
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN));
 
   // Fire the shutdown timeout and check that we request shutdown.
+  Forward(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+  ExpectShutdownAnimationFinished();
   test_api_->trigger_shutdown_timeout();
+
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
   EXPECT_EQ(0, NumShutdownRequests());
   test_api_->trigger_real_shutdown_timeout();
   EXPECT_EQ(1, NumShutdownRequests());
 }
 
-
 // Hold the power button down from the unlocked state to eventual shutdown,
 // then release the button while system does locking.
 TEST_F(SessionStateControllerImpl2Test, CancelLockToShutdown) {
-  controller_->set_has_legacy_power_button_for_test(false);
-
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(false);
+  Initialize(false, user::LOGGED_IN_USER);
+
+  PressPowerButton();
 
   // Hold the power button and lock the screen.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  test_api_->trigger_lock_timeout();
-  state_controller_->OnStartingLock();
+  EXPECT_TRUE(test_api_->is_animating_lock());
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
+  SystemLocks();
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS, 0.5);
 
   // Power button is released while system attempts to lock.
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
-  state_controller_->OnLockStateChanged(true);
-  shell_delegate_->LockScreen();
+  ReleasePowerButton();
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
 
   EXPECT_FALSE(state_controller_->ShutdownRequested());
   EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running());
   EXPECT_FALSE(test_api_->shutdown_timer_is_running());
 }
 
 // Test that we handle the case where lock requests are ignored.
 TEST_F(SessionStateControllerImpl2Test, Lock) {
   // We require animations to have a duration for this test.
   ui::LayerAnimator::set_disable_animations_for_test(false);
 
-  controller_->set_has_legacy_power_button_for_test(false);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(false);
+  Initialize(false, user::LOGGED_IN_USER);
 
   // Hold the power button and lock the screen.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
-  test_api_->trigger_lock_timeout();
+  PressPowerButton();
+  ExpectLockPartOneAnimationStarted();
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
+
   EXPECT_EQ(1, delegate_->num_lock_requests());
   EXPECT_TRUE(test_api_->lock_fail_timer_is_running());
-
   // We shouldn't start the lock-to-shutdown timer until the screen has actually
-  // been locked.
+  // been locked and this was animated.
   EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running());
 
   // Act as if the request timed out.  We should restore the windows.
   test_api_->trigger_lock_fail_timeout();
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_DROP));
+
+  ExpectUnlockPartTwoAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectUnlockPartTwoAnimationFinished();
+  ExpectUnlockedState();
+}
+
+// Test the basic operation of the lock button (not logged in).
+TEST_F(SessionStateControllerImpl2Test, LockButtonBasicNotLoggedIn) {
+  // The lock button shouldn't do anything if we aren't logged in.
+  Initialize(false, user::LOGGED_IN_NONE);
+
+  PressLockButton();
+  EXPECT_FALSE(test_api_->is_animating_lock());
+  ReleaseLockButton();
+  EXPECT_EQ(0, delegate_->num_lock_requests());
+}
+
+// Test the basic operation of the lock button (guest).
+TEST_F(SessionStateControllerImpl2Test, LockButtonBasicGuest) {
+  // The lock button shouldn't do anything when we're logged in as a guest.
+  Initialize(false, user::LOGGED_IN_GUEST);
+
+  PressLockButton();
+  EXPECT_FALSE(test_api_->is_animating_lock());
+  ReleaseLockButton();
+  EXPECT_EQ(0, delegate_->num_lock_requests());
 }
 
 // Test the basic operation of the lock button.
 TEST_F(SessionStateControllerImpl2Test, LockButtonBasic) {
-  controller_->set_has_legacy_power_button_for_test(false);
-  // The lock button shouldn't do anything if we aren't logged in.
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_NONE);
-  state_controller_->OnLockStateChanged(false);
-  SetUserLoggedIn(false);
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_EQ(0, delegate_->num_lock_requests());
-
-  // Ditto for when we're logged in as a guest.
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_GUEST);
-  SetUserLoggedIn(true);
-  SetCanLockScreen(false);
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_EQ(0, delegate_->num_lock_requests());
-
   // If we're logged in as a regular user, we should start the lock timer and
   // the pre-lock animation.
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  SetCanLockScreen(true);
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
+  Initialize(false, user::LOGGED_IN_USER);
+
+  PressLockButton();
+  ExpectLockPartOneAnimationStarted();
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5);
 
   // If the button is released immediately, we shouldn't lock the screen.
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_DROP));
+  ReleaseLockButton();
+  ExpectLockPartOneAnimationUndo();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+
+  ExpectUnlockedState();
   EXPECT_EQ(0, delegate_->num_lock_requests());
 
   // Press the button again and let the lock timeout fire.  We should request
   // that the screen be locked.
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  test_api_->trigger_lock_timeout();
+  PressLockButton();
+  ExpectLockPartOneAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
   EXPECT_EQ(1, delegate_->num_lock_requests());
 
   // Pressing the lock button while we have a pending lock request shouldn't do
   // anything.
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
+  ReleaseLockButton();
+  PressLockButton();
+  ExpectLockPartOneAnimationFinished();
+  ReleaseLockButton();
 
   // Pressing the button also shouldn't do anything after the screen is locked.
-  state_controller_->OnStartingLock();
-  state_controller_->OnLockStateChanged(true);
-  shell_delegate_->LockScreen();
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
+  SystemLocks();
+  ExpectLockPartTwoAnimationStarted();
+
+  PressLockButton();
+  ReleaseLockButton();
+  ExpectLockPartTwoAnimationStarted();
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectLockPartTwoAnimationFinished();
+
+  PressLockButton();
+  ReleaseLockButton();
+  ExpectLockPartTwoAnimationFinished();
 }
 
 // Test that the power button takes priority over the lock button.
 TEST_F(SessionStateControllerImpl2Test, PowerButtonPreemptsLockButton) {
-  controller_->set_has_legacy_power_button_for_test(false);
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(false);
+  Initialize(false, user::LOGGED_IN_USER);
 
   // While the lock button is down, hold the power button.
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
+  PressLockButton();
+  ExpectLockPartOneAnimationStarted();
+  PressPowerButton();
+  ExpectLockPartOneAnimationStarted();
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5);
 
   // The lock timer shouldn't be stopped when the lock button is released.
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
+  ReleaseLockButton();
+  ExpectLockPartOneAnimationStarted();
+  ReleasePowerButton();
+  ExpectLockPartOneAnimationUndo();
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectUnlockedState();
 
   // Now press the power button first and then the lock button.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
-  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
+  PressPowerButton();
+  ExpectLockPartOneAnimationStarted();
+  PressLockButton();
+  ExpectLockPartOneAnimationStarted();
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5);
 
   // Releasing the power button should stop the lock timer.
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
-  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
+  ReleasePowerButton();
+  ExpectLockPartOneAnimationUndo();
+  ReleaseLockButton();
+  ExpectLockPartOneAnimationUndo();
 }
 
 // When the screen is locked without going through the usual power-button
 // slow-close path (e.g. via the wrench menu), test that we still show the
 // fast-close animation.
 TEST_F(SessionStateControllerImpl2Test, LockWithoutButton) {
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
+  Initialize(false, user::LOGGED_IN_USER);
   state_controller_->OnStartingLock();
-  EXPECT_TRUE(
-      animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS |
-          internal::SessionStateAnimator::LAUNCHER,
-          internal::SessionStateAnimator::ANIMATION_LIFT));
+
+  ExpectLockPartOneAnimationStarted();
+  EXPECT_FALSE(test_api_->is_lock_undoable());
 }
 
 // When we hear that the process is exiting but we haven't had a chance to
 // display an animation, we should just blank the screen.
 TEST_F(SessionStateControllerImpl2Test, ShutdownWithoutButton) {
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
+  Initialize(false, user::LOGGED_IN_USER);
   state_controller_->OnAppTerminating();
+
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
-          internal::SessionStateAnimator::kAllContainersMask,
-          internal::SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY));
+          SessionStateAnimator::kAllContainersMask,
+          SessionStateAnimator::ANIMATION_HIDE_IMMEDIATELY));
   GenerateMouseMoveEvent();
   EXPECT_FALSE(cursor_visible());
 }
 
 // Test that we display the fast-close animation and shut down when we get an
 // outside request to shut down (e.g. from the login or lock screen).
 TEST_F(SessionStateControllerImpl2Test, RequestShutdownFromLoginScreen) {
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_NONE);
-  state_controller_->OnLockStateChanged(false);
-  SetUserLoggedIn(false);
+  Initialize(false, user::LOGGED_IN_NONE);
+
   state_controller_->RequestShutdown();
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
+
+  ExpectShutdownAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+
   GenerateMouseMoveEvent();
   EXPECT_FALSE(cursor_visible());
 
   EXPECT_EQ(0, NumShutdownRequests());
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
   test_api_->trigger_real_shutdown_timeout();
   EXPECT_EQ(1, NumShutdownRequests());
 }
 
 TEST_F(SessionStateControllerImpl2Test, RequestShutdownFromLockScreen) {
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(true);
-  shell_delegate_->LockScreen();
+  Initialize(false, user::LOGGED_IN_USER);
+
+  SystemLocks();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+  ExpectLockPartTwoAnimationFinished();
+
   state_controller_->RequestShutdown();
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
+
+  ExpectShutdownAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+
   GenerateMouseMoveEvent();
   EXPECT_FALSE(cursor_visible());
 
   EXPECT_EQ(0, NumShutdownRequests());
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
   test_api_->trigger_real_shutdown_timeout();
   EXPECT_EQ(1, NumShutdownRequests());
 }
 
 TEST_F(SessionStateControllerImpl2Test,
        RequestAndCancelShutdownFromLockScreen) {
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
-  state_controller_->OnLockStateChanged(true);
-  shell_delegate_->LockScreen();
+  Initialize(false, user::LOGGED_IN_USER);
+
+  SystemLocks();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN);
+  ExpectLockedState();
 
   // Press the power button and check that we start the shutdown timer.
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
+  PressPowerButton();
+  EXPECT_FALSE(test_api_->is_animating_lock());
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
+
+  ExpectShutdownAnimationStarted();
+
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_SHUTDOWN, 0.5);
 
   // Release the power button before the shutdown timer fires.
-  controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
+  ReleasePowerButton();
+
   EXPECT_FALSE(test_api_->shutdown_timer_is_running());
-  EXPECT_TRUE(
-      animator_api_->RootWindowIsAnimated(
-          internal::SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS));
+
+  ExpectShutdownAnimationUndo();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_REVERT);
+  ExpectLockedState();
 }
 
 // Test that we ignore power button presses when the screen is turned off.
 TEST_F(SessionStateControllerImpl2Test, IgnorePowerButtonIfScreenIsOff) {
-  state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
+  Initialize(false, user::LOGGED_IN_USER);
 
   // When the screen brightness is at 0%, we shouldn't do anything in response
   // to power button presses.
   controller_->OnScreenBrightnessChanged(0.0);
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_FALSE(test_api_->lock_timer_is_running());
+
+  PressPowerButton();
+  EXPECT_FALSE(test_api_->is_animating_lock());
+  ReleasePowerButton();
 
   // After increasing the brightness to 10%, we should start the timer like
   // usual.
   controller_->OnScreenBrightnessChanged(10.0);
-  controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-  EXPECT_TRUE(test_api_->lock_timer_is_running());
+
+  PressPowerButton();
+  EXPECT_TRUE(test_api_->is_animating_lock());
+}
+
+// Test that hidden background appears and revers correctly on lock/cancel.
+TEST_F(SessionStateControllerImpl2Test, TestHiddenBackgroundLockCancel) {
+  Initialize(false, user::LOGGED_IN_USER);
+  HideBackground();
+
+  EXPECT_TRUE(IsBackgroundHidden());
+  ExpectUnlockedState();
+  PressPowerButton();
+
+  ExpectLockPartOneAnimationStarted();
+  EXPECT_FALSE(IsBackgroundHidden());
+  ExpectBackgroundIsShowing();
+
+  // Forward only half way through.
+  ForwardPartially(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE, 0.5);
+
+  // Release the button before the lock timer fires.
+  ReleasePowerButton();
+  ExpectLockPartOneAnimationUndo();
+  ExpectBackgroundIsHiding();
+  EXPECT_FALSE(IsBackgroundHidden());
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+
+  ExpectUnlockedState();
+  EXPECT_TRUE(IsBackgroundHidden());
+}
+
+// Test that hidden background appears and revers correctly on lock/unlock.
+TEST_F(SessionStateControllerImpl2Test, TestHiddenBackgroundLockUnlock) {
+  Initialize(false, user::LOGGED_IN_USER);
+  HideBackground();
+
+  EXPECT_TRUE(IsBackgroundHidden());
+  ExpectUnlockedState();
+
+  // Press the power button and check that the lock timer is started and that we
+  // start lifting the non-screen-locker containers.
+  PressPowerButton();
+
+  ExpectLockPartOneAnimationStarted();
+  EXPECT_FALSE(IsBackgroundHidden());
+  ExpectBackgroundIsShowing();
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
+
+  ExpectLockPartOneAnimationFinished();
+
+  SystemLocks();
+
+  ExpectLockPartTwoAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectLockPartTwoAnimationFinished();
+
+  ExpectLockedState();
+
+  SuccessfulAuthentication(NULL);
+
+  ExpectUnlockPartOneAnimationStarted();
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectUnlockPartOneAnimationFinished();
+
+  SystemUnlocks();
+
+  ExpectUnlockPartTwoAnimationStarted();
+  ExpectBackgroundIsHiding();
+  EXPECT_FALSE(IsBackgroundHidden());
+
+  Forward(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
+  ExpectUnlockPartTwoAnimationFinished();
+  EXPECT_TRUE(IsBackgroundHidden());
+
+  ExpectUnlockedState();
 }
 
 }  // namespace test
 }  // namespace ash