diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 153c142..61e66cc 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -1886,7 +1886,7 @@
   // Return true if framer should continue processing the packet.
   bool OnPathChallengeFrameInternal(const QuicPathChallengeFrame& frame);
 
-  virtual std::unique_ptr<QuicSelfIssuedConnectionIdManager>
+  std::unique_ptr<QuicSelfIssuedConnectionIdManager>
   MakeSelfIssuedConnectionIdManager();
 
   // Called on peer IP change or restoring to previous address to reset
diff --git a/quiche/quic/core/quic_connection_id_manager.cc b/quiche/quic/core/quic_connection_id_manager.cc
index a3909f3..a2a3fbf 100644
--- a/quiche/quic/core/quic_connection_id_manager.cc
+++ b/quiche/quic/core/quic_connection_id_manager.cc
@@ -296,29 +296,13 @@
   retire_connection_id_alarm_->Cancel();
 }
 
-QuicConnectionId QuicSelfIssuedConnectionIdManager::GenerateNewConnectionId(
-    const QuicConnectionId& old_connection_id) const {
-  return QuicUtils::CreateReplacementConnectionId(old_connection_id);
-}
-
 absl::optional<QuicNewConnectionIdFrame>
 QuicSelfIssuedConnectionIdManager::MaybeIssueNewConnectionId() {
   const bool check_cid_collision_when_issue_new_cid =
       GetQuicReloadableFlag(quic_check_cid_collision_when_issue_new_cid);
-  absl::optional<QuicConnectionId> new_cid;
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator)) {
-    QUIC_RELOADABLE_FLAG_COUNT(
-        quic_connection_uses_abstract_connection_id_generator);
-    new_cid =
-        connection_id_generator_.GenerateNextConnectionId(last_connection_id_);
-  } else {
-    new_cid = GenerateNewConnectionId(last_connection_id_);
-  }
+  absl::optional<QuicConnectionId> new_cid =
+      connection_id_generator_.GenerateNextConnectionId(last_connection_id_);
   if (!new_cid.has_value()) {
-    QUIC_BUG_IF(quic_bug_469887433_1,
-                !GetQuicReloadableFlag(
-                    quic_connection_uses_abstract_connection_id_generator));
     return {};
   }
   if (check_cid_collision_when_issue_new_cid) {
diff --git a/quiche/quic/core/quic_connection_id_manager.h b/quiche/quic/core/quic_connection_id_manager.h
index 1fa48e9..b8454af 100644
--- a/quiche/quic/core/quic_connection_id_manager.h
+++ b/quiche/quic/core/quic_connection_id_manager.h
@@ -161,12 +161,6 @@
   // tell if a received packet has a valid connection ID.
   bool IsConnectionIdInUse(const QuicConnectionId& cid) const;
 
-  // TODO(martinduke): This class will be eliminated when
-  // FLAGS_gfe2_reloadable_flag_quic_connection_uses_abstract_connection_id_generator
-  // goes away.
-  virtual QuicConnectionId GenerateNewConnectionId(
-      const QuicConnectionId& old_connection_id) const;
-
  private:
   friend class test::QuicConnectionIdManagerPeer;
 
diff --git a/quiche/quic/core/quic_connection_id_manager_test.cc b/quiche/quic/core/quic_connection_id_manager_test.cc
index bb85d5d..9df262c 100644
--- a/quiche/quic/core/quic_connection_id_manager_test.cc
+++ b/quiche/quic/core/quic_connection_id_manager_test.cc
@@ -546,14 +546,11 @@
  protected:
   // Verify that a call to GenerateNewConnectionId() does the right thing.
   QuicConnectionId CheckGenerate(QuicConnectionId old_cid) {
-    QuicConnectionId new_cid =
-        QuicUtils::CreateReplacementConnectionId(old_cid);
-    if (GetQuicReloadableFlag(
-            quic_connection_uses_abstract_connection_id_generator)) {
-      // Ready for the actual call.
-      EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(old_cid))
-          .WillOnce(Return(new_cid));
-    }
+    QuicConnectionId new_cid = old_cid;
+    (*new_cid.mutable_data())++;
+    // Ready for the actual call.
+    EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(old_cid))
+        .WillOnce(Return(new_cid));
     return new_cid;
   }
 
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index ee2a090..3a4e7a9 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -1877,9 +1877,7 @@
   QuicConnectionPeer::SetAddressValidated(&connection_);
 
   // Sends new server CID to client.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -2082,9 +2080,7 @@
 
   // Sends new server CID to client.
   QuicConnectionId new_cid;
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -2146,9 +2142,7 @@
 
   // Sends new server CID to client.
   QuicConnectionId new_cid;
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -2220,9 +2214,7 @@
   QuicConnectionId server_cid0 = connection_.connection_id();
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -13304,9 +13296,7 @@
   QuicConnectionId client_cid1 = TestConnectionId(2);
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -13458,9 +13448,7 @@
   QuicConnectionId server_cid0 = connection_.connection_id();
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -13585,9 +13573,7 @@
   QuicConnectionId client_cid1 = TestConnectionId(2);
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -13699,9 +13685,7 @@
   QuicConnectionId client_cid1 = TestConnectionId(2);
   QuicConnectionId server_cid1;
   // Sends new server CID to client.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -13838,11 +13822,8 @@
   ASSERT_EQ(packet_creator->GetDestinationConnectionId(), server_cid0);
 
   // Client will issue a new client connection ID to server.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator)) {
