Pull new version of libweave and update weaved's implementation

libweave had some interface clean-up work done, so reflecting the
current state of library in Brillo.

Change-Id: I987ed3721df917fe59f623a8e00110e2ede4f72f

7 files changed, 62 insertions, 71 deletions

diff --git a/buffet/avahi_mdns_client.h b/buffet/avahi_mdns_client.h
index 7784218..2488dd4 100644
--- a/buffet/avahi_mdns_client.h
+++ b/buffet/avahi_mdns_client.h
@@ -22,7 +22,7 @@
 
 #include <base/memory/weak_ptr.h>
 #include <dbus/bus.h>
-#include <weave/mdns.h>
+#include <weave/dns_service_discovery_provider.h>
 
 #include "buffet/mdns_client.h"
 
@@ -34,7 +34,7 @@ class AvahiMdnsClient : public MdnsClient {
   explicit AvahiMdnsClient(const scoped_refptr<dbus::Bus>& bus);
   ~AvahiMdnsClient() override;
 
-  // weave::Mdns implementation.
+  // weave::DnsServiceDiscoveryProvider implementation.
   void PublishService(const std::string& service_type, uint16_t port,
                       const std::vector<std::string>& txt) override;
   void StopPublishing(const std::string& service_type) override;
diff --git a/buffet/brillo_network_client.cc b/buffet/brillo_network_client.cc
index 5c2cb08..c467418 100644
--- a/buffet/brillo_network_client.cc
+++ b/buffet/brillo_network_client.cc
@@ -36,16 +36,15 @@ BrilloNetworkClient::BrilloNetworkClient(
 BrilloNetworkClient::~BrilloNetworkClient() {
 }
 
-void BrilloNetworkClient::AddOnConnectionChangedCallback(
-    const OnConnectionChangedCallback& listener) {
+void BrilloNetworkClient::AddConnectionChangedCallback(
+    const ConnectionChangedCallback& listener) {
   connection_listeners_.push_back(listener);
 }
 
-void BrilloNetworkClient::ConnectToService(
-    const std::string& ssid,
-    const std::string& passphrase,
-    const base::Closure& on_success,
-    const base::Callback<void(const weave::Error*)>& on_error) {
+void BrilloNetworkClient::Connect(const std::string& ssid,
+                                  const std::string& passphrase,
+                                  const weave::SuccessCallback& on_success,
+                                  const weave::ErrorCallback& on_error) {
   if (!connectivity_client_.ConnectToAccessPoint(ssid, passphrase)) {
     weave::ErrorPtr error;
     weave::Error::AddTo(&error, FROM_HERE, kErrorDomain, "network_failure",
@@ -73,12 +72,12 @@ weave::NetworkState BrilloNetworkClient::GetConnectionState() const {
   return state_;
 }
 
-void BrilloNetworkClient::EnableAccessPoint(const std::string& ssid) {
+void BrilloNetworkClient::StartAccessPoint(const std::string& ssid) {
   connectivity_client_.EnableAccessPoint(ssid);
   state_ = weave::NetworkState::kOffline;
 }
 
-void BrilloNetworkClient::DisableAccessPoint() {
+void BrilloNetworkClient::StopAccessPoint() {
   connectivity_client_.DisableAccessPoint();
 }
 
diff --git a/buffet/brillo_network_client.h b/buffet/brillo_network_client.h
index 6e6de80..f05bd97 100644
--- a/buffet/brillo_network_client.h
+++ b/buffet/brillo_network_client.h
@@ -21,7 +21,7 @@
 #include <vector>
 
 #include <base/cancelable_callback.h>
-#include <weave/network.h>
+#include <weave/network_provider.h>
 
 #include "connectivity_client.h"
 
@@ -35,16 +35,16 @@ class BrilloNetworkClient : public NetworkClient {
   ~BrilloNetworkClient() override;
 
   // Implements the Network interface.
-  void AddOnConnectionChangedCallback(
-      const OnConnectionChangedCallback& listener) override;
-  void ConnectToService(
+  void AddConnectionChangedCallback(
+      const ConnectionChangedCallback& listener) override;
+  void Connect(
       const std::string& ssid,
       const std::string& passphrase,
-      const base::Closure& on_success,
+      const weave::SuccessCallback& on_success,
       const base::Callback<void(const weave::Error*)>& on_error) override;
   weave::NetworkState GetConnectionState() const override;
-  void EnableAccessPoint(const std::string& ssid) override;
-  void DisableAccessPoint() override;
+  void StartAccessPoint(const std::string& ssid) override;
+  void StopAccessPoint() override;
 
  private:
   enum class ConnectionState {
@@ -58,7 +58,7 @@ class BrilloNetworkClient : public NetworkClient {
   void UpdateConnectionState();
 
   ConnectivityClient connectivity_client_;
-  std::vector<OnConnectionChangedCallback> connection_listeners_;
+  std::vector<ConnectionChangedCallback> connection_listeners_;
   base::CancelableClosure connection_timeout_closure_;
   base::CancelableClosure periodic_connection_state_closure_;
   base::Closure connection_success_closure_;
diff --git a/buffet/mdns_client.h b/buffet/mdns_client.h
index 374deba..3743b79 100644
--- a/buffet/mdns_client.h
+++ b/buffet/mdns_client.h
@@ -24,12 +24,12 @@
 #include <base/guid.h>
 #include <base/memory/ref_counted.h>
 #include <dbus/bus.h>
-#include <weave/mdns.h>
+#include <weave/dns_service_discovery_provider.h>
 
 namespace buffet {
 
 // Stub MDNS implementation that does nothing on platform without MDNS support.
-class MdnsClient : public weave::Mdns {
+class MdnsClient : public weave::DnsServiceDiscoveryProvider {
  public:
   MdnsClient() : device_id_{base::GenerateGUID()} {}
   ~MdnsClient() override = default;
diff --git a/buffet/network_client.h b/buffet/network_client.h
index 9901fc8..81d1e77 100644
--- a/buffet/network_client.h
+++ b/buffet/network_client.h
@@ -23,15 +23,16 @@
 
 #include <base/cancelable_callback.h>
 #include <chromeos/errors/error_codes.h>
-#include <weave/network.h>
-#include <weave/wifi.h>
+#include <weave/network_provider.h>
+#include <weave/wifi_provider.h>
 
 #include "buffet/socket_stream.h"
 #include "buffet/weave_error_conversion.h"
 
 namespace buffet {
 
-class NetworkClient : public weave::Network, public weave::Wifi {
+class NetworkClient : public weave::NetworkProvider,
+                      public weave::WifiProvider {
  public:
   explicit NetworkClient(const std::set<std::string>& device_whitelist)
       : device_whitelist_{device_whitelist} {
@@ -39,33 +40,19 @@ class NetworkClient : public weave::Network, public weave::Wifi {
 
   ~NetworkClient() override = default;
 
-  // Implements the Network interface.
-  void AddOnConnectionChangedCallback(
-      const OnConnectionChangedCallback& listener) override {
-  }
-
-  void ConnectToService(
-      const std::string& ssid,
-      const std::string& passphrase,
-      const base::Closure& on_success,
-      const base::Callback<void(const weave::Error*)>& on_error) override {
-  }
+  // NetworkProvider implementation.
+  void AddConnectionChangedCallback(
+      const ConnectionChangedCallback& listener) override {}
 
   weave::NetworkState GetConnectionState() const override {
     return weave::NetworkState::kOffline;
   }
 
-  void EnableAccessPoint(const std::string& ssid) override {
-  }
-
-  void DisableAccessPoint() override {
-  }
-
   void OpenSslSocket(
       const std::string& host,
       uint16_t port,
       const base::Callback<void(std::unique_ptr<weave::Stream>)>& on_success,
-      const base::Callback<void(const weave::Error*)>& on_error) override {
+      const weave::ErrorCallback& on_error) override {
     auto socket = SocketStream::ConnectBlocking(host, port);
     if (socket) {
       SocketStream::TlsConnect(std::move(socket), host, on_success, on_error);
@@ -78,6 +65,16 @@ class NetworkClient : public weave::Network, public weave::Wifi {
     on_error.Run(weave_error.get());
   }
 
+  // WifiProvider implementation.
+  void Connect(const std::string& ssid,
+               const std::string& passphrase,
+               const weave::SuccessCallback& on_success,
+               const weave::ErrorCallback& on_error) override {}
+
+  void StartAccessPoint(const std::string& ssid) override {}
+
+  void StopAccessPoint() override {}
+
   static std::unique_ptr<NetworkClient> CreateInstance(
       const std::set<std::string>& device_whitelist);
 
diff --git a/buffet/socket_stream.cc b/buffet/socket_stream.cc
index 9ce56bf..8ee9c60 100644
--- a/buffet/socket_stream.cc
+++ b/buffet/socket_stream.cc
@@ -69,11 +69,10 @@ void OnError(const base::Callback<void(const weave::Error*)>& error_callback,
 
 }  // namespace
 
-void SocketStream::ReadAsync(
-    void* buffer,
-    size_t size_to_read,
-    const base::Callback<void(size_t)>& success_callback,
-    const base::Callback<void(const weave::Error*)>& error_callback) {
+void SocketStream::Read(void* buffer,
+                        size_t size_to_read,
+                        const ReadSuccessCallback& success_callback,
+                        const weave::ErrorCallback& error_callback) {
   chromeos::ErrorPtr chromeos_error;
   if (!ptr_->ReadAsync(buffer, size_to_read, success_callback,
                        base::Bind(&OnError, error_callback), &chromeos_error)) {
@@ -84,11 +83,10 @@ void SocketStream::ReadAsync(
   }
 }
 
-void SocketStream::WriteAllAsync(
-    const void* buffer,
-    size_t size_to_write,
-    const base::Closure& success_callback,
-    const base::Callback<void(const weave::Error*)>& error_callback) {
+void SocketStream::Write(const void* buffer,
+                         size_t size_to_write,
+                         const weave::SuccessCallback& success_callback,
+                         const weave::ErrorCallback& error_callback) {
   chromeos::ErrorPtr chromeos_error;
   if (!ptr_->WriteAllAsync(buffer, size_to_write, success_callback,
                            base::Bind(&OnError, error_callback),
@@ -100,7 +98,7 @@ void SocketStream::WriteAllAsync(
   }
 }
 
-void SocketStream::CancelPendingAsyncOperations() {
+void SocketStream::CancelPendingOperations() {
   ptr_->CancelPendingAsyncOperations();
 }
 
@@ -124,7 +122,7 @@ void SocketStream::TlsConnect(
     std::unique_ptr<Stream> socket,
     const std::string& host,
     const base::Callback<void(std::unique_ptr<Stream>)>& success_callback,
-    const base::Callback<void(const weave::Error*)>& error_callback) {
+    const weave::ErrorCallback& error_callback) {
   SocketStream* stream = static_cast<SocketStream*>(socket.get());
   chromeos::TlsStream::Connect(std::move(stream->ptr_), host,
                                base::Bind(&OnSuccess, success_callback),
diff --git a/buffet/socket_stream.h b/buffet/socket_stream.h
index 757190c..968acb9 100644
--- a/buffet/socket_stream.h
+++ b/buffet/socket_stream.h
@@ -20,29 +20,26 @@ class SocketStream : public weave::Stream {
 
   ~SocketStream() override = default;
 
-  void ReadAsync(
-      void* buffer,
-      size_t size_to_read,
-      const base::Callback<void(size_t)>& success_callback,
-      const base::Callback<void(const weave::Error*)>& error_callback) override;
+  void Read(void* buffer,
+            size_t size_to_read,
+            const ReadSuccessCallback& success_callback,
+            const weave::ErrorCallback& error_callback) override;
 
-  void WriteAllAsync(
-      const void* buffer,
-      size_t size_to_write,
-      const base::Closure& success_callback,
-      const base::Callback<void(const weave::Error*)>& error_callback) override;
+  void Write(const void* buffer,
+             size_t size_to_write,
+             const weave::SuccessCallback& success_callback,
+             const weave::ErrorCallback& error_callback) override;
 
-  void CancelPendingAsyncOperations() 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 base::Callback<void(const weave::Error*)>& error_callback);
+  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);
 
  private:
   chromeos::StreamPtr ptr_;