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_;