Land Recent QUIC Changes

net/quic/test_tools/quic_test_utils.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/test_tools/quic_test_utils.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/crypto_utils.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/quic_packet_creator.h"
 
 using std::max;
 using std::min;
 using std::string;
 using testing::_;
 
 namespace net {
 namespace test {
 
 MockFramerVisitor::MockFramerVisitor() {
   // By default, we want to accept packets.
+  ON_CALL(*this, OnProtocolVersionMismatch(_))
+      .WillByDefault(testing::Return(false));
+
+  // By default, we want to accept packets.
   ON_CALL(*this, OnPacketHeader(_))
       .WillByDefault(testing::Return(true));
 }
 
 MockFramerVisitor::~MockFramerVisitor() {
 }
 
+bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersionTag version) {
+  return false;
+}
+
 bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
   return true;
 }
 
 FramerVisitorCapturingFrames::FramerVisitorCapturingFrames() : frame_count_(0) {
 }
 
 FramerVisitorCapturingFrames::~FramerVisitorCapturingFrames() {
 }
 
@@ skipping 32 matching lines @@
     const QuicConnectionCloseFrame& frame) {
   close_.reset(new QuicConnectionCloseFrame(frame));
   ++frame_count_;
 }
 
 void FramerVisitorCapturingFrames::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
   goaway_.reset(new QuicGoAwayFrame(frame));
   ++frame_count_;
 }
 
+void FramerVisitorCapturingFrames::OnVersionNegotiationPacket(
+    const QuicVersionNegotiationPacket& packet) {
+  version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
+  frame_count_ = 0;
+}
+
 FramerVisitorCapturingPublicReset::FramerVisitorCapturingPublicReset() {
 }
 
 FramerVisitorCapturingPublicReset::~FramerVisitorCapturingPublicReset() {
 }
 
 void FramerVisitorCapturingPublicReset::OnPublicResetPacket(
     const QuicPublicResetPacket& public_reset) {
   public_reset_packet_ = public_reset;
 }
@@ skipping 11 matching lines @@
 }
 
 const QuicClock* MockHelper::GetClock() const {
   return &clock_;
 }
 
 QuicRandom* MockHelper::GetRandomGenerator() {
   return &random_generator_;
 }
 
-MockConnection::MockConnection(QuicGuid guid, IPEndPoint address)
-    : QuicConnection(guid, address, new MockHelper()),
+MockConnection::MockConnection(QuicGuid guid,
+                               IPEndPoint address,
+                               bool is_server)
+    : QuicConnection(guid, address, new MockHelper(), is_server),
       helper_(helper()) {
 }
 
 MockConnection::MockConnection(QuicGuid guid,
                                IPEndPoint address,
-                               QuicConnectionHelperInterface* helper)
-    : QuicConnection(guid, address, helper),
+                               QuicConnectionHelperInterface* helper,
+                               bool is_server)
+    : QuicConnection(guid, address, helper, is_server),
       helper_(helper) {
 }
 
 MockConnection::~MockConnection() {
 }
 
 PacketSavingConnection::PacketSavingConnection(QuicGuid guid,
-                                               IPEndPoint address)
-    : MockConnection(guid, address) {
+                                               IPEndPoint address,
+                                               bool is_server)
+    : MockConnection(guid, address, is_server) {
 }
 
 PacketSavingConnection::~PacketSavingConnection() {
   STLDeleteElements(&packets_);
 }
 
 bool PacketSavingConnection::SendOrQueuePacket(
     QuicPacketSequenceNumber sequence_number,
     QuicPacket* packet,
     QuicPacketEntropyHash entropy_hash,
@@ skipping 94 matching lines @@
     QuicData* actual,
     QuicData* expected) {
   CompareCharArraysWithHexError(
       description,
       actual->data(), actual->length(),
       expected->data(), expected->length());
 }
 
 static QuicPacket* ConstructPacketFromHandshakeMessage(
     QuicGuid guid,
-    const CryptoHandshakeMessage& message) {
+    const CryptoHandshakeMessage& message,
+    bool should_include_version) {
   CryptoFramer crypto_framer;
   scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
   QuicFramer quic_framer(kQuicVersion1,
                          QuicDecrypter::Create(kNULL),
-                         QuicEncrypter::Create(kNULL));
+                         QuicEncrypter::Create(kNULL),
+                         false);
 
   QuicPacketHeader header;
   header.public_header.guid = guid;
   header.public_header.reset_flag = false;
