Land Recent QUIC changes.

net/tools/quic/quic_epoll_connection_helper_test.cc

Index: net/tools/quic/quic_epoll_connection_helper_test.cc
diff --git a/net/tools/quic/quic_epoll_connection_helper_test.cc b/net/tools/quic/quic_epoll_connection_helper_test.cc
index 6d6ea13d015a98e9fe17c12857aff03d595ce7fb..9f0321a00a8243800be91171db06ffca7fe52ca7 100644
--- a/net/tools/quic/quic_epoll_connection_helper_test.cc
+++ b/net/tools/quic/quic_epoll_connection_helper_test.cc
@@ -91,6 +91,8 @@ class QuicEpollConnectionHelperTest : public ::testing::Test {
         QuicBandwidth::FromKBitsPerSecond(100)));
     EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(Return(
         QuicTime::Delta::FromMilliseconds(100)));
+    ON_CALL(*send_algorithm_, SentPacket(_, _, _, _, _))
+        .WillByDefault(Return(true));
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketSequenceNumber number,
@@ -136,12 +138,14 @@ TEST_F(QuicEpollConnectionHelperTest, DISABLED_TestRetransmission) {
       arraysize(buffer) - 1;
 
   EXPECT_CALL(*send_algorithm_,
-              SentPacket(_, 1, packet_size, NOT_RETRANSMISSION));
+              SentPacket(_, 1, packet_size, NOT_RETRANSMISSION, _));
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(1, packet_size));
-  connection_.SendStreamData(1, buffer, 0, false);
+  struct iovec iov = {const_cast<char*>(buffer),
+                      static_cast<size_t>(3)};
+  connection_.SendvStreamData(1, &iov, 1, 0, false);
   EXPECT_EQ(1u, helper_->header()->packet_sequence_number);
   EXPECT_CALL(*send_algorithm_,
-              SentPacket(_, 2, packet_size, IS_RETRANSMISSION));
+              SentPacket(_, 2, packet_size, IS_RETRANSMISSION, _));
   epoll_server_.AdvanceByAndCallCallbacks(kDefaultRetransmissionTimeMs * 1000);
 
   EXPECT_EQ(2u, helper_->header()->packet_sequence_number);
@@ -150,7 +154,7 @@ TEST_F(QuicEpollConnectionHelperTest, DISABLED_TestRetransmission) {
 TEST_F(QuicEpollConnectionHelperTest, InitialTimeout) {
   EXPECT_TRUE(connection_.connected());
 
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION, _));
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
   epoll_server_.WaitForEventsAndExecuteCallbacks();
   EXPECT_FALSE(connection_.connected());
@@ -167,7 +171,8 @@ TEST_F(QuicEpollConnectionHelperTest, TimeoutAfterSend) {
   EXPECT_EQ(5000, epoll_server_.NowInUsec());
 
   // Send an ack so we don't set the retransmission alarm.
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_,
+              SentPacket(_, 1, _, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
   connection_.SendAck();
 
   // The original alarm will fire.  We should not time out because we had a
@@ -177,7 +182,8 @@ TEST_F(QuicEpollConnectionHelperTest, TimeoutAfterSend) {
 
   // This time, we should time out.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_,
+              SentPacket(_, 2, _, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
   epoll_server_.WaitForEventsAndExecuteCallbacks();
   EXPECT_EQ(kDefaultInitialTimeoutSecs * 1000000 + 5000,
             epoll_server_.NowInUsec());
@@ -191,17 +197,19 @@ TEST_F(QuicEpollConnectionHelperTest, SendSchedulerDelayThenSend) {
   QuicPacket* packet = ConstructDataPacket(1, 0);
   EXPECT_CALL(
       *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
-          testing::Return(QuicTime::Delta::FromMicroseconds(1)));
+          Return(QuicTime::Delta::FromMicroseconds(1)));
   connection_.SendOrQueuePacket(ENCRYPTION_NONE, 1, packet, 0,
                                 HAS_RETRANSMITTABLE_DATA);
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION,
+                                           _));
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
-  EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).
-      WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
-  EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(testing::Return(true));
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
+      Return(QuicTime::Delta::Zero()));
+  EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(Return(true));
   epoll_server_.AdvanceByAndCallCallbacks(1);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }