Make PacketReader/PacketWriter interfaces async-only.

blimp/net/blimp_message_pump_unittest.cc

Index: blimp/net/blimp_message_pump_unittest.cc
diff --git a/blimp/net/blimp_message_pump_unittest.cc b/blimp/net/blimp_message_pump_unittest.cc
index ec7987e6f64df2c0c8d6fb1509559b92b76b1a06..19ac1092dfa7ec960092f100d4988bae79af82ca 100644
--- a/blimp/net/blimp_message_pump_unittest.cc
+++ b/blimp/net/blimp_message_pump_unittest.cc
@@ -49,60 +49,33 @@ class BlimpMessagePumpTest : public testing::Test {
   scoped_ptr<BlimpMessagePump> message_pump_;
 };
 
-// Reader completes reading one packet synchronously.
-TEST_F(BlimpMessagePumpTest, SyncPacketRead) {
-  EXPECT_CALL(receiver_, MockableProcessMessage(EqualsProto(*message1_), _));
-  EXPECT_CALL(reader_, ReadPacket(NotNull(), _))
-      .WillOnce(DoAll(FillBufferFromMessage<0>(message1_.get()),
-                      Return(message1_->ByteSize())));
-  message_pump_->SetMessageProcessor(&receiver_);
-}
-
-// Reader completes reading two packets synchronously.
-TEST_F(BlimpMessagePumpTest, SyncTwoPacketsRead) {
-  EXPECT_CALL(reader_, ReadPacket(NotNull(), _))
-      .WillOnce(DoAll(FillBufferFromMessage<0>(message1_.get()),
-                      Return(message1_->ByteSize())))
-      .WillOnce(DoAll(FillBufferFromMessage<0>(message2_.get()),
-                      Return(message2_->ByteSize())));
-  net::CompletionCallback process_msg_cb;
-  {
-    InSequence s;
-    EXPECT_CALL(receiver_, MockableProcessMessage(EqualsProto(*message1_), _))
-        .WillOnce(SaveArg<1>(&process_msg_cb))
-        .RetiresOnSaturation();
-    EXPECT_CALL(receiver_, MockableProcessMessage(EqualsProto(*message2_), _));
-  }
-  message_pump_->SetMessageProcessor(&receiver_);
-
-  // Trigger next packet read
-  process_msg_cb.Run(net::OK);
-}
-
 // Reader completes reading one packet asynchronously.
-TEST_F(BlimpMessagePumpTest, AsyncPacketRead) {
+TEST_F(BlimpMessagePumpTest, ReadPacket) {
   net::CompletionCallback read_packet_cb;
+  EXPECT_CALL(reader_, ReadPacket(NotNull(), _));
   EXPECT_CALL(reader_, ReadPacket(NotNull(), _))
       .WillOnce(DoAll(FillBufferFromMessage<0>(message1_.get()),
-                      SaveArg<1>(&read_packet_cb), Return(net::ERR_IO_PENDING)))
-      .WillOnce(Return(net::ERR_IO_PENDING));
+                      SetBufferOffset<0>(message1_->ByteSize()),
+                      SaveArg<1>(&read_packet_cb)))
+      .RetiresOnSaturation();
   net::CompletionCallback process_msg_cb;
   EXPECT_CALL(receiver_, MockableProcessMessage(EqualsProto(*message1_), _))
       .WillOnce(SaveArg<1>(&process_msg_cb));
   message_pump_->SetMessageProcessor(&receiver_);
-  read_packet_cb.Run(message1_->ByteSize());
+  read_packet_cb.Run(net::OK);
   process_msg_cb.Run(net::OK);
 }
 
 // Reader completes reading two packets asynchronously.
