Add dark resume methods to PowerManagerClient

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 "chromeos/dbus/power_manager_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 30 matching lines @@
 const char kSuspendDelayDescription[] = "chrome";
 
 // The PowerManagerClient implementation used in production.
 class PowerManagerClientImpl : public PowerManagerClient {
  public:
   PowerManagerClientImpl()
       : origin_thread_id_(base::PlatformThread::CurrentId()),
         power_manager_proxy_(NULL),
         suspend_delay_id_(-1),
         has_suspend_delay_id_(false),
+        dark_suspend_delay_id_(-1),
+        has_dark_suspend_delay_id_(false),
         pending_suspend_id_(-1),
         suspend_is_pending_(false),
+        suspending_from_dark_resume_(false),
         num_pending_suspend_readiness_callbacks_(0),
         last_is_projecting_(false),
         weak_ptr_factory_(this) {}
 
   virtual ~PowerManagerClientImpl() {
     // Here we should unregister suspend notifications from powerd,
     // however:
     // - The lifetime of the PowerManagerClientImpl can extend past that of
     //   the objectproxy,
     // - power_manager can already detect that the client is gone and
@@ skipping 144 matching lines @@
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
     last_is_projecting_ = is_projecting;
   }
 
   virtual base::Closure GetSuspendReadinessCallback() OVERRIDE {
     DCHECK(OnOriginThread());
     DCHECK(suspend_is_pending_);
     num_pending_suspend_readiness_callbacks_++;
     return base::Bind(&PowerManagerClientImpl::HandleObserverSuspendReadiness,
-                      weak_ptr_factory_.GetWeakPtr(), pending_suspend_id_);
+                      weak_ptr_factory_.GetWeakPtr(), pending_suspend_id_,
+                      suspending_from_dark_resume_);
   }
 
   virtual int GetNumPendingSuspendReadinessCallbacks() OVERRIDE {
     return num_pending_suspend_readiness_callbacks_;
   }
 
  protected:
   virtual void Init(dbus::Bus* bus) OVERRIDE {
     power_manager_proxy_ = bus->GetObjectProxy(
         power_manager::kPowerManagerServiceName,
@@ skipping 35 matching lines @@
         power_manager::kInputEventSignal,
         base::Bind(&PowerManagerClientImpl::InputEventReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         power_manager::kSuspendImminentSignal,
         base::Bind(
-            &PowerManagerClientImpl::SuspendImminentReceived,
-            weak_ptr_factory_.GetWeakPtr()),
+            &PowerManagerClientImpl::HandleSuspendImminent,
+            weak_ptr_factory_.GetWeakPtr(), false),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         power_manager::kSuspendDoneSignal,
         base::Bind(&PowerManagerClientImpl::SuspendDoneReceived,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
+        power_manager::kDarkSuspendImminentSignal,
+        base::Bind(
+            &PowerManagerClientImpl::HandleSuspendImminent,
+            weak_ptr_factory_.GetWeakPtr(), true),
+        base::Bind(&PowerManagerClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    power_manager_proxy_->ConnectToSignal(
+        power_manager::kPowerManagerInterface,
         power_manager::kIdleActionImminentSignal,
         base::Bind(
             &PowerManagerClientImpl::IdleActionImminentReceived,
             weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         power_manager::kIdleActionDeferredSignal,
         base::Bind(
             &PowerManagerClientImpl::IdleActionDeferredReceived,
             weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
-    RegisterSuspendDelay();
+    RegisterSuspendDelays();
   }
 
  private:
   // Returns true if the current thread is the origin thread.
   bool OnOriginThread() {
     return base::PlatformThread::CurrentId() == origin_thread_id_;
   }
 
   // Called when a dbus signal is initially connected.
   void SignalConnected(const std::string& interface_name,
@@ skipping 14 matching lines @@
   }
 
   void NameOwnerChangedReceived(const std::string& old_owner,
                                 const std::string& new_owner) {
     VLOG(1) << "Power manager restarted (old owner was "
             << (old_owner.empty() ? "[none]" : old_owner.c_str())
             << ", new owner is "
             << (new_owner.empty() ? "[none]" : new_owner.c_str()) << ")";
     if (!new_owner.empty()) {
       VLOG(1) << "Sending initial state to power manager";
-      RegisterSuspendDelay();
+      RegisterSuspendDelays();
       SetIsProjecting(last_is_projecting_);
       FOR_EACH_OBSERVER(Observer, observers_, PowerManagerRestarted());
     }
   }
 
   void BrightnessChangedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    int32 brightness_level = 0;
+    int32_t 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_,
@@ skipping 59 matching lines @@
       return;
     }
     dbus::MessageReader reader(response);
     double percent = 0.0;
     if (!reader.PopDouble(&percent))
       LOG(ERROR) << "Error reading response from powerd: "
                  << response->ToString();
     callback.Run(percent);
   }
 
-  void OnRegisterSuspendDelayReply(dbus::Response* response) {
+  void HandleRegisterSuspendDelayReply(bool dark_suspend,
+                                       dbus::Response* response) {
     if (!response) {
-      LOG(ERROR) << "Error calling "
-                 << power_manager::kRegisterSuspendDelayMethod;
+      LOG(ERROR) << "Error calling " << response->GetMember();
       return;
     }
 
     dbus::MessageReader reader(response);
     power_manager::RegisterSuspendDelayReply protobuf;
     if (!reader.PopArrayOfBytesAsProto(&protobuf)) {
-      LOG(ERROR) << "Unable to parse reply from "
-                 << power_manager::kRegisterSuspendDelayMethod;
+      LOG(ERROR) << "Unable to parse reply from " << response->GetMember();
       return;
     }
 
-    suspend_delay_id_ = protobuf.delay_id();
-    has_suspend_delay_id_ = true;
-    VLOG(1) << "Registered suspend delay " << suspend_delay_id_;
+    if (dark_suspend) {
+      dark_suspend_delay_id_ = protobuf.delay_id();
+      has_dark_suspend_delay_id_ = true;
+      VLOG(1) << "Registered dark suspend delay " << dark_suspend_delay_id_;
+    } else {
+      suspend_delay_id_ = protobuf.delay_id();
+      has_suspend_delay_id_ = true;
+      VLOG(1) << "Registered suspend delay " << suspend_delay_id_;
+    }
   }
 
-  void SuspendImminentReceived(dbus::Signal* signal) {
-    if (!has_suspend_delay_id_) {
-      LOG(ERROR) << "Received unrequested "
-                 << power_manager::kSuspendImminentSignal << " signal";
+  void HandleSuspendImminent(bool in_dark_resume, dbus::Signal* signal) {
+    std::string signal_name = signal->GetMember();
+    if ((in_dark_resume && !has_dark_suspend_delay_id_) ||
+        (!in_dark_resume && !has_suspend_delay_id_)) {
+      LOG(ERROR) << "Received unrequested " << signal_name << " signal";
       return;
     }
 
     dbus::MessageReader reader(signal);
     power_manager::SuspendImminent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
-      LOG(ERROR) << "Unable to decode protocol buffer from "
-                 << power_manager::kSuspendImminentSignal << " signal";
+      LOG(ERROR) << "Unable to decode protocol buffer from " << signal_name
+                 << " signal";
       return;
     }
 
-    VLOG(1) << "Got " << power_manager::kSuspendImminentSignal << " signal "
-            << "announcing suspend attempt " << proto.suspend_id();
-    if (suspend_is_pending_) {
-      LOG(WARNING) << "Got " << power_manager::kSuspendImminentSignal
-                   << " signal about pending suspend attempt "
-                   << proto.suspend_id() << " while still waiting "
-                   << "on attempt " << pending_suspend_id_;
+    VLOG(1) << "Got " << signal_name << " signal announcing suspend attempt "
+            << proto.suspend_id();
+
+    // If a previous suspend is pending from the same state we are currently in
+    // (fully powered on or in dark resume), then something's gone a little
+    // wonky.
+    if (suspend_is_pending_ &&
+        suspending_from_dark_resume_ == in_dark_resume) {
+      LOG(WARNING) << "Got " << signal_name << " signal about pending suspend "
+                   << "attempt " << proto.suspend_id() << " while still "
+                   << "waiting on attempt " << pending_suspend_id_;
     }
 
     pending_suspend_id_ = proto.suspend_id();
     suspend_is_pending_ = true;
+    suspending_from_dark_resume_ = in_dark_resume;
     num_pending_suspend_readiness_callbacks_ = 0;
-    FOR_EACH_OBSERVER(Observer, observers_, SuspendImminent());
+    if (suspending_from_dark_resume_)
+      FOR_EACH_OBSERVER(Observer, observers_, DarkSuspendImminent());
+    else
+      FOR_EACH_OBSERVER(Observer, observers_, SuspendImminent());
     MaybeReportSuspendReadiness();
   }
 
   void SuspendDoneReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::SuspendDone proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
       LOG(ERROR) << "Unable to decode protocol buffer from "
                  << power_manager::kSuspendDoneSignal << " signal";
       return;
@@ skipping 64 matching lines @@
       case power_manager::InputEvent_Type_LID_CLOSED: {
         bool open =
             (proto.type() == power_manager::InputEvent_Type_LID_OPEN);
         FOR_EACH_OBSERVER(PowerManagerClient::Observer, observers_,
                           LidEventReceived(open, timestamp));
         break;
       }
     }
   }
 
-  // Registers a suspend delay with the power manager.  This is usually
-  // only called at startup, but if the power manager restarts, we need to
-  // create a new delay.
-  void RegisterSuspendDelay() {
+  void RegisterSuspendDelayImpl(
+      const std::string& method_name,
+      const power_manager::RegisterSuspendDelayRequest& protobuf_request,
+      dbus::ObjectProxy::ResponseCallback callback) {
+    dbus::MethodCall method_call(
+        power_manager::kPowerManagerInterface, method_name);
+    dbus::MessageWriter writer(&method_call);
+
+    if (!writer.AppendProtoAsArrayOfBytes(protobuf_request)) {
+      LOG(ERROR) << "Error constructing message for " << method_name;
+      return;
+    }
+
+    power_manager_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, callback);
+  }
+
+  // Registers suspend delays with the power manager.  This is usually only
+  // called at startup, but if the power manager restarts, we need to create new
+  // delays.
+  void RegisterSuspendDelays() {

[pprabhu, 2014/08/26 18:13:18]

Fly by late comment: Shouldn't this also reset |suspend_is_pending_| and
|suspending_from_dark_resume_|?

Consider the case when power_manager dies after we receive a
(Dark)SuspendImminent signal, we will reset the state of PowerManagerClient, but
will end up with incorrect initial values for these two variables.

[Daniel Erat, 2014/08/26 18:16:33]

probably wouldn't hurt to do that here, but i think that powerd has an ugly hack
to send a fake SuspendDone event at startup in this case

[Chirantan Ekbote, 2014/08/26 19:10:54]

But it looks like |suspend_is_pending_| is not cleared in SuspendDoneReceived. 
It only gets cleared in MaybeReportSuspendReadiness.  So we could have a problem
if the following sequence occurs:

- Chrome receives a {Dark}SuspendImminent
- One of the observers takes a callback
- powerd goes away
- powerd restarts
- The observer runs the callback

In this case, chrome would report suspend readiness with an id of -1 or whatever
id powerd assigned to it (depending on whether or not chrome received the
RegisterSuspendDelay reply before running the observer callback).  I think
powerd can deal with either case but we should probably prevent chrome from
sending the message in the first place.  Plus, if for whatever reason powerd
doesn't restart, then chrome would still report suspend readiness only to
receive a ServiceUnknown error in return.

Maybe this should be cleared in NameOwnerChangedReceived?  I'll upload a CL to
do this.

     // Throw out any old delay that was registered.
     suspend_delay_id_ = -1;
     has_suspend_delay_id_ = false;
-
-    dbus::MethodCall method_call(
-        power_manager::kPowerManagerInterface,
-        power_manager::kRegisterSuspendDelayMethod);
-    dbus::MessageWriter writer(&method_call);
+    dark_suspend_delay_id_ = -1;
+    has_dark_suspend_delay_id_ = false;
 
     power_manager::RegisterSuspendDelayRequest protobuf_request;
     base::TimeDelta timeout =
         base::TimeDelta::FromMilliseconds(kSuspendDelayTimeoutMs);
     protobuf_request.set_timeout(timeout.ToInternalValue());
     protobuf_request.set_description(kSuspendDelayDescription);
 
-    if (!writer.AppendProtoAsArrayOfBytes(protobuf_request)) {
-      LOG(ERROR) << "Error constructing message for "
-                 << power_manager::kRegisterSuspendDelayMethod;
-      return;
-    }
-    power_manager_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+    RegisterSuspendDelayImpl(
+        power_manager::kRegisterSuspendDelayMethod,
+        protobuf_request,
         base::Bind(
-            &PowerManagerClientImpl::OnRegisterSuspendDelayReply,
-            weak_ptr_factory_.GetWeakPtr()));
+            &PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
+            weak_ptr_factory_.GetWeakPtr(), false));
+    RegisterSuspendDelayImpl(
+        power_manager::kRegisterDarkSuspendDelayMethod,
+        protobuf_request,
+        base::Bind(
+            &PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
+            weak_ptr_factory_.GetWeakPtr(), true));
   }
 
   // Records the fact that an observer has finished doing asynchronous work
   // that was blocking a pending suspend attempt and possibly reports
   // suspend readiness to powerd.  Called by callbacks returned via
   // GetSuspendReadinessCallback().
-  void HandleObserverSuspendReadiness(int32 suspend_id) {
+  void HandleObserverSuspendReadiness(int32_t suspend_id, bool in_dark_resume) {
     DCHECK(OnOriginThread());
-    if (!suspend_is_pending_ || suspend_id != pending_suspend_id_)
+    if (!suspend_is_pending_ || suspend_id != pending_suspend_id_ ||
+        in_dark_resume != suspending_from_dark_resume_)
       return;
 
     num_pending_suspend_readiness_callbacks_--;
     MaybeReportSuspendReadiness();
   }
 
   // Reports suspend readiness to powerd if no observers are still holding
   // suspend readiness callbacks.
   void MaybeReportSuspendReadiness() {
     if (!suspend_is_pending_ || num_pending_suspend_readiness_callbacks_ > 0)
       return;
 
+    std::string method_name;
+    int32_t delay_id = -1;
+    if (suspending_from_dark_resume_) {
+      method_name = power_manager::kHandleDarkSuspendReadinessMethod;
+      delay_id = dark_suspend_delay_id_;
+    } else {
+      method_name = power_manager::kHandleSuspendReadinessMethod;
+      delay_id = suspend_delay_id_;
+    }
+
     dbus::MethodCall method_call(
-        power_manager::kPowerManagerInterface,
-        power_manager::kHandleSuspendReadinessMethod);
+        power_manager::kPowerManagerInterface, method_name);
     dbus::MessageWriter writer(&method_call);
 
-    VLOG(1) << "Announcing readiness of suspend delay " << suspend_delay_id_
+    VLOG(1) << "Announcing readiness of suspend delay " << delay_id
             << " for suspend attempt " << pending_suspend_id_;
     power_manager::SuspendReadinessInfo protobuf_request;
-    protobuf_request.set_delay_id(suspend_delay_id_);
+    protobuf_request.set_delay_id(delay_id);
     protobuf_request.set_suspend_id(pending_suspend_id_);
 
     pending_suspend_id_ = -1;
     suspend_is_pending_ = false;
 
     if (!writer.AppendProtoAsArrayOfBytes(protobuf_request)) {
-      LOG(ERROR) << "Error constructing message for "
-                 << power_manager::kHandleSuspendReadinessMethod;
+      LOG(ERROR) << "Error constructing message for " << method_name;
       return;
     }
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   // Origin thread (i.e. the UI thread in production).
   base::PlatformThreadId origin_thread_id_;
 
   dbus::ObjectProxy* power_manager_proxy_;
   ObserverList<Observer> observers_;
 
   // The delay_id_ obtained from the RegisterSuspendDelay request.
-  int32 suspend_delay_id_;
+  int32_t suspend_delay_id_;
   bool has_suspend_delay_id_;
 
+  // The delay_id_ obtained from the RegisterDarkSuspendDelay request.
+  int32_t dark_suspend_delay_id_;
+  bool has_dark_suspend_delay_id_;
+
   // powerd-supplied ID corresponding to an imminent suspend attempt that is
   // currently being delayed.
-  int32 pending_suspend_id_;
+  int32_t pending_suspend_id_;
   bool suspend_is_pending_;
 
+  // Set to true when the suspend currently being delayed was triggered during a
+  // dark resume.  Since |pending_suspend_id_| and |suspend_is_pending_| are
+  // both shared by normal and dark suspends, |suspending_from_dark_resume_|
+  // helps distinguish the context within which these variables are being used.
+  bool suspending_from_dark_resume_;
+
   // Number of callbacks that have been returned by
   // GetSuspendReadinessCallback() during the currently-pending suspend
   // attempt but have not yet been called.
   int num_pending_suspend_readiness_callbacks_;
 
   // Last state passed to SetIsProjecting().
   bool last_is_projecting_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
@@ skipping 229 matching lines @@
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new PowerManagerClientStubImpl();
 }
 
 }  // namespace chromeos