Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

net/quic/test_tools/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/test_tools/quic_test_packet_maker.h"
 
 #include <list>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 28 matching lines @@
 
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakePingPacket(
     QuicPacketNumber num,
     bool include_version) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = num;
-  header.entropy_flag = false;
 
   QuicPingFrame ping;
   return std::unique_ptr<QuicReceivedPacket>(
       MakePacket(header, QuicFrame(ping)));
 }
 
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
     QuicPacketNumber num,
     bool include_version,
     QuicStreamId stream_id,
     QuicRstStreamErrorCode error_code) {
   return MakeRstPacket(num, include_version, stream_id, error_code, 0);
 }
 
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
     QuicPacketNumber num,
     bool include_version,
     QuicStreamId stream_id,
     QuicRstStreamErrorCode error_code,
     size_t bytes_written) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = num;
-  header.entropy_flag = false;
 
   QuicRstStreamFrame rst(stream_id, error_code, bytes_written);
   DVLOG(1) << "Adding frame: " << QuicFrame(&rst);
   return std::unique_ptr<QuicReceivedPacket>(
       MakePacket(header, QuicFrame(&rst)));
 }
 
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeAckAndRstPacket(
     QuicPacketNumber num,
     bool include_version,
     QuicStreamId stream_id,
     QuicRstStreamErrorCode error_code,
     QuicPacketNumber largest_received,
     QuicPacketNumber ack_least_unacked,
     QuicPacketNumber stop_least_unacked,
     bool send_feedback) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = num;
-  header.entropy_flag = false;
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.ack_delay_time = QuicTime::Delta::Zero();
   for (QuicPacketNumber i = ack_least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
   }
-  if (largest_received > 0 && version_ > QUIC_VERSION_33) {
-    ack.missing = false;
+  if (largest_received > 0) {
     ack.packets.Add(1, largest_received + 1);
   }
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack));
   DVLOG(1) << "Adding frame: " << frames[0];
 
   QuicStopWaitingFrame stop_waiting;
   stop_waiting.least_unacked = stop_least_unacked;
   frames.push_back(QuicFrame(&stop_waiting));
   DVLOG(1) << "Adding frame: " << frames[1];
@@ skipping 22 matching lines @@
     QuicPacketNumber largest_received,
     QuicPacketNumber least_unacked,
     QuicErrorCode quic_error,
     const std::string& quic_error_details) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = include_version;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = num;
-  header.entropy_flag = false;
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.ack_delay_time = ack_delay_time;
   for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
   }
-  if (largest_received > 0 && version_ > QUIC_VERSION_33) {
-    ack.missing = false;
+  if (largest_received > 0) {
     ack.packets.Add(1, largest_received + 1);
   }
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack));
   DVLOG(1) << "Adding frame: " << frames[0];
 
   QuicStopWaitingFrame stop_waiting;
   stop_waiting.least_unacked = least_unacked;
   frames.push_back(QuicFrame(&stop_waiting));
   DVLOG(1) << "Adding frame: " << frames[1];
@@ skipping 18 matching lines @@
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeConnectionClosePacket(QuicPacketNumber num) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = num;
-  header.entropy_flag = false;
 
   QuicConnectionCloseFrame close;
   close.error_code = QUIC_CRYPTO_VERSION_NOT_SUPPORTED;
   close.error_details = "Time to panic!";
   return std::unique_ptr<QuicReceivedPacket>(
       MakePacket(header, QuicFrame(&close)));
 }
 
 std::unique_ptr<QuicReceivedPacket> QuicTestPacketMaker::MakeGoAwayPacket(
     QuicPacketNumber num,
     QuicErrorCode error_code,
     std::string reason_phrase) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = num;
-  header.entropy_flag = false;
 
   QuicGoAwayFrame goaway;
   goaway.error_code = error_code;
   goaway.last_good_stream_id = 0;
   goaway.reason_phrase = reason_phrase;
   return std::unique_ptr<QuicReceivedPacket>(
       MakePacket(header, QuicFrame(&goaway)));
 }
 
 // Sets both least_unacked fields in stop waiting frame and ack frame
@@ skipping 12 matching lines @@
     QuicPacketNumber largest_received,
     QuicPacketNumber ack_least_unacked,
     QuicPacketNumber stop_least_unacked,
     bool send_feedback) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = packet_number;
-  header.entropy_flag = false;
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.ack_delay_time = QuicTime::Delta::Zero();
   for (QuicPacketNumber i = ack_least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
   }
-  if (largest_received > 0 && version_ > QUIC_VERSION_33) {
-    ack.missing = false;
+  if (largest_received > 0) {
     ack.packets.Add(1, largest_received + 1);
   }
 
   QuicFramer framer(SupportedVersions(version_), clock_->Now(), perspective_);
   QuicFrames frames;
   QuicFrame ack_frame(&ack);
   DVLOG(1) << "Adding frame: " << ack_frame;
   frames.push_back(ack_frame);
 
   QuicStopWaitingFrame stop_waiting;
@@ skipping 61 matching lines @@
     bool fin,
     QuicStreamOffset offset,
     base::StringPiece data) {
   InitializeHeader(packet_number, include_version);
 
   QuicAckFrame ack(MakeAckFrame(largest_received));
   ack.ack_delay_time = QuicTime::Delta::Zero();
   for (QuicPacketNumber i = least_unacked; i <= largest_received; ++i) {
     ack.received_packet_times.push_back(make_pair(i, clock_->Now()));
   }
-  if (largest_received > 0 && version_ > QUIC_VERSION_33) {
-    ack.missing = false;
+  if (largest_received > 0) {
     ack.packets.Add(1, largest_received + 1);
   }
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack));
 
   QuicStopWaitingFrame stop_waiting;
   stop_waiting.least_unacked = least_unacked;
   frames.push_back(QuicFrame(&stop_waiting));
 
   QuicStreamFrame stream_frame(stream_id, fin, offset, data);
@@ skipping 299 matching lines @@
   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;
   header_.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header_.packet_number = packet_number;
-  header_.entropy_flag = false;
 }
 
 }  // namespace test
 }  // namespace net