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

net/quic/chromium/quic_test_packet_maker.cc

 // Copyright 2013 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/chromium/quic_test_packet_maker.h"
 
 #include <list>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 100 matching lines @@
   DVLOG(1) << "Adding frame: " << frames[1];
 
   QuicRstStreamFrame rst(stream_id, error_code, 0);
   frames.push_back(QuicFrame(&rst));
   DVLOG(1) << "Adding frame: " << frames[2];
 
   QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[kMaxPacketSize];
-  size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
-                                                header.packet_number, *packet,
-                                                buffer, kMaxPacketSize);
+  size_t encrypted_size = framer.EncryptPayload(
+      ENCRYPTION_NONE, header.packet_number, *packet, buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_size);
   QuicReceivedPacket encrypted(buffer, encrypted_size, QuicTime::Zero(), false);
   return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeAckAndConnectionClosePacket(
     QuicPacketNumber num,
     bool include_version,
     QuicTime::Delta ack_delay_time,
@@ skipping 29 matching lines @@
   close.error_code = quic_error;
   close.error_details = quic_error_details;
 
   frames.push_back(QuicFrame(&close));
   DVLOG(1) << "Adding frame: " << frames[2];
 
   QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[kMaxPacketSize];
-  size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
-                                                header.packet_number, *packet,
-                                                buffer, kMaxPacketSize);
+  size_t encrypted_size = framer.EncryptPayload(
+      ENCRYPTION_NONE, header.packet_number, *packet, buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_size);
   QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
   return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeConnectionClosePacket(QuicPacketNumber num) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
@@ skipping 66 matching lines @@
   DVLOG(1) << "Adding frame: " << ack_frame;
   frames.push_back(ack_frame);
 
   QuicStopWaitingFrame stop_waiting;
   stop_waiting.least_unacked = stop_least_unacked;
   frames.push_back(QuicFrame(&stop_waiting));
 
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[kMaxPacketSize];
-  size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
-                                                header.packet_number, *packet,
-                                                buffer, kMaxPacketSize);
+  size_t encrypted_size = framer.EncryptPayload(
+      ENCRYPTION_NONE, header.packet_number, *packet, buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_size);
   QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
   return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
 }
 
 // Returns a newly created packet to send kData on stream 1.
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeDataPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
@@ skipping 335 matching lines @@
   return MakeMultipleFramesPacket(header, frames);
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeMultipleFramesPacket(const QuicPacketHeader& header,
                                               const QuicFrames& frames) {
   QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[kMaxPacketSize];
-  size_t encrypted_size = framer.EncryptPayload(ENCRYPTION_NONE, /*path_id=*/0u,
-                                                header.packet_number, *packet,
-                                                buffer, kMaxPacketSize);
+  size_t encrypted_size = framer.EncryptPayload(
+      ENCRYPTION_NONE, header.packet_number, *packet, buffer, kMaxPacketSize);
   EXPECT_NE(0u, encrypted_size);
   QuicReceivedPacket encrypted(buffer, encrypted_size, clock_->Now(), false);
   return std::unique_ptr<QuicReceivedPacket>(encrypted.Clone());
 }
 
 void QuicTestPacketMaker::InitializeHeader(QuicPacketNumber packet_number,
                                            bool should_include_version) {
   header_.public_header.connection_id = connection_id_;
   header_.public_header.reset_flag = false;
   header_.public_header.version_flag = should_include_version;
@@ skipping 19 matching lines @@
     *offset += spdy_frame.size();
     return MakePacket(header_, QuicFrame(&quic_frame));
   }
   QuicStreamFrame quic_frame(kHeadersStreamId, false, 0,
                              StringPiece(spdy_frame.data(), spdy_frame.size()));
   return MakePacket(header_, QuicFrame(&quic_frame));
 }
 
 }  // namespace test
 }  // namespace net