deprecate FLAGS_quic_disable_pre_34

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 "base/memory/ptr_util.h"
 #include "base/sha1.h"
@@ skipping 20 matching lines @@
 using testing::Invoke;
 using testing::_;
 
 namespace net {
 
 namespace test {
 
 QuicAckFrame MakeAckFrame(QuicPacketNumber largest_observed) {
   QuicAckFrame ack;
   ack.largest_observed = largest_observed;
-  ack.entropy_hash = 0;
-  return ack;
-}
-
-QuicAckFrame MakeAckFrameWithNackRanges(size_t num_nack_ranges,
-                                        QuicPacketNumber least_unacked) {
-  QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked);
-  // Add enough missing packets to get num_nack_ranges nack ranges.
-  for (QuicPacketNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
-    ack.packets.Add(least_unacked + i);
-  }
   return ack;
 }
 
 QuicAckFrame MakeAckFrameWithAckBlocks(size_t num_ack_blocks,
                                        QuicPacketNumber least_unacked) {
   QuicAckFrame ack = MakeAckFrame(2 * num_ack_blocks + least_unacked);
-  ack.missing = false;
   // Add enough received packets to get num_ack_blocks ack blocks.
   for (QuicPacketNumber i = 2; i < 2 * num_ack_blocks + 1; i += 2) {
     ack.packets.Add(least_unacked + i);
   }
   return ack;
 }
 
 QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer,
                                    const QuicPacketHeader& header,
                                    const QuicFrames& frames) {
@@ skipping 569 matching lines @@
     Perspective perspective) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id;
   header.public_header.connection_id_length = connection_id_length;
   header.public_header.version_flag = version_flag;
   header.public_header.multipath_flag = multipath_flag;
   header.public_header.reset_flag = reset_flag;
   header.public_header.packet_number_length = packet_number_length;
   header.path_id = path_id;
   header.packet_number = packet_number;
-  header.entropy_flag = false;
-  header.entropy_hash = 0;
   QuicStreamFrame stream_frame(1, false, 0, StringPiece(data));
   QuicFrame frame(&stream_frame);
   QuicFrames frames;
   frames.push_back(frame);
   QuicFramer framer(
       versions != nullptr ? *versions : CurrentSupportedVersions(),
       QuicTime::Zero(), perspective);
 
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
@@ skipping 28 matching lines @@
     Perspective perspective) {
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id;
   header.public_header.connection_id_length = connection_id_length;
   header.public_header.version_flag = version_flag;
   header.public_header.multipath_flag = multipath_flag;
   header.public_header.reset_flag = reset_flag;
   header.public_header.packet_number_length = packet_number_length;
   header.path_id = path_id;
   header.packet_number = packet_number;
-  header.entropy_flag = false;
-  header.entropy_hash = 0;
   QuicStreamFrame stream_frame(1, false, 0, StringPiece(data));
   QuicFrame frame(&stream_frame);
   QuicFrames frames;
   frames.push_back(frame);
   QuicFramer framer(versions != nullptr ? *versions : AllSupportedVersions(),
                     QuicTime::Zero(), perspective);
 
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   EXPECT_TRUE(packet != nullptr);
 
-  if (framer.version() <= QUIC_VERSION_33) {
-    // Now set the packet's private flags byte to 0xFF, which is an invalid
-    // value.
-    reinterpret_cast<unsigned char*>(
-        packet->mutable_data())[GetStartOfEncryptedData(
-        framer.version(), connection_id_length, version_flag, multipath_flag,
-        false /* no diversification nonce */, packet_number_length)] = 0xFF;
-  } else {
-    // 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;
-  }
+  // 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);
   EXPECT_NE(0u, encrypted_length);
   return new QuicEncryptedPacket(buffer, encrypted_length, true);
 }
 
 void CompareCharArraysWithHexError(const string& description,
                                    const char* actual,
@@ skipping 46 matching lines @@
   std::unique_ptr<QuicData> data(
       crypto_framer.ConstructHandshakeMessage(message));
   QuicFramer quic_framer(AllSupportedVersions(), QuicTime::Zero(),
                          Perspective::IS_CLIENT);
 
   QuicPacketHeader header;
   header.public_header.connection_id = connection_id;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = should_include_version;
   header.packet_number = 1;
-  header.entropy_flag = false;
-  header.entropy_hash = 0;
 
   QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
                                data->AsStringPiece());
 
   QuicFrame frame(&stream_frame);
   QuicFrames frames;
   frames.push_back(frame);
   return BuildUnsizedDataPacket(&quic_framer, header, frames);
 }
 
@@ skipping 26 matching lines @@
   if (stream_length < ack_length) {
     *payload_length = 1 + ack_length - stream_length;
   }
 
   return NullEncrypter().GetCiphertextSize(*payload_length) +
          QuicPacketCreator::StreamFramePacketOverhead(
              version, connection_id_length, include_version, include_path_id,
              include_diversification_nonce, packet_number_length, 0u);
 }
 
-TestEntropyCalculator::TestEntropyCalculator() {}
-
-TestEntropyCalculator::~TestEntropyCalculator() {}
-
-QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
-    QuicPacketNumber packet_number) const {
-  return 1u;
-}
-
-MockEntropyCalculator::MockEntropyCalculator() {}
-
-MockEntropyCalculator::~MockEntropyCalculator() {}
-
 QuicConfig DefaultQuicConfig() {
   QuicConfig config;
   config.SetInitialStreamFlowControlWindowToSend(
       kInitialStreamFlowControlWindowForTest);
   config.SetInitialSessionFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   return config;
 }
 
 QuicConfig DefaultQuicConfigStatelessRejects() {
@@ skipping 80 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