diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 1948077..fa06bcb 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -888,6 +888,40 @@
   return received_original_destination_connection_id_.value();
 }
 
+void QuicConfig::SetInitialSourceConnectionIdToSend(
+    const QuicConnectionId& initial_source_connection_id) {
+  initial_source_connection_id_to_send_ = initial_source_connection_id;
+}
+
+bool QuicConfig::HasReceivedInitialSourceConnectionId() const {
+  return received_initial_source_connection_id_.has_value();
+}
+
+QuicConnectionId QuicConfig::ReceivedInitialSourceConnectionId() const {
+  if (!HasReceivedInitialSourceConnectionId()) {
+    QUIC_BUG << "No received initial source connection ID";
+    return EmptyQuicConnectionId();
+  }
+  return received_initial_source_connection_id_.value();
+}
+
+void QuicConfig::SetRetrySourceConnectionIdToSend(
+    const QuicConnectionId& retry_source_connection_id) {
+  retry_source_connection_id_to_send_ = retry_source_connection_id;
+}
+
+bool QuicConfig::HasReceivedRetrySourceConnectionId() const {
+  return received_retry_source_connection_id_.has_value();
+}
+
+QuicConnectionId QuicConfig::ReceivedRetrySourceConnectionId() const {
+  if (!HasReceivedRetrySourceConnectionId()) {
+    QUIC_BUG << "No received retry source connection ID";
+    return EmptyQuicConnectionId();
+  }
+  return received_retry_source_connection_id_.value();
+}
+
 void QuicConfig::SetStatelessResetTokenToSend(
     QuicUint128 stateless_reset_token) {
   stateless_reset_token_.SetSendValue(stateless_reset_token);
@@ -1142,6 +1176,16 @@
         active_connection_id_limit_.GetSendValue());
   }
 
