Make PacketReader/PacketWriter interfaces async-only.

blimp/net/stream_packet_writer.cc

Index: blimp/net/stream_packet_writer.cc
diff --git a/blimp/net/stream_packet_writer.cc b/blimp/net/stream_packet_writer.cc
index 221cdd170e7fa87eb5b0f31742de8e8b9591f4f8..4674f4d65ea5cafe9dc673456eb43ba157fd63ba 100644
--- a/blimp/net/stream_packet_writer.cc
+++ b/blimp/net/stream_packet_writer.cc
@@ -47,14 +47,16 @@ StreamPacketWriter::StreamPacketWriter(net::StreamSocket* socket)
 
 StreamPacketWriter::~StreamPacketWriter() {}
 
-int StreamPacketWriter::WritePacket(scoped_refptr<net::DrainableIOBuffer> data,
-                                    const net::CompletionCallback& callback) {
+void StreamPacketWriter::WritePacket(scoped_refptr<net::DrainableIOBuffer> data,
+                                     const net::CompletionCallback& callback) {
   DCHECK_EQ(WriteState::IDLE, write_state_);
   DCHECK(data);
   if (data->BytesRemaining() == 0) {
     // The packet is empty; your argument is invalid.
     DLOG(ERROR) << "Attempted to write zero-length packet.";
-    return net::ERR_INVALID_ARGUMENT;
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, net::ERR_INVALID_ARGUMENT));
+    return;

[Wez, 2015/11/24 23:43:18]

If we're mandating no zero-sized packets then writing them indicates something
went badly wrong; I'd be fine with a CHECK(data->BytesRemaining()) so that we
crash rather than send out a zero-byte payload - we'll crash if |data| is NULL,
for example, just later on, in a release build.

[Kevin M, 2015/11/25 01:18:37]

Done.

   }
 
   write_state_ = WriteState::HEADER;
@@ -63,18 +65,18 @@ int StreamPacketWriter::WritePacket(scoped_refptr<net::DrainableIOBuffer> data,
       base::HostToNet32(data->BytesRemaining());
   payload_buffer_ = data;
 
-  int result = DoWriteLoop(false);
-  if (result == net::ERR_IO_PENDING) {
-    // Store the completion callback to invoke when DoWriteLoop completes
-    // asynchronously.
-    callback_ = callback;
-  } else {
+  int result = DoWriteLoop(net::OK);
+  if (result != net::ERR_IO_PENDING) {
     // Release the payload buffer, since the write operation has completed
     // synchronously.
     payload_buffer_ = nullptr;
-  }
 
-  return result;
+    // Adapt synchronous completion to an asynchronous style.
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(callback, result));
+  } else {
+    callback_ = callback;
+  }
 }
 
 int StreamPacketWriter::DoWriteLoop(int result) {