Added quick lock mechanism while in Touchview

ash/wm/lock_state_controller_unittest.cc

 // Copyright 2013 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/lock_state_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/test_lock_state_controller_delegate.h"
+#include "ash/test/test_screenshot_delegate.h"
 #include "ash/test/test_shell_delegate.h"
+#include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/wm/power_button_controller.h"
 #include "ash/wm/session_state_animator.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
@@ skipping 36 matching lines @@
 
 void HideBackground() {
   ui::ScopedLayerAnimationSettings settings(
       GetContainer(kShellWindowId_DesktopBackgroundContainer)
           ->layer()
           ->GetAnimator());
   settings.SetTransitionDuration(base::TimeDelta());
   GetContainer(kShellWindowId_DesktopBackgroundContainer)->Hide();
 }
 
-} // namespace
+}  // namespace
 
 class LockStateControllerTest : public AshTestBase {
  public:
   LockStateControllerTest() : controller_(NULL), delegate_(NULL) {}
   virtual ~LockStateControllerTest() {}
 
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
 
     // We would control animations in a fine way:
     animation_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode(
         ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION));
     // TODO(antrim) : restore
     // animator_helper_ = ui::test::CreateLayerAnimatorHelperForTest();
 
     // Temporary disable animations so that observer is always called, and
     // no leaks happen during tests.

[bruthig, 2014/08/29 14:44:33]

In order for the new QuickLock tests below to work in this test fixture they
require there to be an animation duration, however according to this comment it
appears that memory leaks occur if they do.

What I would like to propose is that change I PowerButtonController to accept a
pure virtual LockStateController 'interface' and rename the existing
LockStateController implementation to LockStateControllerImpl (or something like
that).  This would allow me to test the PowerButtonController logic in isolation
by passing in a simple LockStateController test stub.

Thoughts?

[Daniel Erat, 2014/08/29 14:58:26]

i am frustrated by how long all of the tests in this file have been disabled
(and by all of the commented-out code) and am highly supportive of any changes
that would result in them being enabled. (or am i misunderstanding your
suggestion? could the existing tests also be turned back on?)

[bruthig, 2014/08/29 15:41:47]

I actually spent quite a bit of time looking in to why these tests were disabled
and what it would take to re-enable them.  The problem is that these
LockStateControllerTests are actually exercising and verifying animation layers
and other stuff in the ui/compositor space, which in my opinion is much to large
a scope to verify alongside the triggers of when to perform such animations. 
And the best that I can tell, there is not a good way to to control the timing
of the animations from the test and they can only be set to run at some multiple
of real clock time, possibly even a zero multiple.  At the bottom of it all the
ui/compositor layers are dependent on a static Time/TimeTicks Now() function
which currently cannot be well controlled from within a test space.  The work to
be able to inject a mock time object is tracked here: www.crbug.com/166469 .

Now even if it were possible to to control the clock time from a
LockStateController test I am of the opinion that the test would still be
exercising way to much code outside of the ash space and we should somehow
create a better test seam somewhere between ash and the ui/compositor.  Perhaps
a SessionStateAnimator or ui::LayerAnimator test double.

So to answer your question, no, my suggestion would not allow me to easily
re-enable all the other tests in this file.  But it would allow me to actually
write tests to somewhat verify my current change.  My suggestion would also have
me move the QuickLock tests to a power_button_controller_test.cc file.

