1065 lines
39 KiB
C++
1065 lines
39 KiB
C++
// Automatic generation of D-Bus interfaces:
|
|
// - org.chromium.SessionManagerInterface
|
|
#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H
|
|
#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_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::SessionManagerInterface.
|
|
class SessionManagerInterfaceProxyInterface {
|
|
public:
|
|
virtual ~SessionManagerInterfaceProxyInterface() = default;
|
|
|
|
virtual bool EmitLoginPromptVisible(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void EmitLoginPromptVisibleAsync(
|
|
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 EnableChromeTesting(
|
|
bool in_force_relaunch,
|
|
const std::vector<std::string>& in_extra_arguments,
|
|
std::string* out_filepath,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void EnableChromeTestingAsync(
|
|
bool in_force_relaunch,
|
|
const std::vector<std::string>& in_extra_arguments,
|
|
const base::Callback<void(const std::string& /*filepath*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool StartSession(
|
|
const std::string& in_email_address,
|
|
const std::string& in_unique_identifier,
|
|
bool* out_done,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void StartSessionAsync(
|
|
const std::string& in_email_address,
|
|
const std::string& in_unique_identifier,
|
|
const base::Callback<void(bool /*done*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool StopSession(
|
|
const std::string& in_unique_identifier,
|
|
bool* out_done,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void StopSessionAsync(
|
|
const std::string& in_unique_identifier,
|
|
const base::Callback<void(bool /*done*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool StorePolicy(
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
bool* out_done,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void StorePolicyAsync(
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
const base::Callback<void(bool /*done*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool RetrievePolicy(
|
|
std::vector<uint8_t>* out_policy_blob,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RetrievePolicyAsync(
|
|
const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool StorePolicyForUser(
|
|
const std::string& in_user_email,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
bool* out_done,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void StorePolicyForUserAsync(
|
|
const std::string& in_user_email,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
const base::Callback<void(bool /*done*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool RetrievePolicyForUser(
|
|
const std::string& in_user_email,
|
|
std::vector<uint8_t>* out_policy_blob,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RetrievePolicyForUserAsync(
|
|
const std::string& in_user_email,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool StoreDeviceLocalAccountPolicy(
|
|
const std::string& in_account_id,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
bool* out_done,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void StoreDeviceLocalAccountPolicyAsync(
|
|
const std::string& in_account_id,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
const base::Callback<void(bool /*done*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool RetrieveDeviceLocalAccountPolicy(
|
|
const std::string& in_account_id,
|
|
std::vector<uint8_t>* out_policy_blob,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RetrieveDeviceLocalAccountPolicyAsync(
|
|
const std::string& in_account_id,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool RetrieveSessionState(
|
|
std::string* out_state,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RetrieveSessionStateAsync(
|
|
const base::Callback<void(const std::string& /*state*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool RetrieveActiveSessions(
|
|
std::map<std::string, std::string>* out_sessions,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RetrieveActiveSessionsAsync(
|
|
const base::Callback<void(const std::map<std::string, std::string>& /*sessions*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool HandleSupervisedUserCreationStarting(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void HandleSupervisedUserCreationStartingAsync(
|
|
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 HandleSupervisedUserCreationFinished(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void HandleSupervisedUserCreationFinishedAsync(
|
|
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 LockScreen(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void LockScreenAsync(
|
|
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 HandleLockScreenShown(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void HandleLockScreenShownAsync(
|
|
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 HandleLockScreenDismissed(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void HandleLockScreenDismissedAsync(
|
|
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 RestartJob(
|
|
const dbus::FileDescriptor& in_cred_fd,
|
|
const std::vector<std::string>& in_argv,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RestartJobAsync(
|
|
const dbus::FileDescriptor& in_cred_fd,
|
|
const std::vector<std::string>& in_argv,
|
|
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 StartDeviceWipe(
|
|
bool* out_done,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void StartDeviceWipeAsync(
|
|
const base::Callback<void(bool /*done*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool SetFlagsForUser(
|
|
const std::string& in_user_email,
|
|
const std::vector<std::string>& in_flags,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void SetFlagsForUserAsync(
|
|
const std::string& in_user_email,
|
|
const std::vector<std::string>& in_flags,
|
|
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 GetServerBackedStateKeys(
|
|
std::vector<std::vector<uint8_t>>* out_state_keys,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void GetServerBackedStateKeysAsync(
|
|
const base::Callback<void(const std::vector<std::vector<uint8_t>>& /*state_keys*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool InitMachineInfo(
|
|
const std::string& in_data,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void InitMachineInfoAsync(
|
|
const std::string& in_data,
|
|
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 RegisterLoginPromptVisibleSignalHandler(
|
|
const base::Closure& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterSessionStateChangedSignalHandler(
|
|
const base::Callback<void(const std::string&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterSetOwnerKeyCompleteSignalHandler(
|
|
const base::Callback<void(const std::string&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterPropertyChangeCompleteSignalHandler(
|
|
const base::Callback<void(const std::string&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterScreenIsLockedSignalHandler(
|
|
const base::Closure& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterScreenIsUnlockedSignalHandler(
|
|
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::SessionManagerInterface.
|
|
class SessionManagerInterfaceProxy final : public SessionManagerInterfaceProxyInterface {
|
|
public:
|
|
SessionManagerInterfaceProxy(const scoped_refptr<dbus::Bus>& bus) :
|
|
bus_{bus},
|
|
dbus_object_proxy_{
|
|
bus_->GetObjectProxy(service_name_, object_path_)} {
|
|
}
|
|
|
|
~SessionManagerInterfaceProxy() override {
|
|
bus_->RemoveObjectProxy(
|
|
service_name_, object_path_, base::Bind(&base::DoNothing));
|
|
}
|
|
|
|
void RegisterLoginPromptVisibleSignalHandler(
|
|
const base::Closure& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.SessionManagerInterface",
|
|
"LoginPromptVisible",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterSessionStateChangedSignalHandler(
|
|
const base::Callback<void(const std::string&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.SessionManagerInterface",
|
|
"SessionStateChanged",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterSetOwnerKeyCompleteSignalHandler(
|
|
const base::Callback<void(const std::string&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.SessionManagerInterface",
|
|
"SetOwnerKeyComplete",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterPropertyChangeCompleteSignalHandler(
|
|
const base::Callback<void(const std::string&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.SessionManagerInterface",
|
|
"PropertyChangeComplete",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterScreenIsLockedSignalHandler(
|
|
const base::Closure& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.SessionManagerInterface",
|
|
"ScreenIsLocked",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterScreenIsUnlockedSignalHandler(
|
|
const base::Closure& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.SessionManagerInterface",
|
|
"ScreenIsUnlocked",
|
|
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 EmitLoginPromptVisible(
|
|
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.SessionManagerInterface",
|
|
"EmitLoginPromptVisible",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void EmitLoginPromptVisibleAsync(
|
|
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.SessionManagerInterface",
|
|
"EmitLoginPromptVisible",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool EnableChromeTesting(
|
|
bool in_force_relaunch,
|
|
const std::vector<std::string>& in_extra_arguments,
|
|
std::string* out_filepath,
|
|
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.SessionManagerInterface",
|
|
"EnableChromeTesting",
|
|
error,
|
|
in_force_relaunch,
|
|
in_extra_arguments);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_filepath);
|
|
}
|
|
|
|
void EnableChromeTestingAsync(
|
|
bool in_force_relaunch,
|
|
const std::vector<std::string>& in_extra_arguments,
|
|
const base::Callback<void(const std::string& /*filepath*/)>& 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.SessionManagerInterface",
|
|
"EnableChromeTesting",
|
|
success_callback,
|
|
error_callback,
|
|
in_force_relaunch,
|
|
in_extra_arguments);
|
|
}
|
|
|
|
bool StartSession(
|
|
const std::string& in_email_address,
|
|
const std::string& in_unique_identifier,
|
|
bool* out_done,
|
|
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.SessionManagerInterface",
|
|
"StartSession",
|
|
error,
|
|
in_email_address,
|
|
in_unique_identifier);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_done);
|
|
}
|
|
|
|
void StartSessionAsync(
|
|
const std::string& in_email_address,
|
|
const std::string& in_unique_identifier,
|
|
const base::Callback<void(bool /*done*/)>& 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.SessionManagerInterface",
|
|
"StartSession",
|
|
success_callback,
|
|
error_callback,
|
|
in_email_address,
|
|
in_unique_identifier);
|
|
}
|
|
|
|
bool StopSession(
|
|
const std::string& in_unique_identifier,
|
|
bool* out_done,
|
|
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.SessionManagerInterface",
|
|
"StopSession",
|
|
error,
|
|
in_unique_identifier);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_done);
|
|
}
|
|
|
|
void StopSessionAsync(
|
|
const std::string& in_unique_identifier,
|
|
const base::Callback<void(bool /*done*/)>& 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.SessionManagerInterface",
|
|
"StopSession",
|
|
success_callback,
|
|
error_callback,
|
|
in_unique_identifier);
|
|
}
|
|
|
|
bool StorePolicy(
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
bool* out_done,
|
|
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.SessionManagerInterface",
|
|
"StorePolicy",
|
|
error,
|
|
in_policy_blob);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_done);
|
|
}
|
|
|
|
void StorePolicyAsync(
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
const base::Callback<void(bool /*done*/)>& 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.SessionManagerInterface",
|
|
"StorePolicy",
|
|
success_callback,
|
|
error_callback,
|
|
in_policy_blob);
|
|
}
|
|
|
|
bool RetrievePolicy(
|
|
std::vector<uint8_t>* out_policy_blob,
|
|
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.SessionManagerInterface",
|
|
"RetrievePolicy",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_policy_blob);
|
|
}
|
|
|
|
void RetrievePolicyAsync(
|
|
const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& 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.SessionManagerInterface",
|
|
"RetrievePolicy",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool StorePolicyForUser(
|
|
const std::string& in_user_email,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
bool* out_done,
|
|
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.SessionManagerInterface",
|
|
"StorePolicyForUser",
|
|
error,
|
|
in_user_email,
|
|
in_policy_blob);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_done);
|
|
}
|
|
|
|
void StorePolicyForUserAsync(
|
|
const std::string& in_user_email,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
const base::Callback<void(bool /*done*/)>& 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.SessionManagerInterface",
|
|
"StorePolicyForUser",
|
|
success_callback,
|
|
error_callback,
|
|
in_user_email,
|
|
in_policy_blob);
|
|
}
|
|
|
|
bool RetrievePolicyForUser(
|
|
const std::string& in_user_email,
|
|
std::vector<uint8_t>* out_policy_blob,
|
|
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.SessionManagerInterface",
|
|
"RetrievePolicyForUser",
|
|
error,
|
|
in_user_email);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_policy_blob);
|
|
}
|
|
|
|
void RetrievePolicyForUserAsync(
|
|
const std::string& in_user_email,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& 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.SessionManagerInterface",
|
|
"RetrievePolicyForUser",
|
|
success_callback,
|
|
error_callback,
|
|
in_user_email);
|
|
}
|
|
|
|
bool StoreDeviceLocalAccountPolicy(
|
|
const std::string& in_account_id,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
bool* out_done,
|
|
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.SessionManagerInterface",
|
|
"StoreDeviceLocalAccountPolicy",
|
|
error,
|
|
in_account_id,
|
|
in_policy_blob);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_done);
|
|
}
|
|
|
|
void StoreDeviceLocalAccountPolicyAsync(
|
|
const std::string& in_account_id,
|
|
const std::vector<uint8_t>& in_policy_blob,
|
|
const base::Callback<void(bool /*done*/)>& 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.SessionManagerInterface",
|
|
"StoreDeviceLocalAccountPolicy",
|
|
success_callback,
|
|
error_callback,
|
|
in_account_id,
|
|
in_policy_blob);
|
|
}
|
|
|
|
bool RetrieveDeviceLocalAccountPolicy(
|
|
const std::string& in_account_id,
|
|
std::vector<uint8_t>* out_policy_blob,
|
|
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.SessionManagerInterface",
|
|
"RetrieveDeviceLocalAccountPolicy",
|
|
error,
|
|
in_account_id);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_policy_blob);
|
|
}
|
|
|
|
void RetrieveDeviceLocalAccountPolicyAsync(
|
|
const std::string& in_account_id,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*policy_blob*/)>& 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.SessionManagerInterface",
|
|
"RetrieveDeviceLocalAccountPolicy",
|
|
success_callback,
|
|
error_callback,
|
|
in_account_id);
|
|
}
|
|
|
|
bool RetrieveSessionState(
|
|
std::string* out_state,
|
|
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.SessionManagerInterface",
|
|
"RetrieveSessionState",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_state);
|
|
}
|
|
|
|
void RetrieveSessionStateAsync(
|
|
const base::Callback<void(const std::string& /*state*/)>& 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.SessionManagerInterface",
|
|
"RetrieveSessionState",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool RetrieveActiveSessions(
|
|
std::map<std::string, std::string>* out_sessions,
|
|
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.SessionManagerInterface",
|
|
"RetrieveActiveSessions",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_sessions);
|
|
}
|
|
|
|
void RetrieveActiveSessionsAsync(
|
|
const base::Callback<void(const std::map<std::string, std::string>& /*sessions*/)>& 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.SessionManagerInterface",
|
|
"RetrieveActiveSessions",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool HandleSupervisedUserCreationStarting(
|
|
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.SessionManagerInterface",
|
|
"HandleSupervisedUserCreationStarting",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void HandleSupervisedUserCreationStartingAsync(
|
|
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.SessionManagerInterface",
|
|
"HandleSupervisedUserCreationStarting",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool HandleSupervisedUserCreationFinished(
|
|
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.SessionManagerInterface",
|
|
"HandleSupervisedUserCreationFinished",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void HandleSupervisedUserCreationFinishedAsync(
|
|
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.SessionManagerInterface",
|
|
"HandleSupervisedUserCreationFinished",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool LockScreen(
|
|
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.SessionManagerInterface",
|
|
"LockScreen",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void LockScreenAsync(
|
|
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.SessionManagerInterface",
|
|
"LockScreen",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool HandleLockScreenShown(
|
|
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.SessionManagerInterface",
|
|
"HandleLockScreenShown",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void HandleLockScreenShownAsync(
|
|
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.SessionManagerInterface",
|
|
"HandleLockScreenShown",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool HandleLockScreenDismissed(
|
|
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.SessionManagerInterface",
|
|
"HandleLockScreenDismissed",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void HandleLockScreenDismissedAsync(
|
|
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.SessionManagerInterface",
|
|
"HandleLockScreenDismissed",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool RestartJob(
|
|
const dbus::FileDescriptor& in_cred_fd,
|
|
const std::vector<std::string>& in_argv,
|
|
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.SessionManagerInterface",
|
|
"RestartJob",
|
|
error,
|
|
in_cred_fd,
|
|
in_argv);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void RestartJobAsync(
|
|
const dbus::FileDescriptor& in_cred_fd,
|
|
const std::vector<std::string>& in_argv,
|
|
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.SessionManagerInterface",
|
|
"RestartJob",
|
|
success_callback,
|
|
error_callback,
|
|
in_cred_fd,
|
|
in_argv);
|
|
}
|
|
|
|
bool StartDeviceWipe(
|
|
bool* out_done,
|
|
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.SessionManagerInterface",
|
|
"StartDeviceWipe",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_done);
|
|
}
|
|
|
|
void StartDeviceWipeAsync(
|
|
const base::Callback<void(bool /*done*/)>& 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.SessionManagerInterface",
|
|
"StartDeviceWipe",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool SetFlagsForUser(
|
|
const std::string& in_user_email,
|
|
const std::vector<std::string>& in_flags,
|
|
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.SessionManagerInterface",
|
|
"SetFlagsForUser",
|
|
error,
|
|
in_user_email,
|
|
in_flags);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void SetFlagsForUserAsync(
|
|
const std::string& in_user_email,
|
|
const std::vector<std::string>& in_flags,
|
|
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.SessionManagerInterface",
|
|
"SetFlagsForUser",
|
|
success_callback,
|
|
error_callback,
|
|
in_user_email,
|
|
in_flags);
|
|
}
|
|
|
|
bool GetServerBackedStateKeys(
|
|
std::vector<std::vector<uint8_t>>* out_state_keys,
|
|
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.SessionManagerInterface",
|
|
"GetServerBackedStateKeys",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_state_keys);
|
|
}
|
|
|
|
void GetServerBackedStateKeysAsync(
|
|
const base::Callback<void(const std::vector<std::vector<uint8_t>>& /*state_keys*/)>& 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.SessionManagerInterface",
|
|
"GetServerBackedStateKeys",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool InitMachineInfo(
|
|
const std::string& in_data,
|
|
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.SessionManagerInterface",
|
|
"InitMachineInfo",
|
|
error,
|
|
in_data);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void InitMachineInfoAsync(
|
|
const std::string& in_data,
|
|
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.SessionManagerInterface",
|
|
"InitMachineInfo",
|
|
success_callback,
|
|
error_callback,
|
|
in_data);
|
|
}
|
|
|
|
private:
|
|
scoped_refptr<dbus::Bus> bus_;
|
|
const std::string service_name_{"org.chromium.SessionManager"};
|
|
const dbus::ObjectPath object_path_{"/org/chromium/SessionManager"};
|
|
dbus::ObjectProxy* dbus_object_proxy_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(SessionManagerInterfaceProxy);
|
|
};
|
|
|
|
} // namespace chromium
|
|
} // namespace org
|
|
|
|
#endif // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_VAR_CACHE_PORTAGE_CHROMEOS_BASE_CHROMEOS_LOGIN_OUT_DEFAULT_GEN_INCLUDE_SESSION_MANAGER_DBUS_PROXIES_H
|