buffet: Switch buffet::Manager to use DBusObject
Use DBusObject to implement "/org/chromium/Buffet/Manager" object.
BUG=chromium:374864
TEST=USE=buffet P2_TEST_FILTER="buffet::*" FEATURES=test emerge-link platform2
Change-Id: I91141ce76a1dbd4478577f2f7548f99a33241fb5
Reviewed-on: https://chromium-review.googlesource.com/212682
Reviewed-by: Christopher Wiley <wiley@chromium.org>
Tested-by: Alex Vakulenko <avakulenko@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>
diff --git a/buffet/manager.cc b/buffet/manager.cc
index 6c258ba..749e84a 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -22,112 +22,41 @@
#include "buffet/dbus_constants.h"
using chromeos::dbus_utils::AsyncEventSequencer;
-using chromeos::dbus_utils::GetBadArgsError;
using chromeos::dbus_utils::ExportedObjectManager;
-using chromeos::dbus_utils::GetDBusError;
namespace buffet {
-Manager::Manager(
- const base::WeakPtr<ExportedObjectManager>& object_manager)
- : exported_object_(object_manager->GetBus()->GetExportedObject(
- dbus::ObjectPath(dbus_constants::kManagerServicePath))),
- object_manager_(object_manager) { }
+Manager::Manager(const base::WeakPtr<ExportedObjectManager>& object_manager)
+ : dbus_object_(object_manager.get(),
+ object_manager->GetBus(),
+ dbus::ObjectPath(dbus_constants::kManagerServicePath)) {}
-Manager::~Manager() {
- object_manager_->ReleaseInterface(
- dbus::ObjectPath(dbus_constants::kManagerServicePath),
- dbus_constants::kManagerInterface);
- // Prevent the properties object from making calls to the exported object.
- properties_.reset(nullptr);
- // Unregister ourselves from the Bus. This prevents the bus from calling
- // our callbacks in between the Manager's death and the bus unregistering
- // our exported object on shutdown. Unretained makes no promises of memory
- // management.
- exported_object_->Unregister();
- exported_object_ = nullptr;
-}
-
-void Manager::Init(const OnInitFinish& cb) {
- scoped_refptr<AsyncEventSequencer> sequencer(
- new AsyncEventSequencer());
- exported_object_->ExportMethod(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerCheckDeviceRegistered,
- chromeos::dbus_utils::GetExportableDBusMethod(
- base::Bind(&Manager::HandleCheckDeviceRegistered,
- base::Unretained(this))),
- sequencer->GetExportHandler(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerCheckDeviceRegistered,
- "Failed exporting CheckDeviceRegistered method",
- true));
- exported_object_->ExportMethod(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerGetDeviceInfo,
- chromeos::dbus_utils::GetExportableDBusMethod(
- base::Bind(&Manager::HandleGetDeviceInfo,
- base::Unretained(this))),
- sequencer->GetExportHandler(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerGetDeviceInfo,
- "Failed exporting GetDeviceInfo method",
- true));
- exported_object_->ExportMethod(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerStartRegisterDevice,
- chromeos::dbus_utils::GetExportableDBusMethod(
- base::Bind(&Manager::HandleStartRegisterDevice,
- base::Unretained(this))),
- sequencer->GetExportHandler(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerStartRegisterDevice,
- "Failed exporting StartRegisterDevice method",
- true));
- exported_object_->ExportMethod(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerFinishRegisterDevice,
- chromeos::dbus_utils::GetExportableDBusMethod(
- base::Bind(&Manager::HandleFinishRegisterDevice,
- base::Unretained(this))),
- sequencer->GetExportHandler(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerFinishRegisterDevice,
- "Failed exporting FinishRegisterDevice method",
- true));
- exported_object_->ExportMethod(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerUpdateStateMethod,
- chromeos::dbus_utils::GetExportableDBusMethod(
- base::Bind(&Manager::HandleUpdateState,
- base::Unretained(this))),
- sequencer->GetExportHandler(
- dbus_constants::kManagerInterface,
- dbus_constants::kManagerUpdateStateMethod,
- "Failed exporting UpdateState method",
- true));
- exported_object_->ExportMethod(
- dbus_constants::kManagerInterface, dbus_constants::kManagerTestMethod,
- chromeos::dbus_utils::GetExportableDBusMethod(
- base::Bind(&Manager::HandleTestMethod, base::Unretained(this))),
- sequencer->GetExportHandler(
- dbus_constants::kManagerInterface, dbus_constants::kManagerTestMethod,
- "Failed exporting TestMethod method",
- true));
- properties_.reset(new Properties(object_manager_->GetBus()));
+void Manager::Init(const AsyncEventSequencer::CompletionAction& cb) {
+ chromeos::dbus_utils::DBusInterface* itf =
+ dbus_object_.AddOrGetInterface(dbus_constants::kManagerInterface);
+ itf->AddMethodHandler(dbus_constants::kManagerCheckDeviceRegistered,
+ base::Unretained(this),
+ &Manager::HandleCheckDeviceRegistered);
+ itf->AddMethodHandler(dbus_constants::kManagerGetDeviceInfo,
+ base::Unretained(this),
+ &Manager::HandleGetDeviceInfo);
+ itf->AddMethodHandler(dbus_constants::kManagerStartRegisterDevice,
+ base::Unretained(this),
+ &Manager::HandleStartRegisterDevice);
+ itf->AddMethodHandler(dbus_constants::kManagerFinishRegisterDevice,
+ base::Unretained(this),
+ &Manager::HandleFinishRegisterDevice);
+ itf->AddMethodHandler(dbus_constants::kManagerUpdateStateMethod,
+ base::Unretained(this),
+ &Manager::HandleUpdateState);
+ itf->AddMethodHandler(dbus_constants::kManagerTestMethod,
+ base::Unretained(this),
+ &Manager::HandleTestMethod);
+ itf->AddProperty("State", &state_);
// TODO(wiley): Initialize all properties appropriately before claiming
// the properties interface.
- properties_->state_.SetValue("{}");
- properties_->Init(
- sequencer->GetHandler("Manager properties export failed.", true));
- auto claim_interface_task = sequencer->WrapCompletionTask(
- base::Bind(&ExportedObjectManager::ClaimInterface,
- object_manager_->AsWeakPtr(),
- dbus::ObjectPath(dbus_constants::kManagerServicePath),
- dbus_constants::kManagerInterface,
- properties_->GetPropertyWriter(
- dbus_constants::kManagerInterface)));
- sequencer->OnAllTasksCompletedCall({claim_interface_task, cb});
+ state_.SetValue("{}");
+ dbus_object_.RegisterAsync(cb);
command_manager_ = std::make_shared<CommandManager>();
command_manager_->Startup();
device_info_ = std::unique_ptr<DeviceRegistrationInfo>(
@@ -135,177 +64,63 @@
device_info_->Load();
}
-scoped_ptr<dbus::Response> Manager::HandleCheckDeviceRegistered(
- dbus::MethodCall* method_call) {
- // Read the parameters to the method.
- dbus::MessageReader reader(method_call);
- if (reader.HasMoreData()) {
- return GetBadArgsError(method_call,
- "Too many parameters to CheckDeviceRegistered");
- }
-
+std::string Manager::HandleCheckDeviceRegistered(chromeos::ErrorPtr* error) {
LOG(INFO) << "Received call to Manager.CheckDeviceRegistered()";
-
- chromeos::ErrorPtr error;
- bool registered = device_info_->CheckRegistration(&error);
+ std::string device_id;
+ bool registered = device_info_->CheckRegistration(error);
// If it fails due to any reason other than 'device not registered',
// treat it as a real error and report it to the caller.
if (!registered &&
- !error->HasError(kErrorDomainGCD, "device_not_registered")) {
- return scoped_ptr<dbus::Response>(
- GetDBusError(method_call, error.get()).release());
+ !(*error)->HasError(kErrorDomainGCD, "device_not_registered")) {
+ return device_id;
}
- std::string device_id;
- if (registered) {
- device_id = device_info_->GetDeviceId(&error);
- if (device_id.empty())
- return scoped_ptr<dbus::Response>(
- GetDBusError(method_call, error.get()).release());
- }
- // Send back our response.
- scoped_ptr<dbus::Response> response(
- dbus::Response::FromMethodCall(method_call));
- dbus::MessageWriter writer(response.get());
- writer.AppendString(device_id);
- return response.Pass();
+ error->reset();
+
+ if (registered)
+ device_id = device_info_->GetDeviceId(error);
+
+ return device_id;
}
-scoped_ptr<dbus::Response> Manager::HandleGetDeviceInfo(
- dbus::MethodCall* method_call) {
- // Read the parameters to the method.
- dbus::MessageReader reader(method_call);
- if (reader.HasMoreData()) {
- return GetBadArgsError(method_call,
- "Too many parameters to GetDeviceInfo");
- }
-
+std::string Manager::HandleGetDeviceInfo(chromeos::ErrorPtr* error) {
LOG(INFO) << "Received call to Manager.GetDeviceInfo()";
std::string device_info_str;
- chromeos::ErrorPtr error;
- auto device_info = device_info_->GetDeviceInfo(&error);
+ auto device_info = device_info_->GetDeviceInfo(error);
if (!device_info)
- return scoped_ptr<dbus::Response>(
- GetDBusError(method_call, error.get()).release());
+ return device_info_str;
base::JSONWriter::Write(device_info.get(), &device_info_str);
-
- // Send back our response.
- scoped_ptr<dbus::Response> response(
- dbus::Response::FromMethodCall(method_call));
- dbus::MessageWriter writer(response.get());
- writer.AppendString(device_info_str);
- return response.Pass();
+ return device_info_str;
}
-scoped_ptr<dbus::Response> Manager::HandleStartRegisterDevice(
- dbus::MethodCall* method_call) {
- // Read the parameters to the method.
- dbus::MessageReader reader(method_call);
- if (!reader.HasMoreData()) {
- return GetBadArgsError(method_call, "No parameters to StartRegisterDevice");
- }
-
- dbus::MessageReader array_reader(nullptr);
- if (!reader.PopArray(&array_reader))
- return GetBadArgsError(method_call, "Failed to read the parameter array");
- std::map<std::string, std::shared_ptr<base::Value>> params;
- while (array_reader.HasMoreData()) {
- dbus::MessageReader dict_entry_reader(nullptr);
- if (!array_reader.PopDictEntry(&dict_entry_reader))
- return GetBadArgsError(method_call, "Failed to get a call parameter");
- std::string key;
- if (!dict_entry_reader.PopString(&key))
- return GetBadArgsError(method_call, "Failed to read parameter key");
- base::Value* value = dbus::PopDataAsValue(&dict_entry_reader);
- if (!value)
- return GetBadArgsError(method_call, "Failed to read parameter value");
- params.insert(std::make_pair(key, std::shared_ptr<base::Value>(value)));
- }
- if (reader.HasMoreData())
- return GetBadArgsError(method_call,
- "Too many parameters to StartRegisterDevice");
-
+std::string Manager::HandleStartRegisterDevice(
+ chromeos::ErrorPtr* error,
+ const std::map<std::string,
+ std::unique_ptr<base::Value>>& params) {
LOG(INFO) << "Received call to Manager.StartRegisterDevice()";
- chromeos::ErrorPtr error;
- std::string id = device_info_->StartRegistration(params, &error);
- if (id.empty())
- return scoped_ptr<dbus::Response>(
- GetDBusError(method_call, error.get()).release());
-
- // Send back our response.
- scoped_ptr<dbus::Response> response(
- dbus::Response::FromMethodCall(method_call));
- dbus::MessageWriter writer(response.get());
- writer.AppendString(id);
- return response.Pass();
+ return device_info_->StartRegistration(params, error);
}
-scoped_ptr<dbus::Response> Manager::HandleFinishRegisterDevice(
- dbus::MethodCall* method_call) {
- // Read the parameters to the method.
- dbus::MessageReader reader(method_call);
- if (!reader.HasMoreData()) {
- return GetBadArgsError(method_call,
- "No parameters to FinishRegisterDevice");
- }
- std::string user_auth_code;
- if (!reader.PopString(&user_auth_code)) {
- return GetBadArgsError(method_call, "Failed to read UserAuthCode");
- }
- if (reader.HasMoreData()) {
- return GetBadArgsError(method_call,
- "Too many parameters to FinishRegisterDevice");
- }
-
+std::string Manager::HandleFinishRegisterDevice(
+ chromeos::ErrorPtr* error, const std::string& user_auth_code) {
LOG(INFO) << "Received call to Manager.FinishRegisterDevice()";
- chromeos::ErrorPtr error;
- if (!device_info_->FinishRegistration(user_auth_code, &error))
- return scoped_ptr<dbus::Response>(
- GetDBusError(method_call, error.get()).release());
+ if (!device_info_->FinishRegistration(user_auth_code, error))
+ return std::string();
- std::string device_id = device_info_->GetDeviceId(&error);
- if (device_id.empty())
- return scoped_ptr<dbus::Response>(
- GetDBusError(method_call, error.get()).release());
-
- // Send back our response.
- scoped_ptr<dbus::Response> response(
- dbus::Response::FromMethodCall(method_call));
- dbus::MessageWriter writer(response.get());
- writer.AppendString(device_id);
- return response.Pass();
+ return device_info_->GetDeviceId(error);
}
-scoped_ptr<dbus::Response> Manager::HandleUpdateState(
- dbus::MethodCall *method_call) {
- // Read the parameters to the method.
- dbus::MessageReader reader(method_call);
- if (!reader.HasMoreData()) {
- return GetBadArgsError(method_call, "No parameters to UpdateState");
- }
- std::string json_state_fragment;
- if (!reader.PopString(&json_state_fragment)) {
- return GetBadArgsError(method_call, "Failed to read json_state_fragment");
- }
- if (reader.HasMoreData()) {
- return GetBadArgsError(method_call, "Too many parameters to UpdateState");
- }
-
- LOG(INFO) << "Received call to Manager.UpdateState()";
+void Manager::HandleUpdateState(
+ chromeos::ErrorPtr* error, const std::string& json_state_fragment) {
// TODO(wiley): Merge json state blobs intelligently.
- properties_->state_.SetValue(json_state_fragment);
-
- // Send back our response.
- return dbus::Response::FromMethodCall(method_call);
+ state_.SetValue(json_state_fragment);
}
-scoped_ptr<dbus::Response> Manager::HandleTestMethod(
- dbus::MethodCall* method_call) {
- LOG(INFO) << "Received call to test method.";
- return scoped_ptr<dbus::Response>();
+void Manager::HandleTestMethod(chromeos::ErrorPtr* error) {
+ LOG(INFO) << "Received call to test method";
}
} // namespace buffet
