| // Automatic generation of D-Bus interfaces: |
| // - org.chromium.PowerManager |
| #ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H |
| #define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include <base/bind.h> |
| #include <base/callback.h> |
| #include <base/logging.h> |
| #include <base/macros.h> |
| #include <base/memory/ref_counted.h> |
| #include <brillo/any.h> |
| #include <brillo/dbus/dbus_method_invoker.h> |
| #include <brillo/dbus/dbus_property.h> |
| #include <brillo/dbus/dbus_signal_handler.h> |
| #include <brillo/errors/error.h> |
| #include <brillo/variant_dictionary.h> |
| #include <dbus/bus.h> |
| #include <dbus/message.h> |
| #include <dbus/object_manager.h> |
| #include <dbus/object_path.h> |
| #include <dbus/object_proxy.h> |
| |
| namespace org { |
| namespace chromium { |
| |
| // Abstract interface proxy for org::chromium::PowerManager. |
| class PowerManagerProxyInterface { |
| public: |
| virtual ~PowerManagerProxyInterface() = default; |
| |
| virtual bool RequestShutdown( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void RequestShutdownAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |reason| arg is a power_manager::RequestRestartReason value. |
| virtual bool RequestRestart( |
| int32_t in_reason, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |reason| arg is a power_manager::RequestRestartReason value. |
| virtual void RequestRestartAsync( |
| int32_t in_reason, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |external_wakeup_count| arg is optional, and it will call two |
| // different methods in the backend. This can't be expressed in the DBus |
| // Introspection XML file. |
| virtual bool RequestSuspend( |
| uint64_t in_external_wakeup_count, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |external_wakeup_count| arg is optional, and it will call two |
| // different methods in the backend. This can't be expressed in the DBus |
| // Introspection XML file. |
| virtual void RequestSuspendAsync( |
| uint64_t in_external_wakeup_count, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool DecreaseScreenBrightness( |
| bool in_allow_off, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void DecreaseScreenBrightnessAsync( |
| bool in_allow_off, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool IncreaseScreenBrightness( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void IncreaseScreenBrightnessAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool GetScreenBrightnessPercent( |
| double* out_percent, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void GetScreenBrightnessPercentAsync( |
| const base::Callback<void(double /*percent*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |style| arg must be one of the values: |
| // power_manager::kBrightnessTransitionGradual or |
| // power_manager::kBrightnessTransitionInstant. |
| virtual bool SetScreenBrightnessPercent( |
| double in_percent, |
| int32_t in_style, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |style| arg must be one of the values: |
| // power_manager::kBrightnessTransitionGradual or |
| // power_manager::kBrightnessTransitionInstant. |
| virtual void SetScreenBrightnessPercentAsync( |
| double in_percent, |
| int32_t in_style, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool DecreaseKeyboardBrightness( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void DecreaseKeyboardBrightnessAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool IncreaseKeyboardBrightness( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void IncreaseKeyboardBrightnessAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerSupplyProperties protobuf. |
| virtual bool GetPowerSupplyProperties( |
| std::vector<uint8_t>* out_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerSupplyProperties protobuf. |
| virtual void GetPowerSupplyPropertiesAsync( |
| const base::Callback<void(const std::vector<uint8_t>& /*serialized_proto*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool HandleVideoActivity( |
| bool in_fullscreen, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void HandleVideoActivityAsync( |
| bool in_fullscreen, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |type| arg is a power_manager::UserActivityType. |
| virtual bool HandleUserActivity( |
| int32_t in_type, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |type| arg is a power_manager::UserActivityType. |
| virtual void HandleUserActivityAsync( |
| int32_t in_type, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool SetIsProjecting( |
| bool in_is_projecting, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void SetIsProjectingAsync( |
| bool in_is_projecting, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerManagementPolicy protobuf. |
| virtual bool SetPolicy( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerManagementPolicy protobuf. |
| virtual void SetPolicyAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual bool SetPowerSource( |
| const std::string& in_id, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void SetPowerSourceAsync( |
| const std::string& in_id, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |timestamp_internal| arg is represented as the return value of |
| // base::TimeTicks::ToInternalValue(). |
| virtual bool HandlePowerButtonAcknowledgment( |
| int64_t in_timestamp_internal, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |timestamp_internal| arg is represented as the return value of |
| // base::TimeTicks::ToInternalValue(). |
| virtual void HandlePowerButtonAcknowledgmentAsync( |
| int64_t in_timestamp_internal, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| virtual bool RegisterSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| std::vector<uint8_t>* out_serialized_reply_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| virtual void RegisterSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| virtual bool UnregisterSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| virtual void UnregisterSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| virtual bool HandleSuspendReadiness( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| virtual void HandleSuspendReadinessAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| virtual bool RegisterDarkSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| std::vector<uint8_t>* out_serialized_reply_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| virtual void RegisterDarkSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| virtual bool UnregisterDarkSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| virtual void UnregisterDarkSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| virtual bool HandleDarkSuspendReadiness( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| virtual void HandleDarkSuspendReadinessAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::DarkResumeWakeReason protobuf. |
| virtual bool RecordDarkResumeWakeReason( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::DarkResumeWakeReason protobuf. |
| virtual void RecordDarkResumeWakeReasonAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0; |
| |
| virtual void RegisterBrightnessChangedSignalHandler( |
| const base::Callback<void(int32_t, |
| bool)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterKeyboardBrightnessChangedSignalHandler( |
| const base::Callback<void(int32_t, |
| bool)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterPeripheralBatteryStatusSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterPowerSupplyPollSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterSuspendImminentSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterSuspendDoneSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterDarkSuspendImminentSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterInputEventSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterIdleActionImminentSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| |
| virtual void RegisterIdleActionDeferredSignalHandler( |
| const base::Closure& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0; |
| }; |
| |
| } // namespace chromium |
| } // namespace org |
| |
| namespace org { |
| namespace chromium { |
| |
| // Interface proxy for org::chromium::PowerManager. |
| class PowerManagerProxy final : public PowerManagerProxyInterface { |
| public: |
| PowerManagerProxy(const scoped_refptr<dbus::Bus>& bus) : |
| bus_{bus}, |
| dbus_object_proxy_{ |
| bus_->GetObjectProxy(service_name_, object_path_)} { |
| } |
| |
| ~PowerManagerProxy() override { |
| bus_->RemoveObjectProxy( |
| service_name_, object_path_, base::Bind(&base::DoNothing)); |
| } |
| |
| void RegisterBrightnessChangedSignalHandler( |
| const base::Callback<void(int32_t, |
| bool)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "BrightnessChanged", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterKeyboardBrightnessChangedSignalHandler( |
| const base::Callback<void(int32_t, |
| bool)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "KeyboardBrightnessChanged", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterPeripheralBatteryStatusSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "PeripheralBatteryStatus", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterPowerSupplyPollSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "PowerSupplyPoll", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterSuspendImminentSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SuspendImminent", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterSuspendDoneSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SuspendDone", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterDarkSuspendImminentSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "DarkSuspendImminent", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterInputEventSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "InputEvent", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterIdleActionImminentSignalHandler( |
| const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "IdleActionImminent", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void RegisterIdleActionDeferredSignalHandler( |
| const base::Closure& signal_callback, |
| dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override { |
| brillo::dbus_utils::ConnectToSignal( |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "IdleActionDeferred", |
| signal_callback, |
| on_connected_callback); |
| } |
| |
| void ReleaseObjectProxy(const base::Closure& callback) { |
| bus_->RemoveObjectProxy(service_name_, object_path_, callback); |
| } |
| |
| const dbus::ObjectPath& GetObjectPath() const { |
| return object_path_; |
| } |
| |
| dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; } |
| |
| bool RequestShutdown( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RequestShutdown", |
| error); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void RequestShutdownAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RequestShutdown", |
| success_callback, |
| error_callback); |
| } |
| |
| // The |reason| arg is a power_manager::RequestRestartReason value. |
| bool RequestRestart( |
| int32_t in_reason, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RequestRestart", |
| error, |
| in_reason); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |reason| arg is a power_manager::RequestRestartReason value. |
| void RequestRestartAsync( |
| int32_t in_reason, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RequestRestart", |
| success_callback, |
| error_callback, |
| in_reason); |
| } |
| |
| // The |external_wakeup_count| arg is optional, and it will call two |
| // different methods in the backend. This can't be expressed in the DBus |
| // Introspection XML file. |
| bool RequestSuspend( |
| uint64_t in_external_wakeup_count, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RequestSuspend", |
| error, |
| in_external_wakeup_count); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |external_wakeup_count| arg is optional, and it will call two |
| // different methods in the backend. This can't be expressed in the DBus |
| // Introspection XML file. |
| void RequestSuspendAsync( |
| uint64_t in_external_wakeup_count, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RequestSuspend", |
| success_callback, |
| error_callback, |
| in_external_wakeup_count); |
| } |
| |
| bool DecreaseScreenBrightness( |
| bool in_allow_off, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "DecreaseScreenBrightness", |
| error, |
| in_allow_off); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void DecreaseScreenBrightnessAsync( |
| bool in_allow_off, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "DecreaseScreenBrightness", |
| success_callback, |
| error_callback, |
| in_allow_off); |
| } |
| |
| bool IncreaseScreenBrightness( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "IncreaseScreenBrightness", |
| error); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void IncreaseScreenBrightnessAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "IncreaseScreenBrightness", |
| success_callback, |
| error_callback); |
| } |
| |
| bool GetScreenBrightnessPercent( |
| double* out_percent, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "GetScreenBrightnessPercent", |
| error); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error, out_percent); |
| } |
| |
| void GetScreenBrightnessPercentAsync( |
| const base::Callback<void(double /*percent*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "GetScreenBrightnessPercent", |
| success_callback, |
| error_callback); |
| } |
| |
| // The |style| arg must be one of the values: |
| // power_manager::kBrightnessTransitionGradual or |
| // power_manager::kBrightnessTransitionInstant. |
| bool SetScreenBrightnessPercent( |
| double in_percent, |
| int32_t in_style, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetScreenBrightnessPercent", |
| error, |
| in_percent, |
| in_style); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |style| arg must be one of the values: |
| // power_manager::kBrightnessTransitionGradual or |
| // power_manager::kBrightnessTransitionInstant. |
| void SetScreenBrightnessPercentAsync( |
| double in_percent, |
| int32_t in_style, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetScreenBrightnessPercent", |
| success_callback, |
| error_callback, |
| in_percent, |
| in_style); |
| } |
| |
| bool DecreaseKeyboardBrightness( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "DecreaseKeyboardBrightness", |
| error); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void DecreaseKeyboardBrightnessAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "DecreaseKeyboardBrightness", |
| success_callback, |
| error_callback); |
| } |
| |
| bool IncreaseKeyboardBrightness( |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "IncreaseKeyboardBrightness", |
| error); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void IncreaseKeyboardBrightnessAsync( |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "IncreaseKeyboardBrightness", |
| success_callback, |
| error_callback); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerSupplyProperties protobuf. |
| bool GetPowerSupplyProperties( |
| std::vector<uint8_t>* out_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "GetPowerSupplyProperties", |
| error); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error, out_serialized_proto); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerSupplyProperties protobuf. |
| void GetPowerSupplyPropertiesAsync( |
| const base::Callback<void(const std::vector<uint8_t>& /*serialized_proto*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "GetPowerSupplyProperties", |
| success_callback, |
| error_callback); |
| } |
| |
| bool HandleVideoActivity( |
| bool in_fullscreen, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleVideoActivity", |
| error, |
| in_fullscreen); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void HandleVideoActivityAsync( |
| bool in_fullscreen, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleVideoActivity", |
| success_callback, |
| error_callback, |
| in_fullscreen); |
| } |
| |
| // The |type| arg is a power_manager::UserActivityType. |
| bool HandleUserActivity( |
| int32_t in_type, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleUserActivity", |
| error, |
| in_type); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |type| arg is a power_manager::UserActivityType. |
| void HandleUserActivityAsync( |
| int32_t in_type, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleUserActivity", |
| success_callback, |
| error_callback, |
| in_type); |
| } |
| |
| bool SetIsProjecting( |
| bool in_is_projecting, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetIsProjecting", |
| error, |
| in_is_projecting); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void SetIsProjectingAsync( |
| bool in_is_projecting, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetIsProjecting", |
| success_callback, |
| error_callback, |
| in_is_projecting); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerManagementPolicy protobuf. |
| bool SetPolicy( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetPolicy", |
| error, |
| in_serialized_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::PowerManagementPolicy protobuf. |
| void SetPolicyAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetPolicy", |
| success_callback, |
| error_callback, |
| in_serialized_proto); |
| } |
| |
| bool SetPowerSource( |
| const std::string& in_id, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetPowerSource", |
| error, |
| in_id); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| void SetPowerSourceAsync( |
| const std::string& in_id, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "SetPowerSource", |
| success_callback, |
| error_callback, |
| in_id); |
| } |
| |
| // The |timestamp_internal| arg is represented as the return value of |
| // base::TimeTicks::ToInternalValue(). |
| bool HandlePowerButtonAcknowledgment( |
| int64_t in_timestamp_internal, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandlePowerButtonAcknowledgment", |
| error, |
| in_timestamp_internal); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |timestamp_internal| arg is represented as the return value of |
| // base::TimeTicks::ToInternalValue(). |
| void HandlePowerButtonAcknowledgmentAsync( |
| int64_t in_timestamp_internal, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandlePowerButtonAcknowledgment", |
| success_callback, |
| error_callback, |
| in_timestamp_internal); |
| } |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| bool RegisterSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| std::vector<uint8_t>* out_serialized_reply_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RegisterSuspendDelay", |
| error, |
| in_serialized_request_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error, out_serialized_reply_proto); |
| } |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| void RegisterSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RegisterSuspendDelay", |
| success_callback, |
| error_callback, |
| in_serialized_request_proto); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| bool UnregisterSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "UnregisterSuspendDelay", |
| error, |
| in_serialized_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| void UnregisterSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "UnregisterSuspendDelay", |
| success_callback, |
| error_callback, |
| in_serialized_proto); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| bool HandleSuspendReadiness( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleSuspendReadiness", |
| error, |
| in_serialized_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| void HandleSuspendReadinessAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleSuspendReadiness", |
| success_callback, |
| error_callback, |
| in_serialized_proto); |
| } |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| bool RegisterDarkSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| std::vector<uint8_t>* out_serialized_reply_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RegisterDarkSuspendDelay", |
| error, |
| in_serialized_request_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error, out_serialized_reply_proto); |
| } |
| |
| // The |serialized_request_proto| arg is a serialized |
| // power_manager::RegisterSuspendDelayRequest protobuf. |
| // The |serialized_reply_proto| arg is a serialized |
| // RegisterSuspendDelayReply protobuf. |
| void RegisterDarkSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_request_proto, |
| const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RegisterDarkSuspendDelay", |
| success_callback, |
| error_callback, |
| in_serialized_request_proto); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| bool UnregisterDarkSuspendDelay( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "UnregisterDarkSuspendDelay", |
| error, |
| in_serialized_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::UnregisterSuspendDelayRequest protobuf. |
| void UnregisterDarkSuspendDelayAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "UnregisterDarkSuspendDelay", |
| success_callback, |
| error_callback, |
| in_serialized_proto); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| bool HandleDarkSuspendReadiness( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleDarkSuspendReadiness", |
| error, |
| in_serialized_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::SuspendReadinessInfo protobuf. |
| void HandleDarkSuspendReadinessAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "HandleDarkSuspendReadiness", |
| success_callback, |
| error_callback, |
| in_serialized_proto); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::DarkResumeWakeReason protobuf. |
| bool RecordDarkResumeWakeReason( |
| const std::vector<uint8_t>& in_serialized_proto, |
| brillo::ErrorPtr* error, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RecordDarkResumeWakeReason", |
| error, |
| in_serialized_proto); |
| return response && brillo::dbus_utils::ExtractMethodCallResults( |
| response.get(), error); |
| } |
| |
| // The |serialized_proto| arg is a serialized |
| // power_manager::DarkResumeWakeReason protobuf. |
| void RecordDarkResumeWakeReasonAsync( |
| const std::vector<uint8_t>& in_serialized_proto, |
| const base::Callback<void()>& success_callback, |
| const base::Callback<void(brillo::Error*)>& error_callback, |
| int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override { |
| brillo::dbus_utils::CallMethodWithTimeout( |
| timeout_ms, |
| dbus_object_proxy_, |
| "org.chromium.PowerManager", |
| "RecordDarkResumeWakeReason", |
| success_callback, |
| error_callback, |
| in_serialized_proto); |
| } |
| |
| private: |
| scoped_refptr<dbus::Bus> bus_; |
| const std::string service_name_{"org.chromium.PowerManager"}; |
| const dbus::ObjectPath object_path_{"/org/chromium/PowerManager"}; |
| dbus::ObjectProxy* dbus_object_proxy_; |
| |
| DISALLOW_COPY_AND_ASSIGN(PowerManagerProxy); |
| }; |
| |
| } // namespace chromium |
| } // namespace org |
| |
| #endif // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H |
