ash : introduce second SessionStateController implementation.

ash/wm/power_button_controller_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/power_button_controller.h"
 #include "ash/wm/session_state_animator.h"
 #include "ash/wm/session_state_controller.h"
+#include "ash/wm/session_state_controller_impl.h"
 
+#include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/cursor_manager.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/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace ash {
 namespace test {
@@ skipping 32 matching lines @@
 
 class PowerButtonControllerTest : public AshTestBase {
  public:
   PowerButtonControllerTest() : controller_(NULL), delegate_(NULL) {}
   virtual ~PowerButtonControllerTest() {}
 
   void SetUp() OVERRIDE {
     AshTestBase::SetUp();
     delegate_ = new TestPowerButtonControllerDelegate;
     controller_ = Shell::GetInstance()->power_button_controller();
-    state_controller_ = Shell::GetInstance()->session_state_controller();
+    CHECK(!CommandLine::ForCurrentProcess()->HasSwitch(
+        ash::switches::kAshNewLockAnimationsEnabled));
+    state_controller_ = static_cast<SessionStateControllerImpl*>(
+        Shell::GetInstance()->session_state_controller());
     state_controller_->SetDelegate(delegate_);  // transfers ownership
-    test_api_.reset(new SessionStateController::TestApi(state_controller_));
+    test_api_.reset(new SessionStateControllerImpl::TestApi(state_controller_));
     animator_api_.reset(
         new internal::SessionStateAnimator::TestApi(state_controller_->
             animator_.get()));
   }
 
  protected:
   void GenerateMouseMoveEvent() {
     aura::test::EventGenerator generator(
         Shell::GetPrimaryRootWindow());
     generator.MoveMouseTo(10, 10);
   }
 
   int NumShutdownRequests() {
     return delegate_->num_shutdown_requests() +
            reinterpret_cast<TestShellDelegate*>(
                ash::Shell::GetInstance()->delegate())->num_exit_requests();
   }
 
   PowerButtonController* controller_;  // not owned
-  SessionStateController* state_controller_;  // not owned
+  SessionStateControllerImpl* state_controller_;  // not owned
   TestPowerButtonControllerDelegate* delegate_;  // not owned
 
-  scoped_ptr<SessionStateController::TestApi> test_api_;
+  scoped_ptr<SessionStateControllerImpl::TestApi> test_api_;
   scoped_ptr<internal::SessionStateAnimator::TestApi> animator_api_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PowerButtonControllerTest);
 };
 
 // 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(PowerButtonControllerTest, LegacyLockAndShutDown) {
   controller_->set_has_legacy_power_button_for_test(true);
   state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
   state_controller_->OnLockStateChanged(false);
 
   // 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::ANIMATION_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
   EXPECT_FALSE(animator_api_->hide_black_layer_timer_is_running());
   EXPECT_FALSE(test_api_->lock_timer_is_running());
   EXPECT_EQ(1, delegate_->num_lock_requests());
 
   // Notify that we locked successfully.
   state_controller_->OnStartingLock();
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::LAUNCHER,
           internal::SessionStateAnimator::ANIMATION_HIDE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_FAST_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_FULL_CLOSE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
           internal::SessionStateAnimator::ANIMATION_HIDE));
 
   // Notify that the lock window is visible.  We should make it fade in.
   state_controller_->OnLockStateChanged(true);
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllLockScreenContainersMask,
@@ skipping 13 matching lines @@
   // 1. All user session containers have transform (including wallpaper).
   //    They're in this state after lock.
   // 2. Screen locker and related containers are in fact animating
   //    (as shutdown is in progress).
   // With http://crbug.com/144737 we no longer animate user session wallpaper
   // during lock so it makes sense only to check that screen lock and related
   // containers are animated during shutdown.
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllLockScreenContainersMask,
-          internal::SessionStateAnimator::ANIMATION_FAST_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_FULL_CLOSE));
   // 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.
@@ skipping 23 matching lines @@
   state_controller_->OnLockStateChanged(false);
   EXPECT_FALSE(animator_api_->BlackLayerIsVisible());
 
   // 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());
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllContainersMask,
-          internal::SessionStateAnimator::ANIMATION_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 
   // Release the power button before the shutdown timer fires.
   controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
   EXPECT_FALSE(test_api_->shutdown_timer_is_running());
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllContainersMask,
-          internal::SessionStateAnimator::ANIMATION_UNDO_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 
   // We should re-hide the black layer after waiting long enough for
   // the animation to finish.
   EXPECT_TRUE(animator_api_->hide_black_layer_timer_is_running());
   animator_api_->TriggerHideBlackLayerTimeout();
   EXPECT_FALSE(animator_api_->BlackLayerIsVisible());
 
   // 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());
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
   test_api_->trigger_shutdown_timeout();
   EXPECT_TRUE(test_api_->real_shutdown_timer_is_running());
   EXPECT_EQ(0, NumShutdownRequests());
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::LAUNCHER |
               internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
           internal::SessionStateAnimator::ANIMATION_HIDE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllLockScreenContainersMask,