-    animation_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode(
-        ui::ScopedAnimationDurationScaleMode::ZERO_DURATION));
+    // animation_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode(
+    //     ui::ScopedAnimationDurationScaleMode::ZERO_DURATION));
     // TODO(antrim): once there is a way to mock time and run animations, make
     // sure that animations are finished even in simple tests.
 
     delegate_ = new TestLockStateControllerDelegate;
     controller_ = Shell::GetInstance()->power_button_controller();
     lock_state_controller_ = static_cast<LockStateController*>(
         Shell::GetInstance()->lock_state_controller());
     lock_state_controller_->SetDelegate(delegate_);  // transfers ownership
     test_api_.reset(new LockStateController::TestApi(lock_state_controller_));
     animator_api_.reset(
@@ skipping 16 matching lines @@
     ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
     generator.MoveMouseTo(10, 10);
   }
 
   int NumShutdownRequests() {
     return delegate_->num_shutdown_requests() +
            shell_delegate_->num_exit_requests();
   }
 
   void Advance(SessionStateAnimator::AnimationSpeed speed) {
-    // TODO (antrim) : restore
+    // TODO(antrim) : restore
     // animator_helper_->Advance(SessionStateAnimator::GetDuration(speed));
   }
 
   void AdvancePartially(SessionStateAnimator::AnimationSpeed speed,
                         float factor) {
-// TODO (antrim) : restore
+// TODO(antrim) : restore
 //  base::TimeDelta duration = SessionStateAnimator::GetDuration(speed);
 //  base::TimeDelta partial_duration =
 //      base::TimeDelta::FromInternalValue(duration.ToInternalValue() * factor);
 //  animator_helper_->Advance(partial_duration);
   }
 
   void ExpectPreLockAnimationStarted() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore 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 ExpectPreLockAnimationCancel() {
     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 ExpectPreLockAnimationFinished() {
-    //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore 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 ExpectPostLockAnimationStarted() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->ContainersAreAnimated(
             SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
             SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN));
   }
 
   void ExpectPastLockAnimationFinished() {
-    //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->ContainersAreAnimated(
             SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
             SessionStateAnimator::ANIMATION_RAISE_TO_SCREEN));
   }
 
   void ExpectUnlockBeforeUIDestroyedAnimationStarted() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->ContainersAreAnimated(
             SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
             SessionStateAnimator::ANIMATION_LIFT));
   }
 
   void ExpectUnlockBeforeUIDestroyedAnimationFinished() {
-    //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->ContainersAreAnimated(
             SessionStateAnimator::LOCK_SCREEN_CONTAINERS,
             SessionStateAnimator::ANIMATION_LIFT));
   }
 
   void ExpectUnlockAfterUIDestroyedAnimationStarted() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore 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 ExpectUnlockAfterUIDestroyedAnimationFinished() {
-    //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore 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() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->RootWindowIsAnimated(
             SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
   }
 
   void ExpectShutdownAnimationFinished()  {
-    //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->RootWindowIsAnimated(
             SessionStateAnimator::ANIMATION_GRAYSCALE_BRIGHTNESS));
   }
 
   void ExpectShutdownAnimationCancel() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->RootWindowIsAnimated(
             SessionStateAnimator::ANIMATION_UNDO_GRAYSCALE_BRIGHTNESS));
   }
 
   void ExpectBackgroundIsShowing() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->ContainersAreAnimated(
             SessionStateAnimator::DESKTOP_BACKGROUND,
             SessionStateAnimator::ANIMATION_FADE_IN));
   }
 
   void ExpectBackgroundIsHiding() {
-    //TODO (antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_TRUE(animator_helper_->IsAnimating());
     EXPECT_TRUE(
         animator_api_->ContainersAreAnimated(
             SessionStateAnimator::DESKTOP_BACKGROUND,
             SessionStateAnimator::ANIMATION_FADE_OUT));
   }
 
   void ExpectUnlockedState() {
-    //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
     EXPECT_FALSE(session_state_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.0f, layer->opacity());
       EXPECT_EQ(0.0f, layer->layer_brightness());
       EXPECT_EQ(0.0f, layer->layer_saturation());
       EXPECT_EQ(gfx::Transform(), layer->transform());
     }
   }
 
   void ExpectLockedState() {
-    //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+    // TODO(antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
     EXPECT_TRUE(session_state_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.0f, layer->opacity());
       EXPECT_EQ(0.0f, layer->layer_brightness());
       EXPECT_EQ(0.0f, layer->layer_saturation());
       EXPECT_EQ(gfx::Transform(), layer->transform());
     }
   }
 
   void PressPowerButton() {
     controller_->OnPowerButtonEvent(true, base::TimeTicks::Now());
-    //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
+    // TODO(antrim) : restore animator_helper_->Advance(base::TimeDelta());
   }
 
   void ReleasePowerButton() {
     controller_->OnPowerButtonEvent(false, base::TimeTicks::Now());
-    //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
+    // TODO(antrim) : restore animator_helper_->Advance(base::TimeDelta());
   }
 
   void PressLockButton() {
     controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
   }
 
   void ReleaseLockButton() {
     controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
   }
 
+  void PressVolumeDown() {
+    GetEventGenerator().PressKey(ui::VKEY_VOLUME_DOWN, ui::EF_NONE);
+  }
+
+  void ReleaseVolumeDown() {
+    GetEventGenerator().ReleaseKey(ui::VKEY_VOLUME_DOWN, ui::EF_NONE);
+  }
+
   void SystemLocks() {
     lock_state_controller_->OnLockStateChanged(true);
     session_state_delegate_->LockScreen();
-    //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
+    // TODO(antrim) : restore animator_helper_->Advance(base::TimeDelta());
   }
 
   void SuccessfulAuthentication(bool* call_flag) {
     base::Closure closure = base::Bind(&CheckCalledCallback, call_flag);
     lock_state_controller_->OnLockScreenHide(closure);
-    //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
+    // TODO(antrim) : restore animator_helper_->Advance(base::TimeDelta());
   }
 
   void SystemUnlocks() {
     lock_state_controller_->OnLockStateChanged(false);
     session_state_delegate_->UnlockScreen();
-    //TODO (antrim) : restore animator_helper_->Advance(base::TimeDelta());
+    // TODO(antrim) : restore animator_helper_->Advance(base::TimeDelta());
+  }
+
+  void EnableMaximizeMode(bool enable) {
+    Shell::GetInstance()->maximize_mode_controller()->
+        EnableMaximizeModeWindowManager(enable);
   }
 
   void Initialize(bool legacy_button, user::LoginStatus status) {
     controller_->set_has_legacy_power_button_for_test(legacy_button);
     lock_state_controller_->OnLoginStateChanged(status);
     SetUserLoggedIn(status != user::LOGGED_IN_NONE);
     if (status == user::LOGGED_IN_GUEST)
       SetCanLockScreen(false);
     lock_state_controller_->OnLockStateChanged(false);
   }
@@ skipping 48 matching lines @@
   EXPECT_FALSE(test_api_->is_lock_cancellable());
 
   Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
 
   ExpectPreLockAnimationFinished();
   EXPECT_EQ(1, delegate_->num_lock_requests());
 
   // Notify that we locked successfully.
   lock_state_controller_->OnStartingLock();
   // We had that animation already.
-  //TODO (antrim) : restore
+  // TODO(antrim) : restore
   //  EXPECT_FALSE(animator_helper_->IsAnimating());
 
   SystemLocks();
 
   ExpectPostLockAnimationStarted();
   Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   ExpectPastLockAnimationFinished();
 
   // We shouldn't progress towards the shutdown state, however.
   EXPECT_FALSE(test_api_->lock_to_shutdown_timer_is_running());
@@ skipping 94 matching lines @@
   EXPECT_EQ(0, delegate_->num_lock_requests());
 
   Advance(SessionStateAnimator::ANIMATION_SPEED_UNDOABLE);
   ExpectPreLockAnimationFinished();
 
   EXPECT_EQ(1, delegate_->num_lock_requests());
 
   // Notify that we locked successfully.
   lock_state_controller_->OnStartingLock();
   // We had that animation already.
-  //TODO (antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
+  // TODO(antrim) : restore EXPECT_FALSE(animator_helper_->IsAnimating());
 
   SystemLocks();
 
   ExpectPostLockAnimationStarted();
   Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   ExpectPastLockAnimationFinished();
 
   // When we release the power button, the lock-to-shutdown timer should be
   // stopped.
   ExpectLockedState();
@@ skipping 536 matching lines @@
   ExpectBackgroundIsHiding();
   EXPECT_FALSE(IsBackgroundHidden());
 
   Advance(SessionStateAnimator::ANIMATION_SPEED_MOVE_WINDOWS);
   ExpectUnlockAfterUIDestroyedAnimationFinished();
   EXPECT_TRUE(IsBackgroundHidden());
 
   ExpectUnlockedState();
 }
 
+// Tests that a screenshot can be taken by holding volume down and
+// pressing power.
+TEST_F(LockStateControllerTest, Screenshot) {
+  Shell::GetInstance()->lock_state_controller()->SetDelegate(
+      new test::TestLockStateControllerDelegate);
+  test::TestScreenshotDelegate* delegate = GetScreenshotDelegate();
+  delegate->set_can_take_screenshot(true);
+
+  // Pressing power alone does not take a screenshot.
+  PressPowerButton();
+  ReleasePowerButton();
+  EXPECT_EQ(0, delegate->handle_take_screenshot_count());
+
+  // Press & release volume then pressing power does not take a screenshot.
+  ASSERT_EQ(0, delegate->handle_take_screenshot_count());
+  PressVolumeDown();
+  ReleaseVolumeDown();
+  PressPowerButton();
+  ReleasePowerButton();
+  EXPECT_EQ(0, delegate->handle_take_screenshot_count());
+
+  // Pressing power and then volume does not take a screenshot.
+  ASSERT_EQ(0, delegate->handle_take_screenshot_count());
+  PressPowerButton();
+  ReleasePowerButton();
+  PressVolumeDown();
+  ReleaseVolumeDown();
+  EXPECT_EQ(0, delegate->handle_take_screenshot_count());
+
+  // Holding volume down and pressing power takes a screenshot.
+  ASSERT_EQ(0, delegate->handle_take_screenshot_count());
+  PressVolumeDown();
+  PressPowerButton();
+  ReleasePowerButton();
+  ReleaseVolumeDown();
+  EXPECT_EQ(1, delegate->handle_take_screenshot_count());
+}
+
+// Tests that a lock action is cancellable when quick lock is turned on and
+// maximize mode is not active.
+TEST_F(LockStateControllerTest, QuickLockWhileNotInMaximizeMode) {
+  Initialize(false, user::LOGGED_IN_USER);
+  controller_->set_enable_quick_lock_for_test(true);
+
+  PressPowerButton();
+
+  EXPECT_TRUE(test_api_->is_animating_lock());
+  EXPECT_TRUE(lock_state_controller_->CanCancelLockAnimation());
+
+  ReleasePowerButton();
+}
+
+// Tests that a lock action is not cancellable when quick lock is turned on and
+// maximize mode is active.
+TEST_F(LockStateControllerTest, QuickLockWhileInMaximizeMode) {
+  Initialize(false, user::LOGGED_IN_USER);
+  controller_->set_enable_quick_lock_for_test(true);
+  EnableMaximizeMode(true);
+
+  PressPowerButton();
+
+  EXPECT_TRUE(test_api_->is_animating_lock());
+  EXPECT_FALSE(lock_state_controller_->CanCancelLockAnimation());
+
+  ReleasePowerButton();
+}
+
 }  // namespace test
 }  // namespace ash