Land Recent QUIC changes.

net/quic/quic_connection_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.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/crypto/null_encrypter.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_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 217 matching lines @@
     return random_generator_;
   }
 
   virtual int WritePacketToWire(const QuicEncryptedPacket& packet,
                                 int* error) OVERRIDE {
     if (packet.length() >= sizeof(final_bytes_of_last_packet_)) {
       memcpy(&final_bytes_of_last_packet_, packet.data() + packet.length() - 4,
              sizeof(final_bytes_of_last_packet_));
     }
 
-    QuicFramer framer(kQuicVersion1, QuicTime::Zero(), is_server_);
+    QuicFramer framer(QuicVersionMax(), QuicTime::Zero(), is_server_);
     if (use_tagging_decrypter_) {
       framer.SetDecrypter(new TaggingDecrypter);
     }
     FramerVisitorCapturingFrames visitor;
     framer.set_visitor(&visitor);
     EXPECT_TRUE(framer.ProcessPacket(packet));
     header_ = *visitor.header();
     frame_count_ = visitor.frame_count();
     if (visitor.ack()) {
       ack_.reset(new QuicAckFrame(*visitor.ack()));
@@ skipping 109 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectionHelper);
 };
 
 class TestConnection : public QuicConnection {
  public:
   TestConnection(QuicGuid guid,
                  IPEndPoint address,
                  TestConnectionHelper* helper,
                  bool is_server)
-      : QuicConnection(guid, address, helper, is_server),
+      : QuicConnection(guid, address, helper, is_server, QuicVersionMax()),
         helper_(helper) {
     helper_->set_is_server(!is_server);
   }
 
   void SendAck() {
     QuicConnectionPeer::SendAck(this);
   }
 
   void SetReceiveAlgorithm(TestReceiveAlgorithm* receive_algorithm) {
      QuicConnectionPeer::SetReceiveAlgorithm(this, receive_algorithm);
   }
 
   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
     QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
   }
 
   QuicConsumedData SendStreamData1() {
     return SendStreamData(1u, "food", 0, !kFin);
   }
 
   QuicConsumedData SendStreamData2() {
     return SendStreamData(2u, "food2", 0, !kFin);
   }
 
   bool is_server() {
     return QuicConnectionPeer::IsServer(this);
   }
 
+  void set_version(QuicVersion version) {
+    framer_.set_version(version);
+  }
+
   void set_is_server(bool is_server) {
     helper_->set_is_server(!is_server);
     QuicPacketCreatorPeer::SetIsServer(
         QuicConnectionPeer::GetPacketCreator(this), is_server);
     QuicConnectionPeer::SetIsServer(this, is_server);
   }
 
   using QuicConnection::SendOrQueuePacket;
   using QuicConnection::DontWaitForPacketsBefore;
+  using QuicConnection::SelectMutualVersion;
 
  private:
   TestConnectionHelper* helper_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnection);
 };
 
 class QuicConnectionTest : public ::testing::Test {
  protected:
   QuicConnectionTest()
       : guid_(42),
-        framer_(kQuicVersion1, QuicTime::Zero(), false),
+        framer_(QuicVersionMax(), QuicTime::Zero(), false),
         creator_(guid_, &framer_, QuicRandom::GetInstance(), false),
         send_algorithm_(new StrictMock<MockSendAlgorithm>),
         helper_(new TestConnectionHelper(&clock_, &random_generator_)),
         connection_(guid_, IPEndPoint(), helper_, false),
         frame1_(1, false, 0, data1),
         frame2_(1, false, 3, data2),
         accept_packet_(true) {
     connection_.set_visitor(&visitor_);
     connection_.SetSendAlgorithm(send_algorithm_);
     // Simplify tests by not sending feedback unless specifically configured.
     SetFeedback(NULL);
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillRepeatedly(Return(
         QuicTime::Delta::Zero()));
     EXPECT_CALL(*receive_algorithm_,
                 RecordIncomingPacket(_, _, _, _)).Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
+        Return(QuicTime::Delta::Zero()));
   }
 
   QuicAckFrame* outgoing_ack() {
     return QuicConnectionPeer::GetOutgoingAck(&connection_);
   }
 
   QuicAckFrame* last_ack() {
     return helper_->ack();
   }
 
@@ skipping 357 matching lines @@
 
   frame.received_info.missing_packets.erase(191);
   frame.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 192) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 190);
 
   ProcessAckPacket(&frame, true);
   EXPECT_FALSE(QuicConnectionPeer::GetReceivedTruncatedAck(&connection_));
 }
 