-          internal::SessionStateAnimator::ANIMATION_FAST_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_FULL_CLOSE));
 
   // 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(PowerButtonControllerTest, LockAndUnlock) {
   controller_->set_has_legacy_power_button_for_test(false);
   state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
   state_controller_->OnLockStateChanged(false);
   EXPECT_FALSE(animator_api_->BlackLayerIsVisible());
 
   // 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));
 
   // Press the power button and check that the lock timer is started and that we
   // start scaling 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::ANIMATION_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 
   // 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::ANIMATION_UNDO_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
   EXPECT_TRUE(animator_api_->hide_black_layer_timer_is_running());
   animator_api_->TriggerHideBlackLayerTimeout();
   EXPECT_FALSE(animator_api_->BlackLayerIsVisible());
 
   // Press the button and fire the lock timer.  We should request that the
   // screen be locked, but we should still be in the slow-close animation.
   controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
   EXPECT_TRUE(test_api_->lock_timer_is_running());
   EXPECT_EQ(0, delegate_->num_lock_requests());
   test_api_->trigger_lock_timeout();
   EXPECT_EQ(1, delegate_->num_lock_requests());
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 
   // Notify that we locked successfully.
   state_controller_->OnStartingLock();
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::LAUNCHER,
           internal::SessionStateAnimator::ANIMATION_HIDE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_FAST_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_FULL_CLOSE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
           internal::SessionStateAnimator::ANIMATION_HIDE));
 
   // Notify that the lock window is visible.  We should make it fade in.
   state_controller_->OnLockStateChanged(true);
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllLockScreenContainersMask,
@@ skipping 32 matching lines @@
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 
   // 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();
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllContainersMask,
-          internal::SessionStateAnimator::ANIMATION_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE));
 
   // Fire the shutdown timeout and check that we request shutdown.
   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());
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 }
 
@@ skipping 93 matching lines @@
   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);
   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::ANIMATION_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 
   // 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::ANIMATION_UNDO_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
   EXPECT_TRUE(animator_api_->hide_black_layer_timer_is_running());
   animator_api_->TriggerHideBlackLayerTimeout();
   EXPECT_FALSE(animator_api_->BlackLayerIsVisible());
   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());
@@ skipping 48 matching lines @@
 
 // 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 and display the black layer.
 TEST_F(PowerButtonControllerTest, LockWithoutButton) {
   state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
   state_controller_->OnStartingLock();
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
-          internal::SessionStateAnimator::ANIMATION_FAST_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_FULL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 }
 
 // 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(PowerButtonControllerTest, ShutdownWithoutButton) {
   state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
   state_controller_->OnAppTerminating();
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllContainersMask,
           internal::SessionStateAnimator::ANIMATION_HIDE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
   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(PowerButtonControllerTest, RequestShutdownFromLoginScreen) {
   state_controller_->OnLoginStateChanged(user::LOGGED_IN_NONE);
   state_controller_->RequestShutdown();
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
           internal::SessionStateAnimator::ANIMATION_HIDE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllLockScreenContainersMask,
-          internal::SessionStateAnimator::ANIMATION_FAST_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_FULL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
   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(PowerButtonControllerTest, RequestShutdownFromLockScreen) {
   state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
   state_controller_->OnLockStateChanged(true);
   state_controller_->RequestShutdown();
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::NON_LOCK_SCREEN_CONTAINERS,
           internal::SessionStateAnimator::ANIMATION_HIDE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllLockScreenContainersMask,
-          internal::SessionStateAnimator::ANIMATION_FAST_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_FULL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
   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(PowerButtonControllerTest, RequestAndCancelShutdownFromLockScreen) {
   state_controller_->OnLoginStateChanged(user::LOGGED_IN_USER);
   state_controller_->OnLockStateChanged(true);
 
   // 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());
   EXPECT_TRUE(test_api_->shutdown_timer_is_running());
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllContainersMask,
-          internal::SessionStateAnimator::ANIMATION_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_PARTIAL_CLOSE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 
   // Release the power button before the shutdown timer fires.
   controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
   EXPECT_FALSE(test_api_->shutdown_timer_is_running());
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::kAllLockScreenContainersMask,
-          internal::SessionStateAnimator::ANIMATION_UNDO_SLOW_CLOSE));
+          internal::SessionStateAnimator::ANIMATION_UNDO_PARTIAL_CLOSE));
   EXPECT_TRUE(
       animator_api_->ContainersAreAnimated(
           internal::SessionStateAnimator::DESKTOP_BACKGROUND,
           internal::SessionStateAnimator::ANIMATION_RESTORE));
   EXPECT_TRUE(animator_api_->BlackLayerIsVisible());
 }
 
 // Test that the black layer is resized in response to root window resizes.
 TEST_F(PowerButtonControllerTest, ResizeBlackLayer) {
   controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
@@ skipping 18 matching lines @@
 
   // 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());
 }
 
 }  // namespace test
 }  // namespace ash