chromeos: Add PowerManagerClient::GetSwitchStates().

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 <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 11 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/timer/timer.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
 #include "chromeos/dbus/power_manager/input_event.pb.h"
 #include "chromeos/dbus/power_manager/peripheral_battery_status.pb.h"
 #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"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
 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;
 
 // 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:
   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),
@@ skipping 197 matching lines @@
   void GetBacklightsForcedOff(
       const GetBacklightsForcedOffCallback& callback) override {
     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
                                  power_manager::kGetBacklightsForcedOffMethod);
     power_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&PowerManagerClientImpl::OnGetBacklightsForcedOff,
                    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_);
     num_pending_suspend_readiness_callbacks_++;
     return base::Bind(&PowerManagerClientImpl::HandleObserverSuspendReadiness,
                       weak_ptr_factory_.GetWeakPtr(), pending_suspend_id_,
                       suspending_from_dark_resume_);
   }
 
   int GetNumPendingSuspendReadinessCallbacks() override {
@@ skipping 229 matching lines @@
     }
     dbus::MessageReader reader(response);
     bool state = false;
     if (!reader.PopBool(&state)) {
       POWER_LOG(ERROR) << "Error reading response from powerd: "
                        << response->ToString();
     }
     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_)
       observer.PowerChanged(proto);
     const bool on_battery = proto.external_power() ==
         power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED;
     base::PowerMonitorDeviceSource::SetPowerSource(on_battery);
   }
 
   void HandleRegisterSuspendDelayReply(bool dark_suspend,
@@ skipping 163 matching lines @@
           dbus::MessageWriter writer(&method_call);
           writer.AppendInt64(proto.timestamp());
           power_manager_proxy_->CallMethod(
               &method_call,
               dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
               dbus::ObjectProxy::EmptyResponseCallback());
         }
         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;
     }
   }
 
   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);
@@ skipping 158 matching lines @@
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(FAKE_DBUS_CLIENT_IMPLEMENTATION, type);
   return new FakePowerManagerClient();
 }
 
 }  // namespace chromeos