-TEST_F(BlimpMessagePumpTest, AsyncTwoPacketsRead) {
+TEST_F(BlimpMessagePumpTest, ReadTwoPackets) {
   net::CompletionCallback read_packet_cb;
   EXPECT_CALL(reader_, ReadPacket(NotNull(), _))
       .WillOnce(DoAll(FillBufferFromMessage<0>(message1_.get()),
-                      SaveArg<1>(&read_packet_cb), Return(net::ERR_IO_PENDING)))
+                      SetBufferOffset<0>(message1_->ByteSize()),
+                      SaveArg<1>(&read_packet_cb)))
       .WillOnce(DoAll(FillBufferFromMessage<0>(message2_.get()),
-                      SaveArg<1>(&read_packet_cb),
-                      Return(net::ERR_IO_PENDING)));
+                      SetBufferOffset<0>(message2_->ByteSize()),
+                      SaveArg<1>(&read_packet_cb)));
   net::CompletionCallback process_msg_cb;
   {
     InSequence s;
@@ -112,32 +85,31 @@ TEST_F(BlimpMessagePumpTest, AsyncTwoPacketsRead) {
     EXPECT_CALL(receiver_, MockableProcessMessage(EqualsProto(*message2_), _));
   }
   message_pump_->SetMessageProcessor(&receiver_);
-  read_packet_cb.Run(message1_->ByteSize());
+  read_packet_cb.Run(net::OK);
 
   // Trigger next packet read
   process_msg_cb.Run(net::OK);
-  read_packet_cb.Run(message2_->ByteSize());
+  read_packet_cb.Run(net::OK);
 }
 
 // Reader completes reading two packets asynchronously.
 // The first read succeeds, and the second fails.
-TEST_F(BlimpMessagePumpTest, AsyncTwoPacketsReadWithError) {
+TEST_F(BlimpMessagePumpTest, ReadTwoPacketsWithError) {
+  net::CompletionCallback process_msg_cb;
   net::CompletionCallback read_packet_cb;
   EXPECT_CALL(reader_, ReadPacket(NotNull(), _))
       .WillOnce(DoAll(FillBufferFromMessage<0>(message1_.get()),
-                      SaveArg<1>(&read_packet_cb), Return(net::ERR_IO_PENDING)))
+                      SetBufferOffset<0>(message1_->ByteSize()),
+                      SaveArg<1>(&read_packet_cb)))
       .WillOnce(DoAll(FillBufferFromMessage<0>(message2_.get()),
-                      SaveArg<1>(&read_packet_cb),
-                      Return(net::ERR_IO_PENDING)));
-  net::CompletionCallback process_msg_cb;
-  {
-    InSequence s;
-    EXPECT_CALL(receiver_, MockableProcessMessage(EqualsProto(*message1_), _))
-        .WillOnce(SaveArg<1>(&process_msg_cb));
-    EXPECT_CALL(error_observer_, OnConnectionError(net::ERR_FAILED));
-  }
+                      SetBufferOffset<0>(message2_->ByteSize()),
+                      SaveArg<1>(&read_packet_cb)));
+  EXPECT_CALL(receiver_, MockableProcessMessage(EqualsProto(*message1_), _))
+      .WillOnce(SaveArg<1>(&process_msg_cb));
+  EXPECT_CALL(error_observer_, OnConnectionError(net::ERR_FAILED));
+
   message_pump_->SetMessageProcessor(&receiver_);
-  read_packet_cb.Run(message1_->ByteSize());
+  read_packet_cb.Run(net::OK);
 
   // Trigger next packet read
   process_msg_cb.Run(net::OK);
@@ -146,11 +118,16 @@ TEST_F(BlimpMessagePumpTest, AsyncTwoPacketsReadWithError) {
 
 // Reader completes reading one packet synchronously, but packet is invalid
 TEST_F(BlimpMessagePumpTest, InvalidPacket) {
+  net::CompletionCallback read_packet_cb;
   std::string test_msg("msg");
   EXPECT_CALL(reader_, ReadPacket(NotNull(), _))
-      .WillOnce(DoAll(FillBufferFromString<0>(test_msg), Return(1)));
+      .WillOnce(DoAll(FillBufferFromString<0>(test_msg),
+                      SetBufferOffset<0>(test_msg.size()),
+                      SaveArg<1>(&read_packet_cb)));
   EXPECT_CALL(error_observer_, OnConnectionError(net::ERR_FAILED));
+
   message_pump_->SetMessageProcessor(&receiver_);
+  read_packet_cb.Run(net::OK);
 }
 
 }  // namespace