diff --git a/libweave/examples/ubuntu/network_manager.cc b/libweave/examples/ubuntu/network_manager.cc
index ab1d521..2d77309 100644
--- a/libweave/examples/ubuntu/network_manager.cc
+++ b/libweave/examples/ubuntu/network_manager.cc
@@ -49,11 +49,10 @@
     success_callback.Run();
   }
 
-  bool ReadAsync(void* buffer,
+  void ReadAsync(void* buffer,
                  size_t size_to_read,
                  const base::Callback<void(size_t)>& success_callback,
-                 const base::Callback<void(const Error*)>& error_callback,
-                 ErrorPtr* error) {
+                 const base::Callback<void(const Error*)>& error_callback) {
     int res = SSL_read(ssl_.get(), buffer, size_to_read);
     if (res > 0) {
       task_runner_->PostDelayedTask(
@@ -61,7 +60,7 @@
           base::Bind(&SSLStream::RunDelayedTask, weak_ptr_factory_.GetWeakPtr(),
                      base::Bind(success_callback, res)),
           {});
-      return true;
+      return;
     }
 
     int err = SSL_get_error(ssl_.get(), res);
@@ -69,11 +68,10 @@
     if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
       task_runner_->PostDelayedTask(
           FROM_HERE,
-          base::Bind(base::IgnoreResult(&SSLStream::ReadAsync),
-                     weak_ptr_factory_.GetWeakPtr(), buffer, size_to_read,
-                     success_callback, error_callback, nullptr),
+          base::Bind(&SSLStream::ReadAsync, weak_ptr_factory_.GetWeakPtr(),
+                     buffer, size_to_read, success_callback, error_callback),
           base::TimeDelta::FromSeconds(1));
-      return true;
+      return;
     }
 
     ErrorPtr weave_error;
@@ -85,14 +83,13 @@
             &SSLStream::RunDelayedTask, weak_ptr_factory_.GetWeakPtr(),
             base::Bind(error_callback, base::Owned(weave_error.release()))),
         {});
-    return true;
+    return;
   }
 
-  bool WriteAllAsync(const void* buffer,
+  void WriteAllAsync(const void* buffer,
                      size_t size_to_write,
                      const base::Closure& success_callback,
-                     const base::Callback<void(const Error*)>& error_callback,
-                     ErrorPtr* error) {
+                     const base::Callback<void(const Error*)>& error_callback) {
     int res = SSL_write(ssl_.get(), buffer, size_to_write);
     if (res > 0) {
       buffer = static_cast<const char*>(buffer) + res;
@@ -103,17 +100,16 @@
             base::Bind(&SSLStream::RunDelayedTask,
                        weak_ptr_factory_.GetWeakPtr(), success_callback),
             {});
-        return true;
+        return;
       }
 
       task_runner_->PostDelayedTask(
           FROM_HERE,
-          base::Bind(base::IgnoreResult(&SSLStream::WriteAllAsync),
-                     weak_ptr_factory_.GetWeakPtr(), buffer, size_to_write,
-                     success_callback, error_callback, nullptr),
+          base::Bind(&SSLStream::WriteAllAsync, weak_ptr_factory_.GetWeakPtr(),
+                     buffer, size_to_write, success_callback, error_callback),
           base::TimeDelta::FromSeconds(1));
 
-      return true;
+      return;
     }
 
     int err = SSL_get_error(ssl_.get(), res);
@@ -121,11 +117,10 @@
     if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
       task_runner_->PostDelayedTask(
           FROM_HERE,
-          base::Bind(base::IgnoreResult(&SSLStream::WriteAllAsync),
-                     weak_ptr_factory_.GetWeakPtr(), buffer, size_to_write,
-                     success_callback, error_callback, nullptr),
+          base::Bind(&SSLStream::WriteAllAsync, weak_ptr_factory_.GetWeakPtr(),
+                     buffer, size_to_write, success_callback, error_callback),
           base::TimeDelta::FromSeconds(1));
-      return true;
+      return;
     }
 
     ErrorPtr weave_error;
@@ -137,7 +132,7 @@
             &SSLStream::RunDelayedTask, weak_ptr_factory_.GetWeakPtr(),
             base::Bind(error_callback, base::Owned(weave_error.release()))),
         {});
-    return true;
+    return;
   }
 
   void CancelPendingAsyncOperations() {
diff --git a/libweave/include/weave/stream.h b/libweave/include/weave/stream.h
index 9d4e657..0fcd747 100644
--- a/libweave/include/weave/stream.h
+++ b/libweave/include/weave/stream.h
@@ -16,19 +16,17 @@
  public:
   virtual ~Stream() = default;
 
-  virtual bool ReadAsync(
+  virtual void ReadAsync(
       void* buffer,
       size_t size_to_read,
       const base::Callback<void(size_t)>& success_callback,
-      const base::Callback<void(const Error*)>& error_callback,
-      ErrorPtr* error) = 0;
+      const base::Callback<void(const Error*)>& error_callback) = 0;
 
-  virtual bool WriteAllAsync(
+  virtual void WriteAllAsync(
       const void* buffer,
       size_t size_to_write,
       const base::Closure& success_callback,
-      const base::Callback<void(const Error*)>& error_callback,
-      ErrorPtr* error) = 0;
+      const base::Callback<void(const Error*)>& error_callback) = 0;
 
   virtual void CancelPendingAsyncOperations() = 0;
 };
