chromeos: Handle lock button for Aura.

This makes us handle lock button messages from the Chrome OS
power manager in a similar manner to power button messages.

BUG=98328
TEST=added; also did manual testing after updating powerm to treat F1 as the lock button instead of F13

Review URL: http://codereview.chromium.org/9108015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@116573 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 145 insertions, 16 deletions

diff --git a/ash/wm/power_button_controller.cc b/ash/wm/power_button_controller.cc
index 330ef6d..b0e34c8 100644
--- a/ash/wm/power_button_controller.cc
+++ b/ash/wm/power_button_controller.cc
@@ -376,17 +376,10 @@ void PowerButtonController::OnPowerButtonEvent(
     if (lock_fail_timer_.IsRunning())
       return;
 
-    if (logged_in_as_non_guest_ && !locked_) {
-      ShowBackgroundLayer();
-      StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
-                     ANIMATION_SLOW_CLOSE);
-      lock_timer_.Stop();
-      lock_timer_.Start(FROM_HERE,
-                        base::TimeDelta::FromMilliseconds(kSlowCloseAnimMs),
-                        this, &PowerButtonController::OnLockTimeout);
-    } else {
+    if (logged_in_as_non_guest_ && !locked_)
+      StartLockTimer();
+    else
       StartShutdownTimer();
-    }
   } else {  // Button is up.
     if (lock_timer_.IsRunning() || shutdown_timer_.IsRunning())
       StartAnimation(
@@ -413,10 +406,30 @@ void PowerButtonController::OnLockButtonEvent(
     bool down, const base::TimeTicks& timestamp) {
   lock_button_down_ = down;
 
-  if (shutting_down_)
+  if (shutting_down_ || !logged_in_as_non_guest_)
+    return;
+
+  // Bail if we're already locked or are in the process of locking.  Also give
+  // the power button precedence over the lock button (we don't expect both
+  // buttons to be present, so this is just making sure that we don't do
+  // something completely stupid if that assumption changes later).
+  if (locked_ || lock_fail_timer_.IsRunning() || power_button_down_)
     return;
 
-  NOTIMPLEMENTED();
+  if (down) {
+    StartLockTimer();
+  } else {
+    if (lock_timer_.IsRunning()) {
+      StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
+                     ANIMATION_UNDO_SLOW_CLOSE);
+      hide_background_layer_timer_.Stop();
+      hide_background_layer_timer_.Start(
+          FROM_HERE,
+          base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
+          this, &PowerButtonController::HideBackgroundLayer);
+      lock_timer_.Stop();
+    }
+  }
 }
 
 void PowerButtonController::OnRootWindowResized(const gfx::Size& new_size) {
@@ -461,6 +474,16 @@ void PowerButtonController::OnRealShutdownTimeout() {
   delegate_->RequestShutdown();
 }
 
+void PowerButtonController::StartLockTimer() {
+  ShowBackgroundLayer();
+  StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
+                 ANIMATION_SLOW_CLOSE);
+  lock_timer_.Stop();
+  lock_timer_.Start(FROM_HERE,
+                    base::TimeDelta::FromMilliseconds(kSlowCloseAnimMs),
+                    this, &PowerButtonController::OnLockTimeout);
+}
+
 void PowerButtonController::StartShutdownTimer() {
   ShowBackgroundLayer();
   StartAnimation(ALL_CONTAINERS, ANIMATION_SLOW_CLOSE);
diff --git a/ash/wm/power_button_controller.h b/ash/wm/power_button_controller.h
index 98ba1f8..8cb8704 100644
--- a/ash/wm/power_button_controller.h
+++ b/ash/wm/power_button_controller.h
@@ -85,17 +85,29 @@ class ASH_EXPORT PowerButtonController : public aura::RootWindowObserver {
       return controller_->hide_background_layer_timer_.IsRunning();
     }
 
-    void trigger_lock_timeout() { controller_->OnLockTimeout(); }
-    void trigger_lock_fail_timeout() { controller_->OnLockFailTimeout(); }
+    void trigger_lock_timeout() {
+      controller_->OnLockTimeout();
+      controller_->lock_timer_.Stop();
+    }
+    void trigger_lock_fail_timeout() {
+      controller_->OnLockFailTimeout();
+      controller_->lock_fail_timer_.Stop();
+    }
     void trigger_lock_to_shutdown_timeout() {
       controller_->OnLockToShutdownTimeout();
+      controller_->lock_to_shutdown_timer_.Stop();
+    }
+    void trigger_shutdown_timeout() {
+      controller_->OnShutdownTimeout();
+      controller_->shutdown_timer_.Stop();
     }
-    void trigger_shutdown_timeout() { controller_->OnShutdownTimeout(); }
     void trigger_real_shutdown_timeout() {
       controller_->OnRealShutdownTimeout();
+      controller_->real_shutdown_timer_.Stop();
     }
     void trigger_hide_background_layer_timeout() {
       controller_->HideBackgroundLayer();
+      controller_->hide_background_layer_timer_.Stop();
     }
 
     // Returns true if the given set of containers was last animated with
@@ -154,7 +166,8 @@ class ASH_EXPORT PowerButtonController : public aura::RootWindowObserver {
   // Requests that the machine be shut down.
   void OnRealShutdownTimeout();
 
-  // Puts us into the pre-shutdown state.
+  // Puts us into the pre-lock or pre-shutdown state.
+  void StartLockTimer();
   void StartShutdownTimer();
 
   // Shows or hides |background_layer_|.  The show method creates and
diff --git a/ash/wm/power_button_controller_unittest.cc b/ash/wm/power_button_controller_unittest.cc
index 85ff5aa..78ced33 100644
--- a/ash/wm/power_button_controller_unittest.cc
+++ b/ash/wm/power_button_controller_unittest.cc
@@ -272,5 +272,98 @@ TEST_F(PowerButtonControllerTest, CancelHideBackground) {
   EXPECT_FALSE(test_api_->hide_background_layer_timer_is_running());
 }
 
+// Test the basic operation of the lock button.
+TEST_F(PowerButtonControllerTest, LockButtonBasic) {
+  // The lock button shouldn't do anything if we aren't logged in.
+  controller_->OnLoginStateChange(false /*logged_in*/, false /*is_guest*/);
+  controller_->OnLockStateChange(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.
+  controller_->OnLoginStateChange(true /*logged_in*/, true /*is_guest*/);
+  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.
+  controller_->OnLoginStateChange(true /*logged_in*/, false /*is_guest*/);
+  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
+  EXPECT_TRUE(test_api_->lock_timer_is_running());
+  EXPECT_TRUE(
+      test_api_->ContainerGroupIsAnimated(
+          PowerButtonController::ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
+          PowerButtonController::ANIMATION_SLOW_CLOSE));
+  EXPECT_TRUE(test_api_->BackgroundLayerIsVisible());
+
+  // 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(
+      test_api_->ContainerGroupIsAnimated(
+          PowerButtonController::ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
+          PowerButtonController::ANIMATION_UNDO_SLOW_CLOSE));
+  EXPECT_TRUE(test_api_->BackgroundLayerIsVisible());
+  EXPECT_TRUE(test_api_->hide_background_layer_timer_is_running());
+  test_api_->trigger_hide_background_layer_timeout();
+  EXPECT_FALSE(test_api_->BackgroundLayerIsVisible());
+  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();
+  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());
+
+  // Pressing the button also shouldn't do anything after the screen is locked.
+  controller_->OnStartingLock();
+  controller_->OnLockStateChange(true);
+  controller_->OnLockButtonEvent(true, base::TimeTicks::Now());
+  EXPECT_FALSE(test_api_->lock_timer_is_running());
+  controller_->OnLockButtonEvent(false, base::TimeTicks::Now());
+}
+
+// Test that the power button takes priority over the lock button.
+TEST_F(PowerButtonControllerTest, PowerButtonPreemptsLockButton) {
+  controller_->OnLoginStateChange(true /*logged_in*/, false /*is_guest*/);
+  controller_->OnLockStateChange(false);
+
+  // 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());
+
+  // 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());
+
+  // 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());
+
+  // 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());
+}
+
 }  // namespace test
 }  // namespace ash