Land Recent QUIC changes.

net/tools/quic/quic_epoll_connection_helper_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_random.h"
+#include "net/quic/quic_connection.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/tools/quic/test_tools/mock_epoll_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::FramerVisitorCapturingFrames;
 using net::test::MockSendAlgorithm;
 using net::test::QuicConnectionPeer;
 using net::test::MockConnectionVisitor;
 using net::tools::test::MockEpollServer;
 using testing::_;
+using testing::AnyNumber;
 using testing::Return;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
 const char data1[] = "foo";
 const bool kFromPeer = true;
 
@@ skipping 113 matching lines @@
   EXPECT_CALL(*send_algorithm_,
               SentPacket(_, 2, packet_size, IS_RETRANSMISSION, _));
   epoll_server_.AdvanceByAndCallCallbacks(kDefaultRetransmissionTimeMs * 1000);
 
   EXPECT_EQ(2u, helper_->header()->packet_sequence_number);
 }
 
 TEST_F(QuicEpollConnectionHelperTest, InitialTimeout) {
   EXPECT_TRUE(connection_.connected());
 
-  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION, _));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION,
+                                           HAS_RETRANSMITTABLE_DATA));
+  EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillOnce(
+      Return(QuicTime::Delta::FromMicroseconds(1)));
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
   epoll_server_.WaitForEventsAndExecuteCallbacks();
   EXPECT_FALSE(connection_.connected());
   EXPECT_EQ(kDefaultInitialTimeoutSecs * 1000000, epoll_server_.NowInUsec());
 }
 
 TEST_F(QuicEpollConnectionHelperTest, TimeoutAfterSend) {
   EXPECT_TRUE(connection_.connected());
   EXPECT_EQ(0, epoll_server_.NowInUsec());
 
   // When we send a packet, the timeout will change to 5000 +
   // kDefaultInitialTimeoutSecs.
   epoll_server_.AdvanceBy(5000);
   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, NO_RETRANSMITTABLE_DATA));
   connection_.SendAck();
 
   // The original alarm will fire.  We should not time out because we had a
   // network event at t=5000.  The alarm will reregister.
   epoll_server_.WaitForEventsAndExecuteCallbacks();
   EXPECT_EQ(kDefaultInitialTimeoutSecs * 1000000, epoll_server_.NowInUsec());
 
   // This time, we should time out.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
-  EXPECT_CALL(*send_algorithm_,
-              SentPacket(_, 2, _, NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
+  EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, NOT_RETRANSMISSION,
+                                           HAS_RETRANSMITTABLE_DATA));
+  EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillOnce(
+      Return(QuicTime::Delta::FromMicroseconds(1)));
   epoll_server_.WaitForEventsAndExecuteCallbacks();
   EXPECT_EQ(kDefaultInitialTimeoutSecs * 1000000 + 5000,
             epoll_server_.NowInUsec());
   EXPECT_FALSE(connection_.connected());
 }
 
 TEST_F(QuicEpollConnectionHelperTest, SendSchedulerDelayThenSend) {
   // Test that if we send a packet with a delay, it ends up queued.
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
       Return(QuicTime::Delta::Zero()));
   QuicPacket* packet = ConstructDataPacket(1, 0);
   EXPECT_CALL(
       *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
           Return(QuicTime::Delta::FromMicroseconds(1)));
   connection_.SendOrQueuePacket(ENCRYPTION_NONE, 1, packet, 0,
-                                HAS_RETRANSMITTABLE_DATA);
+                                HAS_RETRANSMITTABLE_DATA,
+                                QuicConnection::NO_FORCE);
   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(
       Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(Return(true));
+  EXPECT_CALL(visitor_, HasPendingHandshake()).Times(AnyNumber());
   epoll_server_.AdvanceByAndCallCallbacks(1);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net