chromeos: Implement power button animations for Aura.

chrome/browser/chromeos/dbus/power_manager_client.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "chrome/browser/chromeos/dbus/power_manager_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/format_macros.h"
@@ skipping 56 matching lines @@
     // manager knows the actual brightness level. We don't cache the
     // brightness level in Chrome as it'll make things less reliable.
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         power_manager::kBrightnessChangedSignal,
         base::Bind(&PowerManagerClientImpl::BrightnessChangedReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
-    // Monitor the D-Bus signal for power supply polling signals.
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         power_manager::kPowerSupplyPollSignal,
         base::Bind(&PowerManagerClientImpl::PowerSupplyPollReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
-    // Monitor the D-Bus signal for power state changed signals.
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         power_manager::kPowerStateChangedSignal,
         base::Bind(&PowerManagerClientImpl::PowerStateChangedSignalReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
-    // Monitor the D-Bus signal for screen lock and unlock signals.
+    power_manager_proxy_->ConnectToSignal(
+        power_manager::kPowerManagerInterface,
+        power_manager::kButtonEventSignal,
+        base::Bind(&PowerManagerClientImpl::ButtonEventSignalReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&PowerManagerClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
     power_manager_proxy_->ConnectToSignal(
         chromium::kChromiumInterface,
         chromium::kLockScreenSignal,
         base::Bind(&PowerManagerClientImpl::ScreenLockSignalReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
+
     power_manager_proxy_->ConnectToSignal(
         chromium::kChromiumInterface,
         chromium::kUnlockScreenSignal,
         base::Bind(&PowerManagerClientImpl::ScreenUnlockSignalReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
     power_manager_proxy_->ConnectToSignal(
         chromium::kChromiumInterface,
         chromium::kUnlockScreenFailedSignal,
@@ skipping 114 matching lines @@
   // Make a method call to power manager with no arguments and no response.
   void SimpleMethodCallToPowerManager(const std::string& method_name) {
     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
                                  method_name);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  // Called when a brightness change signal is received.
   void BrightnessChangedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     int32 brightness_level = 0;
     bool user_initiated = 0;
     if (!(reader.PopInt32(&brightness_level) &&
           reader.PopBool(&user_initiated))) {
       LOG(ERROR) << "Brightness changed signal had incorrect parameters: "
                  << signal->ToString();
       return;
     }
     VLOG(1) << "Brightness changed to " << brightness_level
             << ": user initiated " << user_initiated;
     FOR_EACH_OBSERVER(Observer, observers_,
                       BrightnessChanged(brightness_level, user_initiated));
   }
 
-  // Called when a response for DecreaseScreenBrightness() is received.
   void OnDecreaseScreenBrightness(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to decrease screen brightness";
       return;
     }
     VLOG(1) << "screen brightness increased: " << response->ToString();
   }
 
-  // Called when a response for IncreaseScreenBrightness() is received.
   void OnIncreaseScreenBrightness(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Failed to increase screen brightness";
       return;
     }
     VLOG(1) << "screen brightness increased: " << response->ToString();
   }
 
-  // Called when a power state changed signal is received.
   void PowerStateChangedSignalReceived(dbus::Signal* signal) {
     VLOG(1) << "Received power state changed signal.";
     dbus::MessageReader reader(signal);
     std::string power_state_string;
     if (!reader.PopString(&power_state_string)) {
       LOG(ERROR) << "Error reading signal args: " << signal->ToString();
       return;
     }
     if (power_state_string != "on")
       return;
-    // Notify all observers of resume event.
     FOR_EACH_OBSERVER(Observer, observers_, SystemResumed());
   }
 
-  // Called when a power supply polling signal is received.
+  void ButtonEventSignalReceived(dbus::Signal* signal) {
+    dbus::MessageReader reader(signal);
+    std::string button_name;
+    bool down = false;
+    int64 timestamp_internal = 0;
+    if (!reader.PopString(&button_name) ||
+        !reader.PopBool(&down) ||
+        !reader.PopInt64(&timestamp_internal)) {
+      LOG(ERROR) << "Button signal had incorrect parameters: "
+                 << signal->ToString();
+      return;
+    }
+    base::TimeTicks timestamp =
+        base::TimeTicks::FromInternalValue(timestamp_internal);
+
+    if (button_name == power_manager::kPowerButtonName) {
+      FOR_EACH_OBSERVER(
+          Observer, observers_, PowerButtonStateChanged(down, timestamp));
+    } else if (button_name == power_manager::kLockButtonName) {
+      FOR_EACH_OBSERVER(
+          Observer, observers_, LockButtonStateChanged(down, timestamp));
+    }
+  }
+
   void PowerSupplyPollReceived(dbus::Signal* unused_signal) {
     VLOG(1) << "Received power supply poll signal.";
     RequestStatusUpdate();
   }
 
-  // Called when GetAllPropertiesMethod call is complete.
   void OnGetAllPropertiesMethod(dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Error calling " << power_manager::kGetAllPropertiesMethod;
       return;
     }
     dbus::MessageReader reader(response);
     PowerSupplyStatus status;
     double unused_battery_voltage = 0.0;
     double unused_battery_energy = 0.0;
     double unused_battery_energy_rate = 0.0;
@@ skipping 96 matching lines @@
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(1000),
           this,
           &PowerManagerClientStubImpl::Update);
     } else {
       timer_.Stop();
     }
   }
 
   virtual void RequestRestart() OVERRIDE {}
-
   virtual void RequestShutdown() OVERRIDE {}
 
   virtual void CalculateIdleTime(const CalculateIdleTimeCallback& callback)
       OVERRIDE {
     callback.Run(0);
   }
 
   virtual void NotifyScreenLockRequested() OVERRIDE {}
-
   virtual void NotifyScreenLockCompleted() OVERRIDE {}
-
   virtual void NotifyScreenUnlockRequested() OVERRIDE {}
-
   virtual void NotifyScreenUnlockCompleted() OVERRIDE {}
 
  private:
   void Update() {
     // We pause at 0 and 100% so that it's easier to check those conditions.
     if (pause_count_ > 1) {
       pause_count_--;
       return;
     }
 
@@ skipping 40 matching lines @@
 
 PowerManagerClient* PowerManagerClient::Create(dbus::Bus* bus) {
   if (system::runtime_environment::IsRunningOnChromeOS()) {
     return new PowerManagerClientImpl(bus);
   } else {
     return new PowerManagerClientStubImpl();
   }
 }
 
 }  // namespace chromeos