-  header.public_header.version_flag = false;
+  header.public_header.version_flag = should_include_version;
   header.packet_sequence_number = 1;
   header.entropy_flag = false;
   header.entropy_hash = 0;
   header.fec_flag = false;
   header.fec_entropy_flag = false;
   header.fec_group = 0;
 
   QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
                                data->AsStringPiece());
 
   QuicFrame frame(&stream_frame);
   QuicFrames frames;
   frames.push_back(frame);
   return quic_framer.ConstructFrameDataPacket(header, frames).packet;
 }
 
 QuicPacket* ConstructHandshakePacket(QuicGuid guid, CryptoTag tag) {
   CryptoHandshakeMessage message;
   message.tag = tag;
-  return ConstructPacketFromHandshakeMessage(guid, message);
+  return ConstructPacketFromHandshakeMessage(guid, message, false);
 }
 
 CryptoHandshakeMessage CreateChloMessage(const QuicClock* clock,
                                          QuicRandom* random_generator,
                                          const string& server_hostname) {
   QuicCryptoClientConfig client_config;
   client_config.SetDefaults(random_generator);
   string nonce;
   CryptoUtils::GenerateNonce(clock, random_generator, &nonce);
 
   QuicConfig config;
   config.SetDefaults();
 
   CryptoHandshakeMessage message;
   client_config.FillClientHello(nonce, server_hostname, &message);
   config.ToHandshakeMessage(&message);
   return message;
 }
 
 QuicPacket* ConstructClientHelloPacket(QuicGuid guid,
                                        const QuicClock* clock,
                                        QuicRandom* random_generator,
-                                       const string& server_hostname) {
+                                       const string& server_hostname,
+                                       bool should_include_version) {
   CryptoHandshakeMessage chlo = CreateChloMessage(clock, random_generator,
                                                   server_hostname);
-  return ConstructPacketFromHandshakeMessage(guid, chlo);
+  return ConstructPacketFromHandshakeMessage(
+      guid, chlo, should_include_version);
 }
 
 CryptoHandshakeMessage CreateShloMessage(const QuicClock* clock,
                                          QuicRandom* random_generator,
                                          const string& server_hostname) {
   // Expected CHLO
   CryptoHandshakeMessage chlo = CreateChloMessage(clock, random_generator,
                                                   server_hostname);
 
   QuicConfig config;
@@ skipping 22 matching lines @@
 
   return shlo;
 }
 
 QuicPacket* ConstructServerHelloPacket(QuicGuid guid,
                                        const QuicClock* clock,
                                        QuicRandom* random_generator,
                                        const string& server_hostname) {
   CryptoHandshakeMessage shlo =
       CreateShloMessage(clock, random_generator, server_hostname);
-  return ConstructPacketFromHandshakeMessage(guid, shlo);
+  return ConstructPacketFromHandshakeMessage(guid, shlo, false);
 }
 
 size_t GetPacketLengthForOneStream(bool include_version, size_t payload) {
+  // TODO(wtc): the hardcoded use of NullEncrypter here seems wrong.
   return NullEncrypter().GetCiphertextSize(payload) +
       QuicPacketCreator::StreamFramePacketOverhead(1, include_version);
 }
 
 QuicPacketEntropyHash TestEntropyCalculator::ReceivedEntropyHash(
     QuicPacketSequenceNumber sequence_number) const {
   return 1u;
 }
 
 }  // namespace test
 }  // namespace net