chromeos: move screen lock handling to power manager client

chrome/browser/chromeos/dbus/power_manager_client.cc

 // Copyright (c) 2011 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"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/chromeos/system/runtime_environment.h"
+#include "content/public/browser/browser_thread.h"

[satorux1, 2011/11/29 01:29:12]

don't need this.

[Simon Que, 2011/11/29 01:47:32]

Done.

 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 PowerSupplyStatus::PowerSupplyStatus()
     : line_power_on(false),
       battery_is_present(false),
@@ skipping 57 matching lines @@
                    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(
+        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::ScreenLockSignalReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&PowerManagerClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+    power_manager_proxy_->ConnectToSignal(
+        chromium::kChromiumInterface,
+        chromium::kUnlockScreenFailedSignal,
+        base::Bind(&PowerManagerClientImpl::ScreenLockSignalReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&PowerManagerClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual ~PowerManagerClientImpl() {
   }
 
   // PowerManagerClient override.
   virtual void AddObserver(Observer* observer) {
     observers_.AddObserver(observer);
   }
 
@@ skipping 64 matching lines @@
       OVERRIDE {
     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
                                  power_manager::kGetIdleTime);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&PowerManagerClientImpl::OnGetIdleTime,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
+  virtual void NotifyScreenLockRequested() OVERRIDE {
+    SimpleMethodCallToPowerManager(power_manager::kRequestLockScreenMethod);
+  }
+
+  virtual void NotifyScreenLockCompleted() OVERRIDE {
+    SimpleMethodCallToPowerManager(power_manager::kScreenIsLockedMethod);
+  }
+
+  virtual void NotifyScreenUnlockRequested() OVERRIDE {
+    SimpleMethodCallToPowerManager(power_manager::kRequestUnlockScreenMethod);
+  }
+
+  virtual void NotifyScreenUnlockCompleted() OVERRIDE {
+    SimpleMethodCallToPowerManager(power_manager::kScreenIsUnlockedMethod);
+  }
+
  private:
   // Called when a dbus signal is initially connected.
   void SignalConnected(const std::string& interface_name,
                        const std::string& signal_name,
                        bool success) {
     LOG_IF(WARNING, !success) << "Failed to connect to signal "
                               << signal_name << ".";
   }
 
+  // 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;
@@ skipping 83 matching lines @@
       return;
     }
     if (idle_time_ms < 0) {
       LOG(ERROR) << "Power manager failed to calculate idle time.";
       callback.Run(-1);
       return;
     }
     callback.Run(idle_time_ms/1000);
   }
 
+  void ScreenLockSignalReceived(dbus::Signal* signal) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));

[satorux1, 2011/11/29 01:29:12]

Don't need this. We don't do this in other functions. Let's make it consistent.

[Simon Que, 2011/11/29 01:47:32]

Done.

+    std::string signal_name = signal->GetMember();
+    if (signal_name == chromium::kLockScreenSignal) {
+      FOR_EACH_OBSERVER(Observer, observers_, LockScreen());
+    } else if (signal_name == chromium::kUnlockScreenSignal) {
+      FOR_EACH_OBSERVER(Observer, observers_, UnlockScreen());
+    } else if (signal_name == chromium::kUnlockScreenFailedSignal) {
+      FOR_EACH_OBSERVER(Observer, observers_, UnlockScreenFailed());
+    } else {
+      LOG(ERROR) << "Invalid signal name: " << signal_name;
+      NOTREACHED();
+    }

[satorux1, 2011/11/29 01:29:12]

What about defining a function for each signal, rather than processing all
signals in this function. That may be a bit lengthier but would be cleaner.

[Simon Que, 2011/11/29 01:47:32]

Done.

+  }
+
   dbus::ObjectProxy* power_manager_proxy_;
   ObserverList<Observer> observers_;
   base::WeakPtrFactory<PowerManagerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientImpl);
 };
 
 // The PowerManagerClient implementation used on Linux desktop,
 // which does nothing.
 class PowerManagerClientStubImpl : public PowerManagerClient {
@@ skipping 40 matching lines @@
 
   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;
     }
 
     if (battery_percentage_ == 0 || battery_percentage_ == 100) {
       if (pause_count_) {
@@ skipping 38 matching lines @@
 
 PowerManagerClient* PowerManagerClient::Create(dbus::Bus* bus) {
   if (system::runtime_environment::IsRunningOnChromeOS()) {
     return new PowerManagerClientImpl(bus);
   } else {
     return new PowerManagerClientStubImpl();
   }
 }
 
 }  // namespace chromeos