chromeos: Update IdleActionImminent and SuspendDone handling

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 250 matching lines @@
     power_manager_proxy_->ConnectToSignal(
         power_manager::kPowerManagerInterface,
         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::kSuspendStateChangedSignal,
-        base::Bind(&PowerManagerClientImpl::SuspendStateChangedReceived,
-                   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()),
         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::kIdleActionImminentSignal,
         base::Bind(
             &PowerManagerClientImpl::IdleActionImminentReceived,
             weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&PowerManagerClientImpl::SignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
 
     power_manager_proxy_->ConnectToSignal(
@@ skipping 149 matching lines @@
   }
 
   void SuspendImminentReceived(dbus::Signal* signal) {
     if (!has_suspend_delay_id_) {
       LOG(ERROR) << "Received unrequested "
                  << power_manager::kSuspendImminentSignal << " signal";
       return;
     }
 
     dbus::MessageReader reader(signal);
-    power_manager::SuspendImminent protobuf_imminent;
-    if (!reader.PopArrayOfBytesAsProto(&protobuf_imminent)) {
+    power_manager::SuspendImminent proto;
+    if (!reader.PopArrayOfBytesAsProto(&proto)) {
       LOG(ERROR) << "Unable to decode protocol buffer from "
                  << power_manager::kSuspendImminentSignal << " 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 "
-                   << protobuf_imminent.suspend_id() << " while still waiting "
+                   << proto.suspend_id() << " while still waiting "
                    << "on attempt " << pending_suspend_id_;
     }
 
-    pending_suspend_id_ = protobuf_imminent.suspend_id();
+    pending_suspend_id_ = proto.suspend_id();
     suspend_is_pending_ = true;
     num_pending_suspend_readiness_callbacks_ = 0;
     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;
+    }
+
+    const base::TimeDelta duration =
+        base::TimeDelta::FromInternalValue(proto.suspend_duration());
+    VLOG(1) << "Got " << power_manager::kSuspendDoneSignal << " signal:"
+            << " suspend_id=" << proto.suspend_id()
+            << " duration=" << duration.InSeconds() << " sec";
+    FOR_EACH_OBSERVER(
+        PowerManagerClient::Observer, observers_, SuspendDone(duration));
+  }
+
   void IdleActionImminentReceived(dbus::Signal* signal) {
-    FOR_EACH_OBSERVER(Observer, observers_, IdleActionImminent());
+    dbus::MessageReader reader(signal);
+    power_manager::IdleActionImminent proto;
+    if (!reader.PopArrayOfBytesAsProto(&proto)) {
+      LOG(ERROR) << "Unable to decode protocol buffer from "
+                 << power_manager::kIdleActionImminentSignal << " signal";
+      return;
+    }
+    FOR_EACH_OBSERVER(Observer, observers_,
+        IdleActionImminent(base::TimeDelta::FromInternalValue(
+                               proto.time_until_idle_action())));

[bartfab (slow), 2014/04/23 11:49:30]

Nit: This line should be indented four spaces from the start of the previous
line, not from the start of base::TimeDelta.

[Daniel Erat, 2014/04/23 14:35:34]

debatable unless the style guide has been updated or the chromium codebase has
suddenly become way more consistent than it used to be, but done in any case.
:-P

[bartfab (slow), 2014/04/23 14:50:22]

Neither of these is very likely. I guess I just like to pretend things are more
consistent than they really are :).

   }
 
   void IdleActionDeferredReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, IdleActionDeferred());
   }
 
   void InputEventReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::InputEvent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
@@ skipping 32 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;
       }
     }
   }
 
-  void SuspendStateChangedReceived(dbus::Signal* signal) {
-    dbus::MessageReader reader(signal);
-    power_manager::SuspendState proto;
-    if (!reader.PopArrayOfBytesAsProto(&proto)) {
-      LOG(ERROR) << "Unable to decode protocol buffer from "
-                 << power_manager::kSuspendStateChangedSignal << " signal";
-      return;
-    }
-
-    VLOG(1) << "Got " << power_manager::kSuspendStateChangedSignal << " signal:"
-            << " type=" << proto.type() << " wall_time=" << proto.wall_time();
-    base::Time wall_time =
-        base::Time::FromInternalValue(proto.wall_time());
-    switch (proto.type()) {
-      case power_manager::SuspendState_Type_SUSPEND_TO_MEMORY:
-        last_suspend_wall_time_ = wall_time;
-        break;
-      case power_manager::SuspendState_Type_RESUME:
-        FOR_EACH_OBSERVER(
-            PowerManagerClient::Observer, observers_,
-            SystemResumed(wall_time - last_suspend_wall_time_));
-        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() {
     // Throw out any old delay that was registered.
     suspend_delay_id_ = -1;
     has_suspend_delay_id_ = false;
 
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
@@ skipping 36 matching lines @@
   // suspend readiness callbacks.
   void MaybeReportSuspendReadiness() {
     if (!suspend_is_pending_ || num_pending_suspend_readiness_callbacks_ > 0)
       return;
 
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kHandleSuspendReadinessMethod);
     dbus::MessageWriter writer(&method_call);
 
+    VLOG(1) << "Announcing readiness of suspend delay " << suspend_delay_id_
+            << " for suspend attempt " << pending_suspend_id_;
     power_manager::SuspendReadinessInfo protobuf_request;
     protobuf_request.set_delay_id(suspend_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;
@@ skipping 18 matching lines @@
   // powerd-supplied ID corresponding to an imminent suspend attempt that is
   // currently being delayed.
   int32 pending_suspend_id_;
   bool suspend_is_pending_;
 
   // 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_;
 
-  // Wall time from the latest signal telling us that the system was about to
-  // suspend to memory.
-  base::Time last_suspend_wall_time_;
-
   // 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.
   base::WeakPtrFactory<PowerManagerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientImpl);
 };
 
@@ skipping 224 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