chromeos/aura: Handle power button on unofficial hardware.

ash/wm/power_button_controller.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/shell.h"
 #include "ash/shell_window_ids.h"
 #include "base/logging.h"
 #include "base/time.h"
@@ skipping 322 matching lines @@
 void PowerButtonController::OnLockStateChange(bool locked) {
   if (shutting_down_ || locked_ == locked)
     return;
 
   locked_ = locked;
   if (locked) {
     StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_FADE_IN);
     lock_timer_.Stop();
     lock_fail_timer_.Stop();
 
+#if !defined(CHROMEOS_LEGACY_POWER_BUTTON)
     if (power_button_down_) {
       lock_to_shutdown_timer_.Stop();
       lock_to_shutdown_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kLockToShutdownTimeoutMs),
           this, &PowerButtonController::OnLockToShutdownTimeout);
     }
+#endif
   } else {
     StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                    ANIMATION_RESTORE);
     HideBackgroundLayer();
   }
 }
 
 void PowerButtonController::OnStartingLock() {
   if (shutting_down_ || locked_)
     return;
 
   StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
                  ANIMATION_FAST_CLOSE);
 
   // Hide the screen locker containers so we can make them fade in later.
   StartAnimation(SCREEN_LOCKER_CONTAINERS, ANIMATION_HIDE);
 }
 
 void PowerButtonController::OnPowerButtonEvent(
     bool down, const base::TimeTicks& timestamp) {
   power_button_down_ = down;
 
   if (shutting_down_)
     return;
 
+#if defined(CHROMEOS_LEGACY_POWER_BUTTON)
+  // If power button releases won't get reported correctly because we're not
+  // running on official hardware, just lock the screen or shut down
+  // immediately.
+  if (down) {
+    ShowBackgroundLayer();
+    if (logged_in_as_non_guest_ && !locked_) {
+      StartAnimation(ALL_BUT_SCREEN_LOCKER_AND_RELATED_CONTAINERS,
+                     ANIMATION_SLOW_CLOSE);
+      OnLockTimeout();
+    } else {
+      OnShutdownTimeout();
+    }
+  }
+#else
   if (down) {
     // If we already have a pending request to lock the screen, wait.
     if (lock_fail_timer_.IsRunning())
       return;
 
     if (logged_in_as_non_guest_ && !locked_)
       StartLockTimer();
     else
       StartShutdownTimer();
   } else {  // Button is up.
     if (lock_timer_.IsRunning() || shutdown_timer_.IsRunning())
       StartAnimation(
           locked_ ? SCREEN_LOCKER_AND_RELATED_CONTAINERS : ALL_CONTAINERS,
           ANIMATION_UNDO_SLOW_CLOSE);
 
     // Drop the background layer after the undo animation finishes.
     if (lock_timer_.IsRunning() ||
         (shutdown_timer_.IsRunning() && !logged_in_as_non_guest_)) {
       hide_background_layer_timer_.Stop();
       hide_background_layer_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kUndoSlowCloseAnimMs),
           this, &PowerButtonController::HideBackgroundLayer);
     }
 
     lock_timer_.Stop();
     shutdown_timer_.Stop();
     lock_to_shutdown_timer_.Stop();
   }
+#endif
 }
 
 void PowerButtonController::OnLockButtonEvent(
     bool down, const base::TimeTicks& timestamp) {
   lock_button_down_ = 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
@@ skipping 96 matching lines @@
     root_layer->StackAtBottom(background_layer_.get());
   }
   background_layer_->SetVisible(true);
 }
 
 void PowerButtonController::HideBackgroundLayer() {
   background_layer_.reset();
 }
 
 }  // namespace ash