Implement restart on Idle for Kiosk Mode.

chrome/browser/chromeos/dbus/power_manager_client.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 "chrome/browser/chromeos/dbus/power_manager_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 104 matching lines @@
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
     power_manager_proxy_->ConnectToSignal(
         chromium::kChromiumInterface,
         chromium::kUnlockScreenFailedSignal,
         base::Bind(&PowerManagerClientImpl::ScreenUnlockFailedSignalReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
+
+    power_manager_proxy_->ConnectToSignal(
+        power_manager::kPowerManagerInterface,
+        power_manager::kIdleNotifySignal,
+        base::Bind(&PowerManagerClientImpl::IdleNotifySignalReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&PowerManagerClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    power_manager_proxy_->ConnectToSignal(
+        power_manager::kPowerManagerInterface,
+        power_manager::kActiveNotifySignal,
+        base::Bind(&PowerManagerClientImpl::IdleNotifySignalReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&PowerManagerClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual ~PowerManagerClientImpl() {
   }
 
   // PowerManagerClient overrides:
 
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
@@ skipping 65 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 RequestIdleNotification(int64 threshold) OVERRIDE {
+    dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
+                                 power_manager::kRequestIdleNotification);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendInt64(threshold);
+
+    power_manager_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
+  }
+
+  virtual void RequestActiveNotification() OVERRIDE {
+    RequestIdleNotification(0);
+  }
+
+
   virtual void NotifyScreenLockRequested() OVERRIDE {
     SimpleMethodCallToPowerManager(power_manager::kRequestLockScreenMethod);
   }
 
   virtual void NotifyScreenLockCompleted() OVERRIDE {
     SimpleMethodCallToPowerManager(power_manager::kScreenIsLockedMethod);
   }
 
   virtual void NotifyScreenUnlockRequested() OVERRIDE {
     SimpleMethodCallToPowerManager(power_manager::kRequestUnlockScreenMethod);
@@ skipping 151 matching lines @@
   }
 
   void ScreenUnlockSignalReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, UnlockScreen());
   }
 
   void ScreenUnlockFailedSignalReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, UnlockScreenFailed());
   }
 
+
+  void IdleNotifySignalReceived(dbus::Signal* signal) {
+    dbus::MessageReader reader(signal);
+    int64 threshold = 0;
+    if (!reader.PopInt64(&threshold)) {
+      LOG(ERROR) << "Idle Notify signal had incorrect parameters: "
+                 << signal->ToString();
+      return;
+    }
+
+    VLOG(1) << "Idle Notify: " << threshold;
+    if (threshold)
+      FOR_EACH_OBSERVER(Observer, observers_, IdleNotify(threshold));
+    else
+      FOR_EACH_OBSERVER(Observer, observers_, ActiveNotify());
+  }
+
+
   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 41 matching lines @@
   }
 
   virtual void RequestRestart() OVERRIDE {}
   virtual void RequestShutdown() OVERRIDE {}
 
   virtual void CalculateIdleTime(const CalculateIdleTimeCallback& callback)
       OVERRIDE {
     callback.Run(0);
   }
 
+  virtual void RequestIdleNotification(int64 threshold) OVERRIDE {}
+  virtual void RequestActiveNotification() OVERRIDE {}
+
   virtual void NotifyScreenLockRequested() OVERRIDE {
     ScreenLocker::Show();
   }
-
   virtual void NotifyScreenLockCompleted() OVERRIDE {}
-
   virtual void NotifyScreenUnlockRequested() OVERRIDE {
     ScreenLocker::Hide();
   }
 
   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) {
@@ skipping 44 matching lines @@
 
 PowerManagerClient* PowerManagerClient::Create(dbus::Bus* bus) {
   if (system::runtime_environment::IsRunningOnChromeOS()) {
     return new PowerManagerClientImpl(bus);
   } else {
     return new PowerManagerClientStubImpl();
   }
 }
 
 }  // namespace chromeos