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 {

[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_);
     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;

[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_)
       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