Deprecate --gfe2_restart_flag_quic_dispatcher_support_multiple_cid_per_connection_v2

PiperOrigin-RevId: 410393958
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 3e18d65..e31408a 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -317,11 +317,6 @@
   QUICHE_DCHECK(perspective_ == Perspective::IS_CLIENT ||
                 default_path_.self_address.IsInitialized());
 
-  support_multiple_connection_ids_ =
-      version().HasIetfQuicFrames() &&
-      GetQuicRestartFlag(
-          quic_dispatcher_support_multiple_cid_per_connection_v2);
-
   QUIC_DLOG(INFO) << ENDPOINT << "Created connection with server connection ID "
                   << server_connection_id
                   << " and version: " << ParsedQuicVersionToString(version());
@@ -522,7 +517,7 @@
     }
   }
 
-  if (support_multiple_connection_ids_ &&
+  if (version().HasIetfQuicFrames() &&
       config.HasReceivedPreferredAddressConnectionIdAndToken()) {
     QuicNewConnectionIdFrame frame;
     std::tie(frame.connection_id, frame.stateless_reset_token) =
@@ -645,7 +640,7 @@
   //    and server in unit tests with random flag combinations.
   // 2) Client side's rollout can be protected by the same connection option.
   connection_migration_use_new_cid_ =
-      support_multiple_connection_ids_ && validate_client_addresses_ &&
+      validate_client_addresses_ &&
       GetQuicReloadableFlag(quic_drop_unsent_path_response) &&
       GetQuicReloadableFlag(quic_connection_migration_use_new_cid_v2);
   if (config.HasReceivedMaxPacketSize()) {
@@ -1989,7 +1984,6 @@
 
 bool QuicConnection::OnNewConnectionIdFrameInner(
     const QuicNewConnectionIdFrame& frame) {
-  QUICHE_DCHECK(support_multiple_connection_ids_);
   if (peer_issued_cid_manager_ == nullptr) {
     CloseConnection(
         IETF_QUIC_PROTOCOL_VIOLATION,
@@ -2014,6 +2008,7 @@
 
 bool QuicConnection::OnNewConnectionIdFrame(
     const QuicNewConnectionIdFrame& frame) {
+  QUICHE_DCHECK(version().HasIetfQuicFrames());
   QUIC_BUG_IF(quic_bug_10511_13, !connected_)
       << "Processing NEW_CONNECTION_ID frame when "
          "connection is closed. Last frame: "
@@ -2025,14 +2020,12 @@
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnNewConnectionIdFrame(frame);
   }
-  if (!support_multiple_connection_ids_) {
-    return true;
-  }
   return OnNewConnectionIdFrameInner(frame);
 }
 
 bool QuicConnection::OnRetireConnectionIdFrame(
     const QuicRetireConnectionIdFrame& frame) {
+  QUICHE_DCHECK(version().HasIetfQuicFrames());
   QUIC_BUG_IF(quic_bug_10511_14, !connected_)
       << "Processing RETIRE_CONNECTION_ID frame when "
          "connection is closed. Last frame: "
@@ -2048,9 +2041,6 @@
     // Do not respond to RetireConnectionId frame.
     return true;
   }
-  if (!support_multiple_connection_ids_) {
-    return true;
-  }
   if (self_issued_cid_manager_ == nullptr) {
     CloseConnection(
         IETF_QUIC_PROTOCOL_VIOLATION,
@@ -2941,7 +2931,7 @@
 void QuicConnection::ReplaceInitialServerConnectionId(
     const QuicConnectionId& new_server_connection_id) {
   QUICHE_DCHECK(perspective_ == Perspective::IS_CLIENT);
-  if (support_multiple_connection_ids_) {
+  if (version().HasIetfQuicFrames()) {
     if (new_server_connection_id.IsEmpty()) {
       peer_issued_cid_manager_ = nullptr;
     } else {
@@ -3215,8 +3205,9 @@
                 QuicVersionUsesCryptoFrames(transport_version()))
       << ENDPOINT
       << "Handshake in STREAM frames should not check ShouldGeneratePacket";
-  if (support_multiple_connection_ids_ && peer_issued_cid_manager_ != nullptr &&
+  if (peer_issued_cid_manager_ != nullptr &&
       packet_creator_.GetDestinationConnectionId().IsEmpty()) {
+    QUICHE_DCHECK(version().HasIetfQuicFrames());
     QUIC_CODE_COUNT(quic_generate_packet_blocked_by_no_connection_id);
     QUIC_BUG_IF(quic_bug_90265_1, perspective_ == Perspective::IS_CLIENT);
     QUIC_DLOG(INFO) << ENDPOINT
@@ -6264,7 +6255,7 @@
   default_path_.client_connection_id = client_connection_id;
 
   client_connection_id_is_set_ = true;
-  if (support_multiple_connection_ids_ && !client_connection_id.IsEmpty()) {
+  if (version().HasIetfQuicFrames() && !client_connection_id.IsEmpty()) {
     if (perspective_ == Perspective::IS_SERVER) {
       QUICHE_DCHECK(peer_issued_cid_manager_ == nullptr);
       peer_issued_cid_manager_ =
@@ -6853,15 +6844,15 @@
 
 std::vector<QuicConnectionId> QuicConnection::GetActiveServerConnectionIds()
     const {
-  if (!support_multiple_connection_ids_ ||
-      self_issued_cid_manager_ == nullptr) {
+  if (self_issued_cid_manager_ == nullptr) {
     return {default_path_.server_connection_id};
   }
+  QUICHE_DCHECK(version().HasIetfQuicFrames());
   return self_issued_cid_manager_->GetUnretiredConnectionIds();
 }
 
 void QuicConnection::CreateConnectionIdManager() {
-  if (!support_multiple_connection_ids_) {
+  if (!version().HasIetfQuicFrames()) {
     return;
   }
 
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 0709a78..03a1c56 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -1237,10 +1237,6 @@
 
   bool validate_client_address() const { return validate_client_addresses_; }
 
-  bool support_multiple_connection_ids() const {
-    return support_multiple_connection_ids_;
-  }
-
   bool connection_migration_use_new_cid() const {
     return connection_migration_use_new_cid_;
   }
@@ -2278,8 +2274,6 @@
   // If true, upon seeing a new client address, validate the client address.
   bool validate_client_addresses_ = false;
 
-  bool support_multiple_connection_ids_ = false;
-
   // Indicates whether we should proactively validate peer address on a
   // PATH_CHALLENGE received.
   bool should_proactively_validate_peer_address_on_path_challenge_ = false;
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 8879a32..89fb70b 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -1465,7 +1465,7 @@
     EXPECT_EQ(kPeerAddress, connection_.peer_address());
     EXPECT_EQ(kPeerAddress, connection_.effective_peer_address());
     if (perspective == Perspective::IS_CLIENT &&
-        receive_new_server_connection_id) {
+        receive_new_server_connection_id && version().HasIetfQuicFrames()) {
       QuicNewConnectionIdFrame frame;
       frame.connection_id = TestConnectionId(1234);
       ASSERT_NE(frame.connection_id, connection_.connection_id());
@@ -14695,7 +14695,6 @@
   if (!version().HasIetfQuicFrames()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   set_perspective(Perspective::IS_SERVER);
   ASSERT_TRUE(connection_.client_connection_id().IsEmpty());
 
@@ -14720,7 +14719,6 @@
   if (!version().HasIetfQuicFrames()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   connection_.CreateConnectionIdManager();
   ASSERT_FALSE(connection_.connection_id().IsEmpty());
 
@@ -14745,7 +14743,6 @@
   if (!version().HasIetfQuicFrames()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   connection_.CreateConnectionIdManager();
 
   QuicNewConnectionIdFrame frame;
@@ -14782,7 +14779,6 @@
   if (!version().HasIetfQuicFrames()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   set_perspective(Perspective::IS_SERVER);
   SetClientConnectionId(TestConnectionId(0));
 
@@ -14822,7 +14818,6 @@
       !connection_.count_bytes_on_alternative_path_separately()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   PathProbeTestInit(Perspective::IS_SERVER);
   SetClientConnectionId(TestConnectionId(0));
 
@@ -14881,7 +14876,6 @@
       !connection_.connection_migration_use_new_cid()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   set_perspective(Perspective::IS_SERVER);
 
   EXPECT_CALL(visitor_, BeforeConnectionCloseSent());
@@ -14902,7 +14896,6 @@
       !connection_.connection_migration_use_new_cid()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   set_perspective(Perspective::IS_SERVER);
   connection_.CreateConnectionIdManager();
 
@@ -14925,10 +14918,9 @@
 
 TEST_P(QuicConnectionTest,
        ServerRetireSelfIssuedConnectionIdWithoutSendingNewConnectionIdBefore) {
-  if (!connection_.support_multiple_connection_ids()) {
+  if (!version().HasIetfQuicFrames()) {
     return;
   }
-  QuicConnectionPeer::EnableMultipleConnectionIdSupport(&connection_);
   set_perspective(Perspective::IS_SERVER);
   connection_.CreateConnectionIdManager();
 
@@ -15040,8 +15032,7 @@
 }
 
 TEST_P(QuicConnectionTest, PatchMissingClientConnectionIdOntoAlternativePath) {
-  if (!version().HasIetfQuicFrames() ||
-      !connection_.support_multiple_connection_ids()) {
+  if (!version().HasIetfQuicFrames()) {
     return;
   }
   set_perspective(Perspective::IS_SERVER);
@@ -15075,8 +15066,7 @@
 }
 
 TEST_P(QuicConnectionTest, PatchMissingClientConnectionIdOntoDefaultPath) {
-  if (!version().HasIetfQuicFrames() ||
-      !connection_.support_multiple_connection_ids()) {
+  if (!version().HasIetfQuicFrames()) {
     return;
   }
   set_perspective(Perspective::IS_SERVER);
@@ -15117,8 +15107,7 @@
 }
 
 TEST_P(QuicConnectionTest, ShouldGeneratePacketBlockedByMissingConnectionId) {
-  if (!version().HasIetfQuicFrames() ||
-      !connection_.support_multiple_connection_ids()) {
+  if (!version().HasIetfQuicFrames()) {
     return;
   }
   set_perspective(Perspective::IS_SERVER);
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index ef6db5d..a1e89b2 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -368,9 +368,7 @@
   }
   reference_counted_session_map_.clear();
   closed_ref_counted_session_list_.clear();
-  if (support_multiple_cid_per_connection_) {
-    num_sessions_in_session_map_ = 0;
-  }
+  num_sessions_in_session_map_ = 0;
 }
 
 void QuicDispatcher::InitializeWithWriter(QuicPacketWriter* writer) {
@@ -907,37 +905,16 @@
       } else {
         QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_handshake_failed);
       }
-      if (support_multiple_cid_per_connection_) {
-        QUIC_RESTART_FLAG_COUNT_N(
-            quic_dispatcher_support_multiple_cid_per_connection_v2, 1, 2);
-        // This serializes a connection close termination packet and adds the
-        // connection to the time wait list.
-        StatelessConnectionTerminator terminator(
-            server_connection_id, connection->version(), helper_.get(),
-            time_wait_list_manager_.get());
-        terminator.CloseConnection(
-            QUIC_HANDSHAKE_FAILED,
-            "Connection is closed by server before handshake confirmed",
-            connection->version().HasIetfInvariantHeader(),
-            connection->GetActiveServerConnectionIds());
-      } else {
-        action = QuicTimeWaitListManager::SEND_TERMINATION_PACKETS;
-        // This serializes a connection close termination packet and adds the
-        // connection to the time wait list.
-        StatelesslyTerminateConnection(
-            connection->connection_id(),
-            connection->version().HasIetfInvariantHeader()
-                ? IETF_QUIC_LONG_HEADER_PACKET
-                : GOOGLE_QUIC_PACKET,
-            /*version_flag=*/true,
-            connection->version().HasLengthPrefixedConnectionIds(),
-            connection->version(), QUIC_HANDSHAKE_FAILED,
-            "Connection is closed by server before handshake confirmed",
-            // Although it is our intention to send termination packets, the
-            // |action| argument is not used by this call to
-            // StatelesslyTerminateConnection().
-            action);
-      }
+      // This serializes a connection close termination packet and adds the
+      // connection to the time wait list.
+      StatelessConnectionTerminator terminator(
+          server_connection_id, connection->version(), helper_.get(),
+          time_wait_list_manager_.get());
+      terminator.CloseConnection(
+          QUIC_HANDSHAKE_FAILED,
+          "Connection is closed by server before handshake confirmed",
+          connection->version().HasIetfInvariantHeader(),
+          connection->GetActiveServerConnectionIds());
       return;
     }
     QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_stateless_reset);
@@ -1087,17 +1064,11 @@
     closed_ref_counted_session_list_.push_back(std::move(it->second));
   }
   CleanUpSession(it->first, connection, error, error_details, source);
-  if (support_multiple_cid_per_connection_) {
-    QUIC_RESTART_FLAG_COUNT_N(
-        quic_dispatcher_support_multiple_cid_per_connection_v2, 1, 2);
-    for (const QuicConnectionId& cid :
-         connection->GetActiveServerConnectionIds()) {
-      reference_counted_session_map_.erase(cid);
-    }
-    --num_sessions_in_session_map_;
-  } else {
-    reference_counted_session_map_.erase(it);
+  for (const QuicConnectionId& cid :
+       connection->GetActiveServerConnectionIds()) {
+    reference_counted_session_map_.erase(cid);
   }
+  --num_sessions_in_session_map_;
 }
 
 void QuicDispatcher::OnWriteBlocked(
@@ -1123,7 +1094,6 @@
 void QuicDispatcher::OnNewConnectionIdSent(
     const QuicConnectionId& server_connection_id,
     const QuicConnectionId& new_connection_id) {
-  QUICHE_DCHECK(support_multiple_cid_per_connection_);
   auto it = reference_counted_session_map_.find(server_connection_id);
   if (it == reference_counted_session_map_.end()) {
     QUIC_BUG(quic_bug_10287_7)
@@ -1141,7 +1111,6 @@
 
 void QuicDispatcher::OnConnectionIdRetired(
     const QuicConnectionId& server_connection_id) {
-  QUICHE_DCHECK(support_multiple_cid_per_connection_);
   reference_counted_session_map_.erase(server_connection_id);
 }
 
@@ -1271,7 +1240,7 @@
           << "Tried to add a session to session_map with existing connection "
              "id: "
           << server_connection_id;
-    } else if (support_multiple_cid_per_connection_) {
+    } else {
       ++num_sessions_in_session_map_;
     }
     DeliverPacketsToSession(packets, insertion_result.first->second.get());
@@ -1380,7 +1349,7 @@
         << "Tried to add a session to session_map with existing "
            "connection id: "
         << packet_info->destination_connection_id;
-  } else if (support_multiple_cid_per_connection_) {
+  } else {
     ++num_sessions_in_session_map_;
   }
   session_ptr = insertion_result.first->second.get();
@@ -1492,10 +1461,7 @@
 }
 
 size_t QuicDispatcher::NumSessions() const {
-  if (support_multiple_cid_per_connection_) {
-    return num_sessions_in_session_map_;
-  }
-  return reference_counted_session_map_.size();
+  return num_sessions_in_session_map_;
 }
 
 }  // namespace quic
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 71e3914..eab326a 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -164,10 +164,6 @@
 
   bool accept_new_connections() const { return accept_new_connections_; }
 
-  bool support_multiple_cid_per_connection() const {
-    return support_multiple_cid_per_connection_;
-  }
-
  protected:
   // Creates a QUIC session based on the given information.
   // |alpn| is the selected ALPN from |parsed_chlo.alpns|.
@@ -484,10 +480,6 @@
 
   const bool use_recent_reset_addresses_ =
       GetQuicRestartFlag(quic_use_recent_reset_addresses);
-
-  const bool support_multiple_cid_per_connection_ =
-      GetQuicRestartFlag(
-          quic_dispatcher_support_multiple_cid_per_connection_v2);
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 66cfcb3..d4af035 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -2186,8 +2186,6 @@
  public:
   QuicDispatcherSupportMultipleConnectionIdPerConnectionTest()
       : QuicDispatcherTestBase(crypto_test_utils::ProofSourceForTesting()) {
-    SetQuicRestartFlag(quic_dispatcher_support_multiple_cid_per_connection_v2,
-                       true);
     dispatcher_ = std::make_unique<NiceMock<TestDispatcher>>(
         &config_, &crypto_config_, &version_manager_,
         mock_helper_.GetRandomGenerator());
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 176f87c..475867d 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -87,8 +87,6 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_add_stream_info_to_idle_close_detail, true)
 // If true, pass the received PATH_RESPONSE payload to path validator to move forward the path validation.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_pass_path_response_to_validator, true)
-// If true, quic dispatcher supports one connection to use multiple connection IDs. 
-QUIC_FLAG(FLAGS_quic_restart_flag_quic_dispatcher_support_multiple_cid_per_connection_v2, true)
 // If true, quic server will send ENABLE_CONNECT_PROTOCOL setting and and endpoint will validate required request/response headers and extended CONNECT mechanism and update code counts of valid/invalid headers.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_verify_request_headers_2, true)
 // If true, record addresses that server has sent reset to recently, and do not send reset if the address lives in the set.
diff --git a/quic/test_tools/quic_connection_peer.cc b/quic/test_tools/quic_connection_peer.cc
index 57ce9d1..b511949 100644
--- a/quic/test_tools/quic_connection_peer.cc
+++ b/quic/test_tools/quic_connection_peer.cc
@@ -480,12 +480,6 @@
 }
 
 // static
-void QuicConnectionPeer::EnableMultipleConnectionIdSupport(
-    QuicConnection* connection) {
-  connection->support_multiple_connection_ids_ = true;
-}
-
-// static
 void QuicConnectionPeer::ResetPeerIssuedConnectionIdManager(
     QuicConnection* connection) {
   connection->peer_issued_cid_manager_ = nullptr;
diff --git a/quic/test_tools/quic_connection_peer.h b/quic/test_tools/quic_connection_peer.h
index 887ac8a..aa30c24 100644
--- a/quic/test_tools/quic_connection_peer.h
+++ b/quic/test_tools/quic_connection_peer.h
@@ -197,8 +197,6 @@
   static QuicByteCount BytesReceivedBeforeAddressValidation(
       QuicConnection* connection);
 
-  static void EnableMultipleConnectionIdSupport(QuicConnection* connection);
-
   static void ResetPeerIssuedConnectionIdManager(QuicConnection* connection);
 
   static QuicConnection::PathState* GetDefaultPath(QuicConnection* connection);