Land Recent QUIC changes.

net/quic/quic_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/quic/quic_connection_helper.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/test_task_runner.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace net {
 namespace test {
 
 const char kData[] = "foo";
-const bool kHasData = true;
+const bool kFromPeer = true;
 
 class TestConnection : public QuicConnection {
  public:
   TestConnection(QuicGuid guid,
                  IPEndPoint address,
                  QuicConnectionHelper* helper)
       : QuicConnection(guid, address, helper, false) {
   }
 
   void SendAck() {
@@ skipping 284 matching lines @@
             clock_.ApproximateNow().Subtract(start));
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicConnectionHelperTest, InitialTimeout) {
   AddWrite(SYNCHRONOUS, ConstructClosePacket(1, 0));
   Initialize();
 
   // Verify that a single task was posted.
   ASSERT_EQ(1u, runner_->GetPostedTasks().size());
-  EXPECT_EQ(base::TimeDelta::FromMicroseconds(kDefaultTimeoutUs),
+  EXPECT_EQ(base::TimeDelta::FromSeconds(kDefaultInitialTimeoutSecs),
             runner_->GetPostedTasks().front().delay);
 
   EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
   // After we run the next task, we should close the connection.
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, false));
 
   runner_->RunNextTask();
-  EXPECT_EQ(QuicTime::Zero().Add(
-                QuicTime::Delta::FromMicroseconds(kDefaultTimeoutUs)),
+  EXPECT_EQ(QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(
+                kDefaultInitialTimeoutSecs)),
             clock_.ApproximateNow());
   EXPECT_FALSE(connection_->connected());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicConnectionHelperTest, WritePacketToWire) {
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1));
   Initialize();
 
   int len = GetWrite(0)->length();
@@ skipping 16 matching lines @@
 }
 
 TEST_F(QuicConnectionHelperTest, TimeoutAfterSend) {
   AddWrite(SYNCHRONOUS, ConstructAckPacket(1));
   AddWrite(SYNCHRONOUS, ConstructClosePacket(2, 1));
   Initialize();
 
   EXPECT_TRUE(connection_->connected());
   QuicTime start = clock_.ApproximateNow();
 
-  // When we send a packet, the timeout will change to 5000 + kDefaultTimeout.
+  // When we send a packet, the timeout will change to 5000 +
+  // kDefaultInitialTimeoutSecs.
   clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(5000));
   EXPECT_EQ(5000u, clock_.ApproximateNow().Subtract(start).ToMicroseconds());
   EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, NOT_RETRANSMISSION));
 
   // Send an ack so we don't set the retransmission alarm.
   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.
   runner_->RunNextTask();
 
-  EXPECT_EQ(QuicTime::Zero().Add(
-                QuicTime::Delta::FromMicroseconds(kDefaultTimeoutUs)),
+  EXPECT_EQ(QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(
+                kDefaultInitialTimeoutSecs)),
             clock_.ApproximateNow());
   EXPECT_TRUE(connection_->connected());
 
   // This time, we should time out.
-  EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, false));
+  EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, !kFromPeer));
   EXPECT_CALL(*send_algorithm_, SentPacket(_, 2, _, NOT_RETRANSMISSION));
   runner_->RunNextTask();
-  EXPECT_EQ(kDefaultTimeoutUs + 5000, clock_.ApproximateNow().Subtract(
-      QuicTime::Zero()).ToMicroseconds());
+  EXPECT_EQ(kDefaultInitialTimeoutSecs * 1000000 + 5000,
+            clock_.ApproximateNow().Subtract(
+                QuicTime::Zero()).ToMicroseconds());
   EXPECT_FALSE(connection_->connected());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicConnectionHelperTest, SendSchedulerDelayThenSend) {
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1));
   Initialize();
 
   // Test that if we send a packet with a delay, it ends up queued.
   EXPECT_CALL(
@@ skipping 12 matching lines @@
       *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
           testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(testing::Return(true));
   runner_->RunNextTask();
   EXPECT_EQ(0u, connection_->NumQueuedPackets());
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 }  // namespace net