Landing Recent QUIC changes until 5:30 PM, Feb 3, 2017 UTC-5

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 <memory>
 
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_handshake.h"
@@ skipping 443 matching lines @@
   rendezvous_stream_ = stream;
 }
 
 TestQuicSpdyClientSession::TestQuicSpdyClientSession(
     QuicConnection* connection,
     const QuicConfig& config,
     const QuicServerId& server_id,
     QuicCryptoClientConfig* crypto_config)
     : QuicClientSessionBase(connection, &push_promise_index_, config) {
   crypto_stream_.reset(new QuicCryptoClientStream(
-      server_id, this, CryptoTestUtils::ProofVerifyContextForTesting(),
+      server_id, this, crypto_test_utils::ProofVerifyContextForTesting(),
       crypto_config, this));
   Initialize();
 }
 
 TestQuicSpdyClientSession::~TestQuicSpdyClientSession() {}
 
 bool TestQuicSpdyClientSession::IsAuthorized(const string& authority) {
   return true;
 }
 
@@ skipping 163 matching lines @@
   frames.push_back(frame);
   QuicFramer framer(
       versions != nullptr ? *versions : CurrentSupportedVersions(),
       QuicTime::Zero(), perspective);
 
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   EXPECT_TRUE(packet != nullptr);
   char* buffer = new char[kMaxPacketSize];
   size_t encrypted_length = framer.EncryptPayload(
-      ENCRYPTION_NONE, path_id, packet_number, *packet, buffer, kMaxPacketSize);
+      ENCRYPTION_NONE, packet_number, *packet, buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_length);
   return new QuicEncryptedPacket(buffer, encrypted_length, true);
 }
 
 QuicReceivedPacket* ConstructReceivedPacket(
     const QuicEncryptedPacket& encrypted_packet,
     QuicTime receipt_time) {
   char* buffer = new char[encrypted_packet.length()];
   memcpy(buffer, encrypted_packet.data(), encrypted_packet.length());
   return new QuicReceivedPacket(buffer, encrypted_packet.length(), receipt_time,
@@ skipping 33 matching lines @@
   EXPECT_TRUE(packet != nullptr);
 
   // Now set the frame type to 0x1F, which is an invalid frame type.
   reinterpret_cast<unsigned char*>(
       packet->mutable_data())[GetStartOfEncryptedData(
       framer.version(), connection_id_length, version_flag, multipath_flag,
       false /* no diversification nonce */, packet_number_length)] = 0x1F;
 
   char* buffer = new char[kMaxPacketSize];
   size_t encrypted_length = framer.EncryptPayload(
-      ENCRYPTION_NONE, path_id, packet_number, *packet, buffer, kMaxPacketSize);
+      ENCRYPTION_NONE, packet_number, *packet, buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_length);
   return new QuicEncryptedPacket(buffer, encrypted_length, true);
 }
 
 void CompareCharArraysWithHexError(const string& description,
                                    const char* actual,
                                    const int actual_len,
                                    const char* expected,
                                    const int expected_len) {
   EXPECT_EQ(actual_len, expected_len);
@@ skipping 174 matching lines @@
   // strike register worries that we've just overflowed a uint32_t time.
   (*server_connection)->AdvanceTime(connection_start_time);
 }
 
 QuicStreamId QuicClientDataStreamId(int i) {
   return kClientDataStreamId1 + 2 * i;
 }
 
 }  // namespace test
 }  // namespace net