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 "base/strings/string_piece.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_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/spdy/spdy_frame_builder.h"
 
@@ skipping 30 matching lines @@
   ON_CALL(*this, OnConnectionCloseFrame(_))
       .WillByDefault(testing::Return(true));
 
   ON_CALL(*this, OnGoAwayFrame(_))
       .WillByDefault(testing::Return(true));
 }
 
 MockFramerVisitor::~MockFramerVisitor() {
 }
 
-bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersionTag version) {
+bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicTag version) {
   return false;
 }
 
 bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
   return true;
 }
 
 bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
   return true;
 }
@@ skipping 112 matching lines @@
   return &random_generator_;
 }
 
 void MockHelper::AdvanceTime(QuicTime::Delta delta) {
   clock_.AdvanceTime(delta);
 }
 
 MockConnection::MockConnection(QuicGuid guid,
                                IPEndPoint address,
                                bool is_server)
-    : QuicConnection(guid, address, new MockHelper(), is_server),
+    : QuicConnection(guid, address, new testing::NiceMock<MockHelper>(),
+                     is_server),
       has_mock_helper_(true) {
 }
 
 MockConnection::MockConnection(QuicGuid guid,
                                IPEndPoint address,
                                QuicConnectionHelperInterface* helper,
                                bool is_server)
     : QuicConnection(guid, address, helper, is_server),
       has_mock_helper_(false) {
 }
 
 MockConnection::~MockConnection() {
 }
 
 void MockConnection::AdvanceTime(QuicTime::Delta delta) {
   CHECK(has_mock_helper_) << "Cannot advance time unless a MockClock is being"
                              " used";
   static_cast<MockHelper*>(helper())->AdvanceTime(delta);
 }
 
 PacketSavingConnection::PacketSavingConnection(QuicGuid guid,
                                                IPEndPoint address,
                                                bool is_server)
     : MockConnection(guid, address, is_server) {
 }
 
 PacketSavingConnection::~PacketSavingConnection() {
   STLDeleteElements(&packets_);
+  STLDeleteElements(&encrypted_packets_);
 }
 
 bool PacketSavingConnection::SendOrQueuePacket(
     EncryptionLevel level,
     QuicPacketSequenceNumber sequence_number,
     QuicPacket* packet,
     QuicPacketEntropyHash entropy_hash,
     HasRetransmittableData retransmittable) {
   packets_.push_back(packet);
+  QuicEncryptedPacket* encrypted =
+      framer_.EncryptPacket(level, sequence_number, *packet);
+  encrypted_packets_.push_back(encrypted);
   return true;
 }
 
 MockSession::MockSession(QuicConnection* connection, bool is_server)
     : QuicSession(connection, is_server) {
   ON_CALL(*this, WriteData(_, _, _, _))
       .WillByDefault(testing::Return(QuicConsumedData(0, false)));
 }
 
 MockSession::~MockSession() {
 }
 
+TestSession::TestSession(QuicConnection* connection, bool is_server)
+    : QuicSession(connection, is_server),
+      crypto_stream_(NULL) {
+}
+
+TestSession::~TestSession() {
+}
+
+void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
+  crypto_stream_ = stream;
+}
+
+QuicCryptoStream* TestSession::GetCryptoStream() {
+  return crypto_stream_;
+}
+
 MockSendAlgorithm::MockSendAlgorithm() {
 }
 
 MockSendAlgorithm::~MockSendAlgorithm() {
 }
 
 namespace {
 
 string HexDumpWithMarks(const char* data, int length,
                         const bool* marks, int mark_length) {
@@ skipping 96 matching lines @@
 
   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) {
+QuicPacket* ConstructHandshakePacket(QuicGuid guid, QuicTag tag) {
   CryptoHandshakeMessage message;
   message.set_tag(tag);
   return ConstructPacketFromHandshakeMessage(guid, message, false);
 }
 
 size_t GetPacketLengthForOneStream(bool include_version, size_t payload) {
   // TODO(wtc): the hardcoded use of NullEncrypter here seems wrong.
   size_t packet_length = NullEncrypter().GetCiphertextSize(payload) +
       QuicPacketCreator::StreamFramePacketOverhead(1, include_version);
 
@@ skipping 10 matching lines @@
   return 1u;
 }
 
 bool TestDecompressorVisitor::OnDecompressedData(StringPiece data) {
   data.AppendToString(&data_);
   return true;
 }
 
 }  // namespace test
 }  // namespace net