+  if (initial_source_connection_id_to_send_.has_value()) {
+    params->initial_source_connection_id =
+        initial_source_connection_id_to_send_.value();
+  }
+
+  if (retry_source_connection_id_to_send_.has_value()) {
+    params->retry_source_connection_id =
+        retry_source_connection_id_to_send_.value();
+  }
+
   if (GetQuicRestartFlag(quic_google_transport_param_send_new)) {
     QUIC_RESTART_FLAG_COUNT_N(quic_google_transport_param_send_new, 1, 3);
     if (initial_round_trip_time_us_.HasSendValue()) {
@@ -1264,6 +1308,17 @@
   active_connection_id_limit_.SetReceivedValue(
       params.active_connection_id_limit.value());
 
+  if (!is_resumption) {
+    if (params.initial_source_connection_id.has_value()) {
+      received_initial_source_connection_id_ =
+          params.initial_source_connection_id.value();
+    }
+    if (params.retry_source_connection_id.has_value()) {
+      received_retry_source_connection_id_ =
+          params.retry_source_connection_id.value();
+    }
+  }
+
   bool google_params_already_parsed = false;
   if (GetQuicRestartFlag(quic_google_transport_param_send_new)) {
     QUIC_RESTART_FLAG_COUNT_N(quic_google_transport_param_send_new, 2, 3);
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index b7206c3..4f302b6 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -438,6 +438,18 @@
   bool HasReceivedActiveConnectionIdLimit() const;
   uint64_t ReceivedActiveConnectionIdLimit() const;
 
+  // Initial source connection ID.
+  void SetInitialSourceConnectionIdToSend(
+      const QuicConnectionId& initial_source_connection_id);
+  bool HasReceivedInitialSourceConnectionId() const;
+  QuicConnectionId ReceivedInitialSourceConnectionId() const;
+
+  // Retry source connection ID.
+  void SetRetrySourceConnectionIdToSend(
+      const QuicConnectionId& retry_source_connection_id);
+  bool HasReceivedRetrySourceConnectionId() const;
+  QuicConnectionId ReceivedRetrySourceConnectionId() const;
+
   bool negotiated() const;
 
   void SetCreateSessionTagIndicators(QuicTagVector tags);
@@ -594,7 +606,8 @@
   // Uses the active_connection_id_limit transport parameter in IETF QUIC.
   QuicFixedUint62 active_connection_id_limit_;
 
-  // Sent by the server when it has previously sent a RETRY packet.
+  // The value of the Destination Connection ID field from the first
+  // Initial packet sent by the client.
   // Uses the original_destination_connection_id transport parameter in
   // IETF QUIC.
   quiche::QuicheOptional<QuicConnectionId>
@@ -602,6 +615,20 @@
   quiche::QuicheOptional<QuicConnectionId>
       received_original_destination_connection_id_;
 
+  // The value that the endpoint included in the Source Connection ID field of
+  // the first Initial packet it sent.
+  // Uses the initial_source_connection_id transport parameter in IETF QUIC.
+  quiche::QuicheOptional<QuicConnectionId>
+      initial_source_connection_id_to_send_;
+  quiche::QuicheOptional<QuicConnectionId>
+      received_initial_source_connection_id_;
+
+  // The value that the server included in the Source Connection ID field of a
+  // Retry packet it sent.
+  // Uses the retry_source_connection_id transport parameter in IETF QUIC.
+  quiche::QuicheOptional<QuicConnectionId> retry_source_connection_id_to_send_;
+  quiche::QuicheOptional<QuicConnectionId> received_retry_source_connection_id_;
+
   // Custom transport parameters that can be sent and received in the TLS
   // handshake.
   TransportParameters::ParameterMap custom_transport_parameters_to_send_;
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index 6d29cc9..4aa9619 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -468,6 +468,10 @@
   config_.SetMaxDatagramFrameSizeToSend(kMaxDatagramFrameSizeForTest);
   config_.SetActiveConnectionIdLimitToSend(kFakeActiveConnectionIdLimit);
 
+  config_.SetOriginalConnectionIdToSend(TestConnectionId(0x1111));
+  config_.SetInitialSourceConnectionIdToSend(TestConnectionId(0x2222));
+  config_.SetRetrySourceConnectionIdToSend(TestConnectionId(0x3333));
+
   TransportParameters params;
   config_.FillTransportParameters(&params);
 
@@ -486,6 +490,16 @@
             params.max_datagram_frame_size.value());
   EXPECT_EQ(kFakeActiveConnectionIdLimit,
             params.active_connection_id_limit.value());
+
+  ASSERT_TRUE(params.original_destination_connection_id.has_value());
+  EXPECT_EQ(TestConnectionId(0x1111),
+            params.original_destination_connection_id.value());
+  ASSERT_TRUE(params.initial_source_connection_id.has_value());
+  EXPECT_EQ(TestConnectionId(0x2222),
+            params.initial_source_connection_id.value());
+  ASSERT_TRUE(params.retry_source_connection_id.has_value());
+  EXPECT_EQ(TestConnectionId(0x3333),
+            params.retry_source_connection_id.value());
 }
 
 TEST_P(QuicConfigTest, ProcessTransportParametersServer) {
@@ -509,6 +523,9 @@
   params.max_ack_delay.set_value(kFakeMaxAckDelay);
   params.ack_delay_exponent.set_value(kFakeAckDelayExponent);
   params.active_connection_id_limit.set_value(kFakeActiveConnectionIdLimit);
+  params.original_destination_connection_id = TestConnectionId(0x1111);
+  params.initial_source_connection_id = TestConnectionId(0x2222);
+  params.retry_source_connection_id = TestConnectionId(0x3333);
 
   std::string error_details;
   EXPECT_THAT(config_.ProcessTransportParameters(
@@ -549,6 +566,9 @@
   EXPECT_FALSE(config_.HasReceivedStatelessResetToken());
   EXPECT_FALSE(config_.HasReceivedMaxAckDelayMs());
   EXPECT_FALSE(config_.HasReceivedAckDelayExponent());
+  EXPECT_FALSE(config_.HasReceivedOriginalConnectionId());
+  EXPECT_FALSE(config_.HasReceivedInitialSourceConnectionId());
+  EXPECT_FALSE(config_.HasReceivedRetrySourceConnectionId());
 
   // Let the config process another slightly tweaked transport paramters.
   // Note that the values for flow control and stream limit cannot be smaller
@@ -609,6 +629,15 @@
   ASSERT_TRUE(config_.HasReceivedActiveConnectionIdLimit());
   EXPECT_EQ(config_.ReceivedActiveConnectionIdLimit(),
             kFakeActiveConnectionIdLimit);
+
+  ASSERT_TRUE(config_.HasReceivedOriginalConnectionId());
+  EXPECT_EQ(config_.ReceivedOriginalConnectionId(), TestConnectionId(0x1111));
+  ASSERT_TRUE(config_.HasReceivedInitialSourceConnectionId());
+  EXPECT_EQ(config_.ReceivedInitialSourceConnectionId(),
+            TestConnectionId(0x2222));
+  ASSERT_TRUE(config_.HasReceivedRetrySourceConnectionId());
+  EXPECT_EQ(config_.ReceivedRetrySourceConnectionId(),
+            TestConnectionId(0x3333));
 }
 
 TEST_P(QuicConfigTest, DisableMigrationTransportParameter) {
diff --git a/quic/test_tools/quic_config_peer.cc b/quic/test_tools/quic_config_peer.cc
index 78904c4..b380642 100644
--- a/quic/test_tools/quic_config_peer.cc
+++ b/quic/test_tools/quic_config_peer.cc
@@ -112,6 +112,20 @@
 }
 
 // static
+void QuicConfigPeer::SetReceivedInitialSourceConnectionId(
+    QuicConfig* config,
+    const QuicConnectionId& initial_source_connection_id) {
+  config->received_initial_source_connection_id_ = initial_source_connection_id;
+}
+
+// static
+void QuicConfigPeer::SetReceivedRetrySourceConnectionId(
+    QuicConfig* config,
+    const QuicConnectionId& retry_source_connection_id) {
+  config->received_retry_source_connection_id_ = retry_source_connection_id;
+}
+
+// static
 void QuicConfigPeer::SetReceivedMaxDatagramFrameSize(
     QuicConfig* config,
     uint64_t max_datagram_frame_size) {
diff --git a/quic/test_tools/quic_config_peer.h b/quic/test_tools/quic_config_peer.h
index e72c429..a351907 100644
--- a/quic/test_tools/quic_config_peer.h
+++ b/quic/test_tools/quic_config_peer.h
@@ -66,6 +66,14 @@
       QuicConfig* config,
       const QuicConnectionId& original_destination_connection_id);
 
+  static void SetReceivedInitialSourceConnectionId(
+      QuicConfig* config,
+      const QuicConnectionId& initial_source_connection_id);
+
+  static void SetReceivedRetrySourceConnectionId(
+      QuicConfig* config,
+      const QuicConnectionId& retry_source_connection_id);
+
   static void SetReceivedMaxDatagramFrameSize(QuicConfig* config,
                                               uint64_t max_datagram_frame_size);
 };