-    EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
-        .WillOnce(Return(TestConnectionId(456)));
-  }
+  EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
+      .WillOnce(Return(TestConnectionId(456)));
   EXPECT_CALL(visitor_, SendNewConnectionId(_))
       .WillOnce(Invoke([&](const QuicNewConnectionIdFrame& frame) {
         client_cid1 = frame.connection_id;
@@ -14001,11 +13982,8 @@
 
   // Client will issue a new client connection ID to server.
   QuicConnectionId new_client_connection_id;
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator)) {
-    EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
-        .WillOnce(Return(TestConnectionId(456)));
-  }
+  EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
+      .WillOnce(Return(TestConnectionId(456)));
   EXPECT_CALL(visitor_, SendNewConnectionId(_))
       .WillOnce(Invoke([&](const QuicNewConnectionIdFrame& frame) {
         new_client_connection_id = frame.connection_id;
@@ -14259,9 +14237,7 @@
   set_perspective(Perspective::IS_SERVER);
   connection_.CreateConnectionIdManager();
 
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -14298,9 +14274,7 @@
   QuicRetireConnectionIdFrame frame;
   frame.sequence_number = 0u;
   if (connection_.connection_migration_use_new_cid()) {
-    if (GetQuicReloadableFlag(
-            quic_connection_uses_abstract_connection_id_generator) &&
-        !connection_.connection_id().IsEmpty()) {
+    if (!connection_.connection_id().IsEmpty()) {
       EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(cid0))
           .WillOnce(Return(TestConnectionId(456)));
       EXPECT_CALL(connection_id_generator_,
@@ -14340,9 +14314,7 @@
   EXPECT_EQ(connection_.GetOneActiveServerConnectionId(), cid0);
 
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -14377,9 +14349,7 @@
 
   // Packet2 with RetireConnectionId frame trigers sending NewConnectionId
   // immediately.
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator) &&
-      !connection_.connection_id().IsEmpty()) {
+  if (!connection_.connection_id().IsEmpty()) {
     EXPECT_CALL(connection_id_generator_, GenerateNextConnectionId(_))
         .WillOnce(Return(TestConnectionId(456)));
   }
@@ -14793,15 +14763,12 @@
       !connection_.connection_migration_use_new_cid()) {
     return;
   }
-  if (GetQuicReloadableFlag(
-          quic_connection_uses_abstract_connection_id_generator)) {
-    EXPECT_CALL(connection_id_generator_,
-                GenerateNextConnectionId(TestConnectionId(12)))
-        .WillOnce(Return(TestConnectionId(456)));
-    EXPECT_CALL(connection_id_generator_,
-                GenerateNextConnectionId(TestConnectionId(456)))
-        .WillOnce(Return(TestConnectionId(789)));
-  }
+  EXPECT_CALL(connection_id_generator_,
+              GenerateNextConnectionId(TestConnectionId(12)))
+      .WillOnce(Return(TestConnectionId(456)));
+  EXPECT_CALL(connection_id_generator_,
+              GenerateNextConnectionId(TestConnectionId(456)))
+      .WillOnce(Return(TestConnectionId(789)));
   EXPECT_CALL(visitor_, SendNewConnectionId(_)).Times(2);
   EXPECT_CALL(visitor_, OnRstStream(_));
   EXPECT_CALL(visitor_, OnWindowUpdateFrame(_));
diff --git a/quiche/quic/core/quic_dispatcher.cc b/quiche/quic/core/quic_dispatcher.cc
index 0ae3a64..7e6de46 100644
--- a/quiche/quic/core/quic_dispatcher.cc
+++ b/quiche/quic/core/quic_dispatcher.cc
@@ -41,13 +41,6 @@
 // Minimal INITIAL packet length sent by clients is 1200.
 const QuicPacketLength kMinClientInitialPacketLength = 1200;
 
-bool VariableShortHeaderConnectionIdLengths() {
-  return GetQuicReloadableFlag(
-             quic_ask_for_short_header_connection_id_length) &&
-         GetQuicReloadableFlag(
-             quic_connection_uses_abstract_connection_id_generator);
-}
-
 // An alarm that informs the QuicDispatcher to delete old sessions.
 class DeleteSessionsAlarm : public QuicAlarm::DelegateWithoutContext {
  public:
@@ -393,9 +386,7 @@
   if (!packet_info.version_flag &&
       GetQuicReloadableFlag(quic_ask_for_short_header_connection_id_length) &&
       (IsSupportedVersion(ParsedQuicVersion::Q046()) ||
-       IsSupportedVersion(ParsedQuicVersion::Q050()) ||
-       !GetQuicReloadableFlag(
-           quic_connection_uses_abstract_connection_id_generator))) {
+       IsSupportedVersion(ParsedQuicVersion::Q050()))) {
     ReceivedPacketInfo gquic_packet_info(self_address, peer_address, packet);
     // Try again without asking |connection_id_generator_| for the length.
     const QuicErrorCode gquic_error = QuicFramer::ParsePublicHeaderDispatcher(
@@ -476,7 +467,7 @@
   // unknown, in which case we allow short connection IDs for version
   // negotiation because that version could allow those.
   uint8_t expected_connection_id_length =
-      VariableShortHeaderConnectionIdLengths()
+      GetQuicReloadableFlag(quic_ask_for_short_header_connection_id_length)
           ? connection_id_generator_.ConnectionIdLength(
                 static_cast<uint8_t>(*server_connection_id.data()))
           : expected_server_connection_id_length_;
@@ -1359,7 +1350,7 @@
     }
   } else {
     uint8_t min_connection_id_length =
-        VariableShortHeaderConnectionIdLengths()
+        GetQuicReloadableFlag(quic_ask_for_short_header_connection_id_length)
             ? connection_id_generator_.ConnectionIdLength(static_cast<uint8_t>(
                   *packet_info.destination_connection_id.data()))
             : expected_server_connection_id_length_;
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index ce5e23f..d702e62 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -1244,6 +1244,10 @@
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
   // dispatcher_ should drop this packet.
+  if (GetQuicReloadableFlag(quic_ask_for_short_header_connection_id_length)) {
+    EXPECT_CALL(connection_id_generator_, ConnectionIdLength(_))
+        .WillOnce(Return(15));
+  }
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_, ProcessPacket(_, _, _, _, _, _))
       .Times(0);
diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index d3079d5..627532a 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -87,8 +87,6 @@
 QUIC_FLAG(quic_reloadable_flag_quic_conservative_cwnd_and_pacing_gains, false)
 // Instead of assuming an incoming connection ID length for short headers, ask each time, if both quic_abstract_connection_id_generator and quic_connection_uses_abstract_connection_id_generator are true.
 QUIC_FLAG(quic_reloadable_flag_quic_ask_for_short_header_connection_id_length, false)
-// QuicConnection uses a library to generate connection IDs
-QUIC_FLAG(quic_reloadable_flag_quic_connection_uses_abstract_connection_id_generator, true)
 // When true, defaults to BBR congestion control instead of Cubic.
 QUIC_FLAG(quic_reloadable_flag_quic_default_to_bbr, false)
 // When true, support draft-ietf-quic-v2-01
diff --git a/quiche/quic/core/quic_utils.cc b/quiche/quic/core/quic_utils.cc
index 5a5d6b0..5a86673 100644
--- a/quiche/quic/core/quic_utils.cc
+++ b/quiche/quic/core/quic_utils.cc
@@ -444,41 +444,6 @@
 }
 
 // static
-QuicConnectionId QuicUtils::CreateReplacementConnectionId(
-    const QuicConnectionId& connection_id) {
-  return CreateReplacementConnectionId(connection_id,
-                                       kQuicDefaultConnectionIdLength);
-}
-
-// static
-QuicConnectionId QuicUtils::CreateReplacementConnectionId(
-    const QuicConnectionId& connection_id,
-    uint8_t expected_connection_id_length) {
-  if (expected_connection_id_length == 0) {
-    return EmptyQuicConnectionId();
-  }
-  const uint64_t connection_id_hash64 = FNV1a_64_Hash(
-      absl::string_view(connection_id.data(), connection_id.length()));
-  if (expected_connection_id_length <= sizeof(uint64_t)) {
-    return QuicConnectionId(
-        reinterpret_cast<const char*>(&connection_id_hash64),
-        expected_connection_id_length);
-  }
-  char new_connection_id_data[255] = {};
-  const absl::uint128 connection_id_hash128 = FNV1a_128_Hash(
-      absl::string_view(connection_id.data(), connection_id.length()));
-  static_assert(sizeof(connection_id_hash64) + sizeof(connection_id_hash128) <=
-                    sizeof(new_connection_id_data),
-                "bad size");
-  memcpy(new_connection_id_data, &connection_id_hash64,
-         sizeof(connection_id_hash64));
-  memcpy(new_connection_id_data + sizeof(connection_id_hash64),
-         &connection_id_hash128, sizeof(connection_id_hash128));
-  return QuicConnectionId(new_connection_id_data,
-                          expected_connection_id_length);
-}
-
-// static
 QuicConnectionId QuicUtils::CreateRandomConnectionId() {
   return CreateRandomConnectionId(kQuicDefaultConnectionIdLength,
                                   QuicRandom::GetInstance());
diff --git a/quiche/quic/core/quic_utils.h b/quiche/quic/core/quic_utils.h
index 2d4d5e8..79212fd 100644
--- a/quiche/quic/core/quic_utils.h
+++ b/quiche/quic/core/quic_utils.h
@@ -159,20 +159,6 @@
   static QuicStreamId GetMaxClientInitiatedBidirectionalStreamId(
       QuicTransportVersion version);
 
-  // Generates a connection ID of length |expected_connection_id_length|
-  // derived from |connection_id|.
-  // This is guaranteed to be deterministic (calling this method with two
-  // connection IDs that are equal is guaranteed to produce the same result).
-  static QuicConnectionId CreateReplacementConnectionId(
-      const QuicConnectionId& connection_id,
-      uint8_t expected_connection_id_length);
-
-  // Generates a 64bit connection ID derived from |connection_id|.
-  // This is guaranteed to be deterministic (calling this method with two
-  // connection IDs that are equal is guaranteed to produce the same result).
-  static QuicConnectionId CreateReplacementConnectionId(
-      const QuicConnectionId& connection_id);
-
   // Generates a random 64bit connection ID.
   static QuicConnectionId CreateRandomConnectionId();
 
diff --git a/quiche/quic/core/quic_utils_test.cc b/quiche/quic/core/quic_utils_test.cc
index 835cb97..a4a194f 100644
--- a/quiche/quic/core/quic_utils_test.cc
+++ b/quiche/quic/core/quic_utils_test.cc
@@ -167,91 +167,6 @@
   EXPECT_FALSE(QuicUtils::IsIetfPacketShortHeader(first_byte));
 }
 
-TEST_F(QuicUtilsTest, ReplacementConnectionIdIsDeterministic) {
-  // Verify that two equal connection IDs get the same replacement.
-  QuicConnectionId connection_id64a = TestConnectionId(33);
-  QuicConnectionId connection_id64b = TestConnectionId(33);
-  EXPECT_EQ(connection_id64a, connection_id64b);
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id64a),
-            QuicUtils::CreateReplacementConnectionId(connection_id64b));
-  QuicConnectionId connection_id72a = TestConnectionIdNineBytesLong(42);
-  QuicConnectionId connection_id72b = TestConnectionIdNineBytesLong(42);
-  EXPECT_EQ(connection_id72a, connection_id72b);
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id72a),
-            QuicUtils::CreateReplacementConnectionId(connection_id72b));
-  // Test variant with custom length.
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id64a, 7),
-            QuicUtils::CreateReplacementConnectionId(connection_id64b, 7));
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id64a, 9),
-            QuicUtils::CreateReplacementConnectionId(connection_id64b, 9));
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id64a, 16),
-            QuicUtils::CreateReplacementConnectionId(connection_id64b, 16));
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id72a, 7),
-            QuicUtils::CreateReplacementConnectionId(connection_id72b, 7));
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id72a, 9),
-            QuicUtils::CreateReplacementConnectionId(connection_id72b, 9));
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id72a, 16),
-            QuicUtils::CreateReplacementConnectionId(connection_id72b, 16));
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id72a, 32),
-            QuicUtils::CreateReplacementConnectionId(connection_id72b, 32));
-  EXPECT_EQ(QuicUtils::CreateReplacementConnectionId(connection_id72a, 255),
-            QuicUtils::CreateReplacementConnectionId(connection_id72b, 255));
-}
-
-TEST_F(QuicUtilsTest, ReplacementConnectionIdLengthIsCorrect) {
-  // Verify that all lengths get replaced by kQuicDefaultConnectionIdLength.
-  const char connection_id_bytes[255] = {};
-  for (uint8_t i = 0; i < sizeof(connection_id_bytes) - 1; ++i) {
-    QuicConnectionId connection_id(connection_id_bytes, i);
-    QuicConnectionId replacement_connection_id =
-        QuicUtils::CreateReplacementConnectionId(connection_id);
-    EXPECT_EQ(kQuicDefaultConnectionIdLength,
-              replacement_connection_id.length());
-    // Test variant with custom length.
-    QuicConnectionId replacement_connection_id7 =
-        QuicUtils::CreateReplacementConnectionId(connection_id, 7);
-    EXPECT_EQ(7, replacement_connection_id7.length());
-    QuicConnectionId replacement_connection_id9 =
-        QuicUtils::CreateReplacementConnectionId(connection_id, 9);
-    EXPECT_EQ(9, replacement_connection_id9.length());
-    QuicConnectionId replacement_connection_id16 =
-        QuicUtils::CreateReplacementConnectionId(connection_id, 16);
-    EXPECT_EQ(16, replacement_connection_id16.length());
-    QuicConnectionId replacement_connection_id32 =
-        QuicUtils::CreateReplacementConnectionId(connection_id, 32);
-    EXPECT_EQ(32, replacement_connection_id32.length());
-    QuicConnectionId replacement_connection_id255 =
-        QuicUtils::CreateReplacementConnectionId(connection_id, 255);
-    EXPECT_EQ(255, replacement_connection_id255.length());
-  }
-}
-
-TEST_F(QuicUtilsTest, ReplacementConnectionIdHasEntropy) {
-  // Make sure all these test connection IDs have different replacements.
-  for (uint64_t i = 0; i < 256; ++i) {
-    QuicConnectionId connection_id_i = TestConnectionId(i);
-    EXPECT_NE(connection_id_i,
-              QuicUtils::CreateReplacementConnectionId(connection_id_i));
-    for (uint64_t j = i + 1; j <= 256; ++j) {
-      QuicConnectionId connection_id_j = TestConnectionId(j);
-      EXPECT_NE(connection_id_i, connection_id_j);
-      EXPECT_NE(QuicUtils::CreateReplacementConnectionId(connection_id_i),
-                QuicUtils::CreateReplacementConnectionId(connection_id_j));
-      // Test variant with custom length.
-      EXPECT_NE(QuicUtils::CreateReplacementConnectionId(connection_id_i, 7),
-                QuicUtils::CreateReplacementConnectionId(connection_id_j, 7));
-      EXPECT_NE(QuicUtils::CreateReplacementConnectionId(connection_id_i, 9),
-                QuicUtils::CreateReplacementConnectionId(connection_id_j, 9));
-      EXPECT_NE(QuicUtils::CreateReplacementConnectionId(connection_id_i, 16),
-                QuicUtils::CreateReplacementConnectionId(connection_id_j, 16));
-      EXPECT_NE(QuicUtils::CreateReplacementConnectionId(connection_id_i, 32),
-                QuicUtils::CreateReplacementConnectionId(connection_id_j, 32));
-      EXPECT_NE(QuicUtils::CreateReplacementConnectionId(connection_id_i, 255),
-                QuicUtils::CreateReplacementConnectionId(connection_id_j, 255));
-    }
-  }
-}
-
 TEST_F(QuicUtilsTest, RandomConnectionId) {
   MockRandom random(33);
   QuicConnectionId connection_id = QuicUtils::CreateRandomConnectionId(&random);