Deprecate --gfe2_reloadable_flag_quic_packet_creator_prefetch.

net/quic/quic_packet_creator_test.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/quic_packet_creator.h"
 
 #include <stdint.h>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 20 matching lines @@
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
 // Run tests with combinations of {QuicVersion, ToggleVersionSerialization}.
 struct TestParams {
   TestParams(QuicVersion version,
              bool version_serialization,
-             QuicConnectionIdLength length,
-             bool copy_use_prefetch)
+             QuicConnectionIdLength length)
       : version(version),
         connection_id_length(length),
-        version_serialization(version_serialization),
-        copy_use_prefetch(copy_use_prefetch) {}
+        version_serialization(version_serialization) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ client_version: " << QuicVersionToString(p.version)
        << " connection id length: " << p.connection_id_length
-       << " include version: " << p.version_serialization
-       << " copy use prefetch: " << p.copy_use_prefetch << " }";
+       << " include version: " << p.version_serialization << " }";
     return os;
   }
 
   QuicVersion version;
   QuicConnectionIdLength connection_id_length;
   bool version_serialization;
-  bool copy_use_prefetch;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   QuicConnectionIdLength max = PACKET_8BYTE_CONNECTION_ID;
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
-    params.push_back(TestParams(all_supported_versions[i], true, max, false));
-    params.push_back(TestParams(all_supported_versions[i], false, max, false));
+    params.push_back(TestParams(all_supported_versions[i], true, max));
+    params.push_back(TestParams(all_supported_versions[i], false, max));
   }
-  params.push_back(TestParams(all_supported_versions[0], true,
-                              PACKET_0BYTE_CONNECTION_ID, false));
-  params.push_back(TestParams(all_supported_versions[0], true,
-                              PACKET_1BYTE_CONNECTION_ID, false));
-  params.push_back(TestParams(all_supported_versions[0], true,
-                              PACKET_4BYTE_CONNECTION_ID, false));
-  params.push_back(TestParams(all_supported_versions[0], true, max, true));
+  params.push_back(
+      TestParams(all_supported_versions[0], true, PACKET_0BYTE_CONNECTION_ID));
+  params.push_back(
+      TestParams(all_supported_versions[0], true, PACKET_1BYTE_CONNECTION_ID));
+  params.push_back(
+      TestParams(all_supported_versions[0], true, PACKET_4BYTE_CONNECTION_ID));
+  params.push_back(TestParams(all_supported_versions[0], true, max));
   return params;
 }
 
 class MockDelegate : public QuicPacketCreator::DelegateInterface {
  public:
   MockDelegate() {}
   ~MockDelegate() override {}
 
   MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
   MOCK_METHOD0(OnResetFecGroup, void());
@@ skipping 35 matching lines @@
         data_("foo"),
         creator_(connection_id_, &client_framer_, &mock_random_, &delegate_),
         serialized_packet_(creator_.NoPacket()) {
     creator_.set_connection_id_length(GetParam().connection_id_length);
 
     creator_.SetEncrypter(ENCRYPTION_INITIAL, new NullEncrypter());
     creator_.SetEncrypter(ENCRYPTION_FORWARD_SECURE, new NullEncrypter());
     client_framer_.set_visitor(&framer_visitor_);
     client_framer_.set_received_entropy_calculator(&entropy_calculator_);
     server_framer_.set_visitor(&framer_visitor_);
-    FLAGS_quic_packet_creator_prefetch = GetParam().copy_use_prefetch;
   }
 
   ~QuicPacketCreatorTest() override {}
 
   SerializedPacket SerializeAllFrames(const QuicFrames& frames) {
     SerializedPacket packet =
         creator_.SerializeAllFrames(frames, buffer_, kMaxPacketSize);
     EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_),
               packet.encryption_level);
     return packet;
@@ skipping 1373 matching lines @@
   creator_.SetCurrentPath(kDefaultPathId, 2, 10000 / kDefaultMaxPacketSize);
   // FEC packet consumes a packet number.
   EXPECT_EQ(64 * 256 - max_packets_per_fec_group, creator_.packet_number());
   EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net