chromeos: Add PowerManagerClient::GetSwitchStates().

chromeos/dbus/power_manager_client.cc

Index: chromeos/dbus/power_manager_client.cc
diff --git a/chromeos/dbus/power_manager_client.cc b/chromeos/dbus/power_manager_client.cc
index 90097f817c855e77616cbfafd815c99655946755..2ee1a195e42d04e356eff8206be6996c6852147d 100644
--- a/chromeos/dbus/power_manager_client.cc
+++ b/chromeos/dbus/power_manager_client.cc
@@ -29,6 +29,7 @@
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
 #include "chromeos/dbus/power_manager/suspend.pb.h"
+#include "chromeos/dbus/power_manager/switch_states.pb.h"
 #include "chromeos/system/statistics_provider.h"
 #include "components/device_event_log/device_event_log.h"
 #include "dbus/bus.h"
@@ -38,6 +39,8 @@
 
 namespace chromeos {
 
+namespace {
+
 // Maximum amount of time that the power manager will wait for Chrome to
 // say that it's ready for the system to be suspended, in milliseconds.
 const int kSuspendDelayTimeoutMs = 5000;
@@ -45,6 +48,40 @@ const int kSuspendDelayTimeoutMs = 5000;
 // Human-readable description of Chrome's suspend delay.
 const char kSuspendDelayDescription[] = "chrome";
 
+// Converts a LidState value from a power_manager::SwitchStates proto to the
+// corresponding PowerManagerClient::LidState value.
+PowerManagerClient::LidState GetLidStateFromProtoEnum(
+    power_manager::SwitchStates::LidState state) {
+  switch (state) {
+    case power_manager::SwitchStates_LidState_OPEN:
+      return PowerManagerClient::LidState::OPEN;
+    case power_manager::SwitchStates_LidState_CLOSED:
+      return PowerManagerClient::LidState::CLOSED;
+    case power_manager::SwitchStates_LidState_NOT_PRESENT:
+      return PowerManagerClient::LidState::NOT_PRESENT;
+  }
+  NOTREACHED() << "Unhandled lid state " << state;
+  return PowerManagerClient::LidState::NOT_PRESENT;
+}
+
+// Converts a TabletMode value from a power_manager::SwitchStates proto to the
+// corresponding PowerManagerClient::TabletMode value.
+PowerManagerClient::TabletMode GetTabletModeFromProtoEnum(
+    power_manager::SwitchStates::TabletMode mode) {
+  switch (mode) {
+    case power_manager::SwitchStates_TabletMode_ON:
+      return PowerManagerClient::TabletMode::ON;
+    case power_manager::SwitchStates_TabletMode_OFF:
+      return PowerManagerClient::TabletMode::OFF;
+    case power_manager::SwitchStates_TabletMode_UNSUPPORTED:
+      return PowerManagerClient::TabletMode::UNSUPPORTED;
+  }
+  NOTREACHED() << "Unhandled tablet mode " << mode;
+  return PowerManagerClient::TabletMode::UNSUPPORTED;
+}
+
+}  // namespace
+
 // The PowerManagerClient implementation used in production.
 class PowerManagerClientImpl : public PowerManagerClient {
  public:
@@ -262,6 +299,15 @@ class PowerManagerClientImpl : public PowerManagerClient {
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
+  void GetSwitchStates(const GetSwitchStatesCallback& callback) override {

[jonross, 2017/03/21 17:01:57]

And I can just call this to poll. Sweet thanks!

+    dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
+                                 power_manager::kGetSwitchStatesMethod);
+    power_manager_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&PowerManagerClientImpl::OnGetSwitchStates,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
   base::Closure GetSuspendReadinessCallback() override {
     DCHECK(OnOriginThread());
     DCHECK(suspend_is_pending_);
@@ -511,6 +557,23 @@ class PowerManagerClientImpl : public PowerManagerClient {
     callback.Run(state);
   }
 
+  void OnGetSwitchStates(const GetSwitchStatesCallback& callback,
+                         dbus::Response* response) {
+    if (!response) {
+      POWER_LOG(ERROR) << "Error calling "
+                       << power_manager::kGetSwitchStatesMethod;
+      return;

[Daniel Erat, 2017/03/21 16:14:16]

i'm following this class's existing practice of apparently dropping callbacks on
the floor when d-bus calls to powerd fail, but i'm not sure if this will cause
any problems for you. in practice, it can probably only happen at startup if
chrome somehow manages to start faster than powerd.

[jonross, 2017/03/21 17:01:57]

If this is only expected when chrome is faster than powerd, this is fine. As
powerd setting up after will notify us through InputEventReceived.

In my particular case the devices always have powerd running first, so this is
unlikely to come up. But good to know about. Maybe put a small doc about this?

[Daniel Erat, 2017/03/21 17:15:02]

sure, makes sense. i've added comments in the header for all of the methods that
i think exhibit this pattern.

+    }
+    power_manager::SwitchStates proto;
+    if (!dbus::MessageReader(response).PopArrayOfBytesAsProto(&proto)) {
+      POWER_LOG(ERROR) << "Error parsing response from "
+                       << power_manager::kGetSwitchStatesMethod;
+      return;
+    }
+    callback.Run(GetLidStateFromProtoEnum(proto.lid_state()),
+                 GetTabletModeFromProtoEnum(proto.tablet_mode()));
+  }
+
   void HandlePowerSupplyProperties(
       const power_manager::PowerSupplyProperties& proto) {
     for (auto& observer : observers_)
@@ -694,21 +757,21 @@ class PowerManagerClientImpl : public PowerManagerClient {
         break;
       }
       case power_manager::InputEvent_Type_LID_OPEN:
-      case power_manager::InputEvent_Type_LID_CLOSED: {
-        bool open =
-            (proto.type() == power_manager::InputEvent_Type_LID_OPEN);
         for (auto& observer : observers_)
-          observer.LidEventReceived(open, timestamp);
+          observer.LidEventReceived(LidState::OPEN, timestamp);
+        break;
+      case power_manager::InputEvent_Type_LID_CLOSED:
+        for (auto& observer : observers_)
+          observer.LidEventReceived(LidState::CLOSED, timestamp);
         break;
-      }
       case power_manager::InputEvent_Type_TABLET_MODE_ON:
-      case power_manager::InputEvent_Type_TABLET_MODE_OFF: {
-        bool on =
-            (proto.type() == power_manager::InputEvent_Type_TABLET_MODE_ON);
         for (auto& observer : observers_)
-          observer.TabletModeEventReceived(on, timestamp);
+          observer.TabletModeEventReceived(TabletMode::ON, timestamp);
+        break;
+      case power_manager::InputEvent_Type_TABLET_MODE_OFF:
+        for (auto& observer : observers_)
+          observer.TabletModeEventReceived(TabletMode::OFF, timestamp);
         break;
-      }
     }
   }