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 {
+    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;
+    }
+    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;
-      }
     }
   }