weaved: Uprev libweave and fix public interfaces
libweave includes these two new commits now:
- 11956f74 Added version field to state and migrate from unversioned data
- c37cbb8b Use single callback for replies to async operations
Change-Id: I67f67c735b538c2a4dc161464ac7796c4d114ca6
diff --git a/buffet/http_transport_client.cc b/buffet/http_transport_client.cc
index 75e2a33..c869517 100644
--- a/buffet/http_transport_client.cc
+++ b/buffet/http_transport_client.cc
@@ -44,18 +44,20 @@
DISALLOW_COPY_AND_ASSIGN(ResponseImpl);
};
-void OnSuccessCallback(const HttpClient::SuccessCallback& success_callback,
+void OnSuccessCallback(const HttpClient::SendRequestCallback& callback,
int id,
std::unique_ptr<brillo::http::Response> response) {
- success_callback.Run(ResponseImpl{std::move(response)});
+ callback.Run(std::unique_ptr<HttpClient::Response>{new ResponseImpl{
+ std::move(response)}},
+ nullptr);
}
-void OnErrorCallback(const weave::ErrorCallback& error_callback,
+void OnErrorCallback(const HttpClient::SendRequestCallback& callback,
int id,
- const brillo::Error* chromeos_error) {
+ const brillo::Error* brillo_error) {
weave::ErrorPtr error;
- ConvertError(*chromeos_error, &error);
- error_callback.Run(std::move(error));
+ ConvertError(*brillo_error, &error);
+ callback.Run(nullptr, std::move(error));
}
} // anonymous namespace
@@ -68,13 +70,11 @@
HttpTransportClient::~HttpTransportClient() {}
-void HttpTransportClient::SendRequest(
- Method method,
- const std::string& url,
- const Headers& headers,
- const std::string& data,
- const SuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) {
+void HttpTransportClient::SendRequest(Method method,
+ const std::string& url,
+ const Headers& headers,
+ const std::string& data,
+ const SendRequestCallback& callback) {
brillo::http::Request request(url, weave::EnumToString(method), transport_);
request.AddHeaders(headers);
if (!data.empty()) {
@@ -85,12 +85,12 @@
weave::ErrorPtr error;
ConvertError(*cromeos_error, &error);
transport_->RunCallbackAsync(
- FROM_HERE, base::Bind(error_callback, base::Passed(&error)));
+ FROM_HERE, base::Bind(callback, nullptr, base::Passed(&error)));
return;
}
}
- request.GetResponse(base::Bind(&OnSuccessCallback, success_callback),
- base::Bind(&OnErrorCallback, error_callback));
+ request.GetResponse(base::Bind(&OnSuccessCallback, callback),
+ base::Bind(&OnErrorCallback, callback));
}
} // namespace buffet
diff --git a/buffet/http_transport_client.h b/buffet/http_transport_client.h
index 17e20d9..a81910c 100644
--- a/buffet/http_transport_client.h
+++ b/buffet/http_transport_client.h
@@ -28,8 +28,7 @@
const std::string& url,
const Headers& headers,
const std::string& data,
- const SuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) override;
+ const SendRequestCallback& callback) override;
private:
std::shared_ptr<brillo::http::Transport> transport_;
diff --git a/buffet/manager.cc b/buffet/manager.cc
index 423a393..37cebe5 100644
--- a/buffet/manager.cc
+++ b/buffet/manager.cc
@@ -122,21 +122,6 @@
}
}
-void RegisterDeviceSuccess(
- const std::shared_ptr<DBusMethodResponse<std::string>>& response,
- weave::Device* device) {
- LOG(INFO) << "Device registered: " << device->GetSettings().cloud_id;
- response->Return(device->GetSettings().cloud_id);
-}
-
-void RegisterDeviceError(
- const std::shared_ptr<DBusMethodResponse<std::string>>& response,
- weave::ErrorPtr weave_error) {
- brillo::ErrorPtr error;
- ConvertError(*weave_error, &error);
- response->ReplyWithError(error.get());
-}
-
} // anonymous namespace
class Manager::TaskRunner : public weave::provider::TaskRunner {
@@ -248,26 +233,34 @@
const std::string& ticket_id) {
LOG(INFO) << "Received call to Manager.RegisterDevice()";
- std::shared_ptr<DBusMethodResponse<std::string>> shared_response =
- std::move(response);
+ device_->Register(ticket_id, base::Bind(&Manager::RegisterDeviceDone,
+ weak_ptr_factory_.GetWeakPtr(),
+ base::Passed(&response)));
+}
- device_->Register(ticket_id, base::Bind(&RegisterDeviceSuccess,
- shared_response, device_.get()),
- base::Bind(&RegisterDeviceError, shared_response));
+void Manager::RegisterDeviceDone(DBusMethodResponsePtr<std::string> response,
+ weave::ErrorPtr error) {
+ if (error) {
+ brillo::ErrorPtr brillo_error;
+ ConvertError(*error, &brillo_error);
+ return response->ReplyWithError(brillo_error.get());
+ }
+ LOG(INFO) << "Device registered: " << device_->GetSettings().cloud_id;
+ response->Return(device_->GetSettings().cloud_id);
}
void Manager::UpdateState(DBusMethodResponsePtr<> response,
const brillo::VariantDictionary& property_set) {
- brillo::ErrorPtr chromeos_error;
+ brillo::ErrorPtr brillo_error;
auto properties =
- DictionaryFromDBusVariantDictionary(property_set, &chromeos_error);
+ DictionaryFromDBusVariantDictionary(property_set, &brillo_error);
if (!properties)
- return response->ReplyWithError(chromeos_error.get());
+ return response->ReplyWithError(brillo_error.get());
weave::ErrorPtr error;
if (!device_->SetStateProperties(*properties, &error)) {
- ConvertError(*error, &chromeos_error);
- return response->ReplyWithError(chromeos_error.get());
+ ConvertError(*error, &brillo_error);
+ return response->ReplyWithError(brillo_error.get());
}
response->Return();
}
@@ -297,9 +290,9 @@
std::string id;
weave::ErrorPtr error;
if (!device_->AddCommand(*command, &id, &error)) {
- brillo::ErrorPtr chromeos_error;
- ConvertError(*error, &chromeos_error);
- return response->ReplyWithError(chromeos_error.get());
+ brillo::ErrorPtr brillo_error;
+ ConvertError(*error, &brillo_error);
+ return response->ReplyWithError(brillo_error.get());
}
response->Return(id);
diff --git a/buffet/manager.h b/buffet/manager.h
index 2a2b634..2dc06e8 100644
--- a/buffet/manager.h
+++ b/buffet/manager.h
@@ -95,6 +95,9 @@
const std::vector<uint8_t>& code);
void OnPairingEnd(const std::string& session_id);
+ void RegisterDeviceDone(DBusMethodResponsePtr<std::string> response,
+ weave::ErrorPtr error);
+
Options options_;
com::android::Weave::ManagerAdaptor dbus_adaptor_{this};
diff --git a/buffet/shill_client.cc b/buffet/shill_client.cc
index 7f67304..add3036 100644
--- a/buffet/shill_client.cc
+++ b/buffet/shill_client.cc
@@ -10,6 +10,7 @@
#include <base/stl_util.h>
#include <brillo/any.h>
#include <brillo/errors/error.h>
+#include <brillo/variant_dictionary.h>
#include <dbus/shill/dbus-constants.h>
#include <weave/enum_to_string.h>
@@ -126,14 +127,13 @@
void ShillClient::Connect(const string& ssid,
const string& passphrase,
- const weave::SuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) {
+ const weave::DoneCallback& callback) {
if (connecting_service_) {
weave::ErrorPtr error;
weave::Error::AddTo(&error, FROM_HERE, kErrorDomain, "busy",
"Already connecting to WiFi network");
base::MessageLoop::current()->PostTask(
- FROM_HERE, base::Bind(error_callback, base::Passed(&error)));
+ FROM_HERE, base::Bind(callback, base::Passed(&error)));
return;
}
CleanupConnectingService();
@@ -149,21 +149,19 @@
service_properties[shill::kSaveCredentialsProperty] = Any{true};
service_properties[shill::kAutoConnectProperty] = Any{true};
ObjectPath service_path;
- brillo::ErrorPtr chromeos_error;
+ brillo::ErrorPtr brillo_error;
if (!manager_proxy_.ConfigureService(service_properties, &service_path,
- &chromeos_error) ||
- !manager_proxy_.RequestScan(shill::kTypeWifi, &chromeos_error)) {
+ &brillo_error) ||
+ !manager_proxy_.RequestScan(shill::kTypeWifi, &brillo_error)) {
weave::ErrorPtr weave_error;
- ConvertError(*chromeos_error, &weave_error);
+ ConvertError(*brillo_error, &weave_error);
base::MessageLoop::current()->PostTask(
- FROM_HERE,
- base::Bind(error_callback, base::Passed(&weave_error)));
+ FROM_HERE, base::Bind(callback, base::Passed(&weave_error)));
return;
}
connecting_service_.reset(new ServiceProxy{bus_, service_path});
connecting_service_->Connect(nullptr);
- connect_success_callback_ = success_callback;
- connect_error_callback_ = error_callback;
+ connect_done_callback_ = callback;
connecting_service_->RegisterPropertyChangedSignalHandler(
base::Bind(&ShillClient::OnServicePropertyChange,
weak_factory_.GetWeakPtr(), service_path),
@@ -178,7 +176,7 @@
void ShillClient::ConnectToServiceError(
std::shared_ptr<org::chromium::flimflam::ServiceProxy> connecting_service) {
if (connecting_service != connecting_service_ ||
- connect_error_callback_.is_null()) {
+ connect_done_callback_.is_null()) {
return;
}
std::string error = have_called_connect_ ? connecting_service_error_
@@ -452,11 +450,12 @@
void ShillClient::OnStateChangeForConnectingService(const string& state) {
switch (ShillServiceStateToNetworkState(state)) {
case Network::State::kOnline: {
- auto callback = connect_success_callback_;
+ auto callback = connect_done_callback_;
+ connect_done_callback_.Reset();
CleanupConnectingService();
if (!callback.is_null())
- callback.Run();
+ callback.Run(nullptr);
break;
}
case Network::State::kError: {
@@ -473,7 +472,7 @@
if (error.empty())
return;
- auto callback = connect_error_callback_;
+ auto callback = connect_done_callback_;
CleanupConnectingService();
weave::ErrorPtr weave_error;
@@ -551,16 +550,13 @@
connecting_service_->ReleaseObjectProxy(base::Bind(&IgnoreDetachEvent));
connecting_service_.reset();
}
- connect_success_callback_.Reset();
- connect_error_callback_.Reset();
+ connect_done_callback_.Reset();
have_called_connect_ = false;
}
-void ShillClient::OpenSslSocket(
- const std::string& host,
- uint16_t port,
- const OpenSslSocketSuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) {
+void ShillClient::OpenSslSocket(const std::string& host,
+ uint16_t port,
+ const OpenSslSocketCallback& callback) {
if (disable_xmpp_)
return;
std::unique_ptr<weave::Stream> raw_stream{
@@ -571,13 +567,11 @@
weave::ErrorPtr weave_error;
ConvertError(*error.get(), &weave_error);
base::MessageLoop::current()->PostTask(
- FROM_HERE,
- base::Bind(error_callback, base::Passed(&weave_error)));
+ FROM_HERE, base::Bind(callback, nullptr, base::Passed(&weave_error)));
return;
}
- SocketStream::TlsConnect(std::move(raw_stream), host, success_callback,
- error_callback);
+ SocketStream::TlsConnect(std::move(raw_stream), host, callback);
}
} // namespace buffet
diff --git a/buffet/shill_client.h b/buffet/shill_client.h
index 9cf5b4f..bca5f34 100644
--- a/buffet/shill_client.h
+++ b/buffet/shill_client.h
@@ -40,14 +40,12 @@
State GetConnectionState() const override;
void OpenSslSocket(const std::string& host,
uint16_t port,
- const OpenSslSocketSuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) override;
+ const OpenSslSocketCallback& callback) override;
// WifiProvider implementation.
void Connect(const std::string& ssid,
const std::string& passphrase,
- const weave::SuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) override;
+ const weave::DoneCallback& callback) override;
void StartAccessPoint(const std::string& ssid) override;
void StopAccessPoint() override;
@@ -111,8 +109,7 @@
bool have_called_connect_{false};
std::shared_ptr<org::chromium::flimflam::ServiceProxy> connecting_service_;
std::string connecting_service_error_;
- base::Closure connect_success_callback_;
- weave::ErrorCallback connect_error_callback_;
+ weave::DoneCallback connect_done_callback_;
// State for tracking our online connectivity.
std::map<dbus::ObjectPath, DeviceState> devices_;
diff --git a/buffet/socket_stream.cc b/buffet/socket_stream.cc
index e7588f1..f6bef88 100644
--- a/buffet/socket_stream.cc
+++ b/buffet/socket_stream.cc
@@ -11,9 +11,11 @@
#include <unistd.h>
#include <base/bind.h>
+#include <base/bind_helpers.h>
#include <base/files/file_util.h>
#include <base/message_loop/message_loop.h>
#include <base/strings/stringprintf.h>
+#include <brillo/bind_lambda.h>
#include <brillo/streams/file_stream.h>
#include <brillo/streams/tls_stream.h>
@@ -22,6 +24,8 @@
namespace buffet {
+using weave::provider::Network;
+
namespace {
std::string GetIPAddress(const sockaddr* sa) {
@@ -78,48 +82,49 @@
return socket_fd;
}
-void OnSuccess(const base::Callback<void(std::unique_ptr<weave::Stream>)>&
- success_callback,
+void OnSuccess(const Network::OpenSslSocketCallback& callback,
brillo::StreamPtr tls_stream) {
- success_callback.Run(
- std::unique_ptr<weave::Stream>{new SocketStream{std::move(tls_stream)}});
+ callback.Run(
+ std::unique_ptr<weave::Stream>{new SocketStream{std::move(tls_stream)}},
+ nullptr);
}
-void OnError(const base::Callback<void(weave::ErrorPtr)>& error_callback,
- const brillo::Error* chromeos_error) {
+void OnError(const weave::DoneCallback& callback,
+ const brillo::Error* brillo_error) {
weave::ErrorPtr error;
- ConvertError(*chromeos_error, &error);
- error_callback.Run(std::move(error));
+ ConvertError(*brillo_error, &error);
+ callback.Run(std::move(error));
}
} // namespace
void SocketStream::Read(void* buffer,
size_t size_to_read,
- const ReadSuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) {
- brillo::ErrorPtr chromeos_error;
- if (!ptr_->ReadAsync(buffer, size_to_read, success_callback,
- base::Bind(&OnError, error_callback), &chromeos_error)) {
+ const ReadCallback& callback) {
+ brillo::ErrorPtr brillo_error;
+ if (!ptr_->ReadAsync(
+ buffer, size_to_read,
+ base::Bind([](const ReadCallback& callback,
+ size_t size) { callback.Run(size, nullptr); },
+ callback),
+ base::Bind(&OnError, base::Bind(callback, 0)), &brillo_error)) {
weave::ErrorPtr error;
- ConvertError(*chromeos_error, &error);
+ ConvertError(*brillo_error, &error);
base::MessageLoop::current()->PostTask(
- FROM_HERE, base::Bind(error_callback, base::Passed(&error)));
+ FROM_HERE, base::Bind(callback, 0, base::Passed(&error)));
}
}
void SocketStream::Write(const void* buffer,
size_t size_to_write,
- const weave::SuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) {
- brillo::ErrorPtr chromeos_error;
- if (!ptr_->WriteAllAsync(buffer, size_to_write, success_callback,
- base::Bind(&OnError, error_callback),
- &chromeos_error)) {
+ const WriteCallback& callback) {
+ brillo::ErrorPtr brillo_error;
+ if (!ptr_->WriteAllAsync(buffer, size_to_write, base::Bind(callback, nullptr),
+ base::Bind(&OnError, callback), &brillo_error)) {
weave::ErrorPtr error;
- ConvertError(*chromeos_error, &error);
+ ConvertError(*brillo_error, &error);
base::MessageLoop::current()->PostTask(
- FROM_HERE, base::Bind(error_callback, base::Passed(&error)));
+ FROM_HERE, base::Bind(callback, base::Passed(&error)));
}
}
@@ -134,8 +139,7 @@
if (socket_fd <= 0)
return nullptr;
- auto ptr_ =
- brillo::FileStream::FromFileDescriptor(socket_fd, true, nullptr);
+ auto ptr_ = brillo::FileStream::FromFileDescriptor(socket_fd, true, nullptr);
if (ptr_)
return std::unique_ptr<Stream>{new SocketStream{std::move(ptr_)}};
@@ -143,15 +147,13 @@
return nullptr;
}
-void SocketStream::TlsConnect(
- std::unique_ptr<Stream> socket,
- const std::string& host,
- const base::Callback<void(std::unique_ptr<Stream>)>& success_callback,
- const weave::ErrorCallback& error_callback) {
+void SocketStream::TlsConnect(std::unique_ptr<Stream> socket,
+ const std::string& host,
+ const Network::OpenSslSocketCallback& callback) {
SocketStream* stream = static_cast<SocketStream*>(socket.get());
- brillo::TlsStream::Connect(std::move(stream->ptr_), host,
- base::Bind(&OnSuccess, success_callback),
- base::Bind(&OnError, error_callback));
+ brillo::TlsStream::Connect(
+ std::move(stream->ptr_), host, base::Bind(&OnSuccess, callback),
+ base::Bind(&OnError, base::Bind(callback, nullptr)));
}
} // namespace buffet
diff --git a/buffet/socket_stream.h b/buffet/socket_stream.h
index 9ad4b84..aef8b99 100644
--- a/buffet/socket_stream.h
+++ b/buffet/socket_stream.h
@@ -10,6 +10,7 @@
#include <base/callback.h>
#include <base/macros.h>
#include <brillo/streams/stream.h>
+#include <weave/provider/network.h>
#include <weave/stream.h>
namespace buffet {
@@ -22,24 +23,21 @@
void Read(void* buffer,
size_t size_to_read,
- const ReadSuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) override;
+ const ReadCallback& callback) override;
void Write(const void* buffer,
size_t size_to_write,
- const weave::SuccessCallback& success_callback,
- const weave::ErrorCallback& error_callback) override;
+ const WriteCallback& callback) override;
void CancelPendingOperations() override;
static std::unique_ptr<weave::Stream> ConnectBlocking(const std::string& host,
uint16_t port);
- static void TlsConnect(std::unique_ptr<weave::Stream> socket,
- const std::string& host,
- const base::Callback<void(
- std::unique_ptr<weave::Stream>)>& success_callback,
- const weave::ErrorCallback& error_callback);
+ static void TlsConnect(
+ std::unique_ptr<weave::Stream> socket,
+ const std::string& host,
+ const weave::provider::Network::OpenSslSocketCallback& callback);
private:
brillo::StreamPtr ptr_;