+TEST_F(QuicConnectionTest, DISABLED_AckReceiptCausesAckSend) {
+  ProcessPacket(1);
+  // Delay sending, then queue up an ack.
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+                  testing::Return(QuicTime::Delta::FromMicroseconds(1)));
+  QuicConnectionPeer::SendAck(&connection_);
+
+  // Process an ack with a least unacked of the received ack.
+  // This causes an ack to be sent when TimeUntilSend returns 0.
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
+                  testing::Return(QuicTime::Delta::Zero()));
+  // Skip a packet and then record an ack.
+  creator_.set_sequence_number(2);
+  QuicAckFrame frame(0, QuicTime::Zero(), 3);
+  ProcessAckPacket(&frame, true);
+}
+
 TEST_F(QuicConnectionTest, LeastUnackedLower) {
   SendStreamDataToPeer(1, "foo", 0, !kFin, NULL);
   SendStreamDataToPeer(1, "bar", 3, !kFin, NULL);
   SendStreamDataToPeer(1, "eep", 6, !kFin, NULL);
 
   // Start out saying the least unacked is 2
   creator_.set_sequence_number(5);
   QuicAckFrame frame(0, QuicTime::Zero(), 2);
   ProcessAckPacket(&frame, true);
 
@@ skipping 1250 matching lines @@
 
     entropy_hash ^= packet_entropy_hash;
   }
   EXPECT_TRUE(QuicConnectionPeer::IsValidEntropy(
       &connection_, max_sequence_number, missing_packets, entropy_hash))
       << "";
 }
 
 // TODO(satyamsehkhar): Add more test when we start supporting more versions.
 TEST_F(QuicConnectionTest, SendVersionNegotiationPacket) {
-  QuicTag kRandomVersion = 143;
-  QuicFramerPeer::SetVersion(&framer_, kRandomVersion);
+  // TODO(rjshade): Update this to use a real version once we have multiple
+  //                versions in the codebase.
+  framer_.set_version_for_tests(QUIC_VERSION_UNSUPPORTED);
 
   QuicPacketHeader header;
   header.public_header.guid = guid_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = true;
   header.entropy_flag = false;
   header.fec_flag = false;
   header.packet_sequence_number = 12;
   header.fec_group = 0;
 
   QuicFrames frames;
   QuicFrame frame(&frame1_);
   frames.push_back(frame);
   scoped_ptr<QuicPacket> packet(
       framer_.ConstructFrameDataPacket(header, frames).packet);
   scoped_ptr<QuicEncryptedPacket> encrypted(
       framer_.EncryptPacket(ENCRYPTION_NONE, 12, *packet));
 
-  QuicFramerPeer::SetVersion(&framer_, kQuicVersion1);
+  framer_.set_version(QuicVersionMax());
   connection_.set_is_server(true);
   connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
   EXPECT_TRUE(helper_->version_negotiation_packet() != NULL);
-  EXPECT_EQ(1u,
+
+  size_t num_versions = arraysize(kSupportedQuicVersions);
+  EXPECT_EQ(num_versions,
             helper_->version_negotiation_packet()->versions.size());
-  EXPECT_EQ(kQuicVersion1,
-            helper_->version_negotiation_packet()->versions[0]);
+
+  // We expect all versions in kSupportedQuicVersions to be
+  // included in the packet.
+  for (size_t i = 0; i < num_versions; ++i) {
+    EXPECT_EQ(kSupportedQuicVersions[i],
+              helper_->version_negotiation_packet()->versions[i]);
+  }
 }
 
 TEST_F(QuicConnectionTest, CheckSendStats) {
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(_, _)).Times(3);
   EXPECT_CALL(*send_algorithm_,
               SentPacket(_, _, _, NOT_RETRANSMISSION));
   connection_.SendStreamData(1u, "first", 0, !kFin);
   size_t first_packet_size = last_sent_packet_size();
 
   EXPECT_CALL(*send_algorithm_,
@@ skipping 110 matching lines @@
   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(
       ENCRYPTION_NONE, 1, *packet));
 
   EXPECT_CALL(visitor_, OnCanWrite()).Times(1).WillOnce(Return(true));
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_PEER_GOING_AWAY, true));
   EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(0);
 
   connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
 }
 
+//// The QUIC_VERSION_X versions are deliberately set, rather than using all
+//// values in kSupportedQuicVersions.
+//TEST_F(QuicConnectionTest, SelectMutualVersion) {
+//  // Set the connection to speak QUIC_VERSION_6.
+//  connection_.set_version(QUIC_VERSION_6);
+//  EXPECT_EQ(connection_.version(), QUIC_VERSION_6);
+//
+//  // Pass in available versions which includes a higher mutually supported
+//  // version.  The higher mutually supported version should be selected.
+//  EXPECT_TRUE(
+//      connection_.SelectMutualVersion({QUIC_VERSION_6, QUIC_VERSION_7}));
+//  EXPECT_EQ(connection_.version(), QUIC_VERSION_7);
+//
+//  // Expect that the lower version is selected.
+//  EXPECT_TRUE(connection_.SelectMutualVersion({QUIC_VERSION_6}));
+//  EXPECT_EQ(connection_.version(), QUIC_VERSION_6);
+//
+//  // Shouldn't be able to find a mutually supported version.
+//  EXPECT_FALSE(connection_.SelectMutualVersion({QUIC_VERSION_UNSUPPORTED}));
+//}
+
 }  // namespace
 }  // namespace test
 }  // namespace net