diff --git a/libweave/src/notification/xmpp_channel.cc b/libweave/src/notification/xmpp_channel.cc
index 04c398d..ce0c001 100644
--- a/libweave/src/notification/xmpp_channel.cc
+++ b/libweave/src/notification/xmpp_channel.cc
@@ -321,18 +321,13 @@
   }
   write_socket_data_ = queued_write_data_ + message;
   queued_write_data_.clear();
-  ErrorPtr error;
   VLOG(2) << "Sending XMPP message: " << message;
 
   write_pending_ = true;
-  bool ok = stream_->WriteAllAsync(
+  stream_->WriteAllAsync(
       write_socket_data_.data(), write_socket_data_.size(),
       base::Bind(&XmppChannel::OnMessageSent, task_ptr_factory_.GetWeakPtr()),
-      base::Bind(&XmppChannel::OnWriteError, task_ptr_factory_.GetWeakPtr()),
-      &error);
-
-  if (!ok)
-    OnWriteError(error.get());
+      base::Bind(&XmppChannel::OnWriteError, task_ptr_factory_.GetWeakPtr()));
 }
 
 void XmppChannel::OnMessageSent() {
@@ -349,16 +344,11 @@
   if (read_pending_ || !stream_)
     return;
 
-  ErrorPtr error;
   read_pending_ = true;
-  bool ok = stream_->ReadAsync(
+  stream_->ReadAsync(
       read_socket_data_.data(), read_socket_data_.size(),
       base::Bind(&XmppChannel::OnMessageRead, task_ptr_factory_.GetWeakPtr()),
-      base::Bind(&XmppChannel::OnReadError, task_ptr_factory_.GetWeakPtr()),
-      &error);
-
-  if (!ok)
-    OnReadError(error.get());
+      base::Bind(&XmppChannel::OnReadError, task_ptr_factory_.GetWeakPtr()));
 }
 
 void XmppChannel::OnReadError(const Error* error) {
diff --git a/libweave/src/notification/xmpp_channel_unittest.cc b/libweave/src/notification/xmpp_channel_unittest.cc
index aaa0f28..fb5669f 100644
--- a/libweave/src/notification/xmpp_channel_unittest.cc
+++ b/libweave/src/notification/xmpp_channel_unittest.cc
@@ -93,32 +93,31 @@
     read_data_ += data;
   }
 
-  bool ReadAsync(void* buffer,
-                 size_t size_to_read,
-                 const base::Callback<void(size_t)>& success_callback,
-                 const base::Callback<void(const Error*)>& error_callback,
-                 ErrorPtr* error) override {
+  void ReadAsync(
+      void* buffer,
+      size_t size_to_read,
+      const base::Callback<void(size_t)>& success_callback,
+      const base::Callback<void(const Error*)>& error_callback) override {
     if (read_data_.empty()) {
       task_runner_->PostDelayedTask(
-          FROM_HERE, base::Bind(base::IgnoreResult(&FakeStream::ReadAsync),
-                                base::Unretained(this), buffer, size_to_read,
-                                success_callback, error_callback, nullptr),
+          FROM_HERE,
+          base::Bind(&FakeStream::ReadAsync, base::Unretained(this), buffer,
+                     size_to_read, success_callback, error_callback),
           base::TimeDelta::FromSeconds(0));
-      return true;
+      return;
     }
     size_t size = std::min(size_to_read, read_data_.size());
     memcpy(buffer, read_data_.data(), size);
     read_data_ = read_data_.substr(size);
     task_runner_->PostDelayedTask(FROM_HERE, base::Bind(success_callback, size),
                                   base::TimeDelta::FromSeconds(0));
-    return true;
   }
 
-  bool WriteAllAsync(const void* buffer,
-                     size_t size_to_write,
-                     const base::Closure& success_callback,
-                     const base::Callback<void(const Error*)>& error_callback,
-                     ErrorPtr* error) override {
+  void WriteAllAsync(
+      const void* buffer,
+      size_t size_to_write,
+      const base::Closure& success_callback,
+      const base::Callback<void(const Error*)>& error_callback) override {
     size_t size = std::min(size_to_write, write_data_.size());
     EXPECT_EQ(
         write_data_.substr(0, size),
@@ -126,7 +125,6 @@
     write_data_ = write_data_.substr(size);
     task_runner_->PostDelayedTask(FROM_HERE, success_callback,
                                   base::TimeDelta::FromSeconds(0));
-    return true;
   }
 
  private: