Make PacketReader/PacketWriter interfaces async-only.

blimp/net/stream_packet_writer_unittest.cc

Index: blimp/net/stream_packet_writer_unittest.cc
diff --git a/blimp/net/stream_packet_writer_unittest.cc b/blimp/net/stream_packet_writer_unittest.cc
index c8014f9481f8bcc3ddc3c3ec7220e5f89a7bb04d..564b9b91ea4f2e1bf8d89bd5c2cef28f04755a57 100644
--- a/blimp/net/stream_packet_writer_unittest.cc
+++ b/blimp/net/stream_packet_writer_unittest.cc
@@ -60,8 +60,7 @@ TEST_F(StreamPacketWriterTest, TestWriteAsync) {
   EXPECT_CALL(socket_, Write(BufferEquals(EncodeHeader(test_data_str_.size())),
                              kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(SaveArg<2>(&header_cb), Return(net::ERR_IO_PENDING)));
-  EXPECT_EQ(net::ERR_IO_PENDING,
-            message_writer_.WritePacket(test_data_, writer_cb.callback()));
+  message_writer_.WritePacket(test_data_, writer_cb.callback());
   Mock::VerifyAndClearExpectations(&socket_);
 
   // Write payload.
@@ -100,8 +99,7 @@ TEST_F(StreamPacketWriterTest, TestPartialWriteAsync) {
       .WillOnce(DoAll(SaveArg<2>(&payload_cb), Return(net::ERR_IO_PENDING)))
       .RetiresOnSaturation();
 
-  EXPECT_EQ(net::ERR_IO_PENDING,
-            message_writer_.WritePacket(test_data_, writer_cb.callback()));
+  message_writer_.WritePacket(test_data_, writer_cb.callback());
 
   // Header is written - first one byte, then the remainder.
   header_cb.Run(1);
@@ -127,8 +125,7 @@ TEST_F(StreamPacketWriterTest, TestWriteErrorAsync) {
               Write(BufferEquals(test_data_str_), test_data_str_.size(), _))
       .WillOnce(DoAll(SaveArg<2>(&payload_cb), Return(net::ERR_IO_PENDING)));
 
-  EXPECT_EQ(net::ERR_IO_PENDING,
-            message_writer_.WritePacket(test_data_, writer_cb.callback()));
+  message_writer_.WritePacket(test_data_, writer_cb.callback());
   header_cb.Run(kPacketHeaderSizeBytes);
   payload_cb.Run(net::ERR_CONNECTION_RESET);
 
@@ -144,9 +141,8 @@ TEST_F(StreamPacketWriterTest, TestWriteSync) {
   EXPECT_CALL(socket_,
               Write(BufferEquals(test_data_str_), test_data_str_.size(), _))
       .WillOnce(Return(test_data_str_.size()));
-  EXPECT_EQ(net::OK,
-            message_writer_.WritePacket(test_data_, writer_cb.callback()));
-  EXPECT_FALSE(writer_cb.have_result());
+  message_writer_.WritePacket(test_data_, writer_cb.callback());
+  EXPECT_EQ(net::OK, writer_cb.WaitForResult());
 }
 
 // Successful write with 2 sync header writes and 2 sync payload writes.
@@ -167,19 +163,18 @@ TEST_F(StreamPacketWriterTest, TestPartialWriteSync) {
                              payload.size() - 1, _))
       .WillOnce(Return(payload.size() - 1));
 
-  EXPECT_EQ(net::OK,
-            message_writer_.WritePacket(test_data_, writer_cb.callback()));
-  EXPECT_FALSE(writer_cb.have_result());
+  message_writer_.WritePacket(test_data_, writer_cb.callback());
+  EXPECT_EQ(net::OK, writer_cb.WaitForResult());
 }
 
 // Verify that zero-length packets are rejected.
 TEST_F(StreamPacketWriterTest, TestZeroLengthPacketsRejected) {
   net::TestCompletionCallback writer_cb;
 
-  EXPECT_EQ(net::ERR_INVALID_ARGUMENT,
-            message_writer_.WritePacket(
-                new net::DrainableIOBuffer(new net::IOBuffer(0), 0),
-                writer_cb.callback()));
+  message_writer_.WritePacket(
+      new net::DrainableIOBuffer(new net::IOBuffer(0), 0),
+      writer_cb.callback());
+  EXPECT_EQ(net::ERR_INVALID_ARGUMENT, writer_cb.WaitForResult());
 
   EXPECT_FALSE(writer_cb.have_result());
 }
@@ -192,8 +187,8 @@ TEST_F(StreamPacketWriterTest, TestWriteHeaderErrorSync) {
                              kPacketHeaderSizeBytes, _))
       .WillOnce(Return(net::ERR_FAILED));
 
-  EXPECT_EQ(net::ERR_FAILED,
-            message_writer_.WritePacket(test_data_, writer_cb.callback()));
+  message_writer_.WritePacket(test_data_, writer_cb.callback());
+  EXPECT_EQ(net::ERR_FAILED, writer_cb.WaitForResult());
 
   EXPECT_EQ(net::ERR_EMPTY_RESPONSE,
             writer_cb.GetResult(net::ERR_EMPTY_RESPONSE));
@@ -211,9 +206,8 @@ TEST_F(StreamPacketWriterTest, TestWritePayloadErrorSync) {
               Write(BufferEquals(test_data_str_), test_data_str_.size(), _))
       .WillOnce(Return(net::ERR_FAILED));
 
-  EXPECT_EQ(net::ERR_FAILED,
-            message_writer_.WritePacket(test_data_, writer_cb.callback()));
-  EXPECT_FALSE(writer_cb.have_result());
+  message_writer_.WritePacket(test_data_, writer_cb.callback());
+  EXPECT_EQ(net::ERR_FAILED, writer_cb.WaitForResult());
 }
 
 // Verify that asynchronous header write completions don't cause a
@@ -228,8 +222,7 @@ TEST_F(StreamPacketWriterTest, DeletedDuringHeaderWrite) {
   EXPECT_CALL(socket_, Write(BufferEquals(EncodeHeader(test_data_str_.size())),
                              kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(SaveArg<2>(&header_cb), Return(net::ERR_IO_PENDING)));
-  EXPECT_EQ(net::ERR_IO_PENDING,
-            writer->WritePacket(test_data_, writer_cb.callback()));
+  writer->WritePacket(test_data_, writer_cb.callback());
   Mock::VerifyAndClearExpectations(&socket_);
 
   // Header write completion callback is invoked after the writer died.
@@ -252,8 +245,7 @@ TEST_F(StreamPacketWriterTest, DeletedDuringPayloadWrite) {
               Write(BufferEquals(test_data_str_), test_data_str_.size(), _))
       .WillOnce(DoAll(SaveArg<2>(&payload_cb), Return(net::ERR_IO_PENDING)));
 
-  EXPECT_EQ(net::ERR_IO_PENDING,
-            writer->WritePacket(test_data_, writer_cb.callback()));
+  writer->WritePacket(test_data_, writer_cb.callback());
 
   // Header write completes successfully.
   header_cb.Run(kPacketHeaderSizeBytes);