diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 209bc81..c72622c 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -210,8 +210,9 @@
         chlo_multiplier_(0),
         stream_factory_(nullptr),
         support_server_push_(false),
-        override_connection_id_(nullptr),
-        expected_connection_id_length_(kQuicDefaultConnectionIdLength) {
+        override_server_connection_id_(nullptr),
+        override_client_connection_id_(nullptr),
+        expected_server_connection_id_length_(kQuicDefaultConnectionIdLength) {
     SetQuicFlag(FLAGS_quic_supports_tls_handshake, true);
     SetQuicRestartFlag(quic_no_server_conn_ver_negotiation2, true);
     SetQuicReloadableFlag(quic_no_client_conn_ver_negotiation, true);
@@ -258,8 +259,11 @@
     if (!pre_shared_key_client_.empty()) {
       client->client()->SetPreSharedKey(pre_shared_key_client_);
     }
-    if (override_connection_id_ != nullptr) {
-      client->UseConnectionId(*override_connection_id_);
+    if (override_server_connection_id_ != nullptr) {
+      client->UseConnectionId(*override_server_connection_id_);
+    }
+    if (override_client_connection_id_ != nullptr) {
+      client->UseClientConnectionId(*override_client_connection_id_);
     }
     client->Connect();
     return client;
@@ -374,7 +378,7 @@
     auto* test_server = new QuicTestServer(
         crypto_test_utils::ProofSourceForTesting(), server_config_,
         server_supported_versions_, &memory_cache_backend_,
-        expected_connection_id_length_);
+        expected_server_connection_id_length_);
     server_thread_ = QuicMakeUnique<ServerThread>(test_server, server_address_);
     if (chlo_multiplier_ != 0) {
       server_thread_->server()->SetChloMultiplier(chlo_multiplier_);
@@ -537,8 +541,9 @@
   bool support_server_push_;
   std::string pre_shared_key_client_;
   std::string pre_shared_key_server_;
-  QuicConnectionId* override_connection_id_;
-  uint8_t expected_connection_id_length_;
+  QuicConnectionId* override_server_connection_id_;
+  QuicConnectionId* override_client_connection_id_;
+  uint8_t expected_server_connection_id_length_;
 };
 
 // Run all end to end tests with all supported versions.
@@ -602,8 +607,8 @@
 TEST_P(EndToEndTest, SimpleRequestResponseZeroConnectionID) {
   QuicConnectionId connection_id = QuicUtils::CreateZeroConnectionId(
       GetParam().negotiated_version.transport_version);
-  override_connection_id_ = &connection_id;
-  expected_connection_id_length_ = connection_id.length();
+  override_server_connection_id_ = &connection_id;
+  expected_server_connection_id_length_ = connection_id.length();
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
@@ -627,7 +632,7 @@
   }
   QuicConnectionId connection_id =
       TestConnectionIdNineBytesLong(UINT64_C(0xBADbadBADbad));
-  override_connection_id_ = &connection_id;
+  override_server_connection_id_ = &connection_id;
   ASSERT_TRUE(Initialize());
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
@@ -638,6 +643,43 @@
                                                 .length());
 }
 
+TEST_P(EndToEndTest, ClientConnectionId) {
+  if (!GetParam().negotiated_version.SupportsClientConnectionIds()) {
+    ASSERT_TRUE(Initialize());
+    return;
+  }
+  QuicConnectionId client_connection_id =
+      TestConnectionId(UINT64_C(0xc1c2c3c4c5c6c7c8));
+  override_client_connection_id_ = &client_connection_id;
+  ASSERT_TRUE(Initialize());
+  EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
+  EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
+  EXPECT_EQ(client_connection_id, client_->client()
+                                      ->client_session()
+                                      ->connection()
+                                      ->client_connection_id());
+}
+
+TEST_P(EndToEndTest, ForcedVersionNegotiationAndClientConnectionId) {
+  if (!GetParam().negotiated_version.SupportsClientConnectionIds()) {
+    ASSERT_TRUE(Initialize());
+    return;
+  }
+  client_supported_versions_.insert(client_supported_versions_.begin(),
+                                    QuicVersionReservedForNegotiation());
+  QuicConnectionId client_connection_id =
+      TestConnectionId(UINT64_C(0xc1c2c3c4c5c6c7c8));
+  override_client_connection_id_ = &client_connection_id;
+  ASSERT_TRUE(Initialize());
+  ASSERT_TRUE(ServerSendsVersionNegotiation());
+  EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
+  EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
+  EXPECT_EQ(client_connection_id, client_->client()
+                                      ->client_session()
+                                      ->connection()
+                                      ->client_connection_id());
+}
+
 TEST_P(EndToEndTest, ForcedVersionNegotiationAndBadConnectionIdLength) {
   if (!GetQuicRestartFlag(
           quic_allow_variable_length_connection_id_for_negotiation)) {
@@ -653,7 +695,7 @@
                                     QuicVersionReservedForNegotiation());
   QuicConnectionId connection_id =
       TestConnectionIdNineBytesLong(UINT64_C(0xBADbadBADbad));
-  override_connection_id_ = &connection_id;
+  override_server_connection_id_ = &connection_id;
   ASSERT_TRUE(Initialize());
   ASSERT_TRUE(ServerSendsVersionNegotiation());
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
@@ -675,9 +717,9 @@
   // Start client_ which will use a bad connection ID length.
   QuicConnectionId connection_id =
       TestConnectionIdNineBytesLong(UINT64_C(0xBADbadBADbad));
-  override_connection_id_ = &connection_id;
+  override_server_connection_id_ = &connection_id;
   ASSERT_TRUE(Initialize());
-  override_connection_id_ = nullptr;
+  override_server_connection_id_ = nullptr;
 
   // Start client2 which will use a good connection ID length.
   std::unique_ptr<QuicTestClient> client2(CreateQuicClient(nullptr));
@@ -766,8 +808,8 @@
 TEST_P(EndToEndTest, MultipleRequestResponseZeroConnectionID) {
   QuicConnectionId connection_id = QuicUtils::CreateZeroConnectionId(
       GetParam().negotiated_version.transport_version);
-  override_connection_id_ = &connection_id;
-  expected_connection_id_length_ = connection_id.length();
+  override_server_connection_id_ = &connection_id;
+  expected_server_connection_id_length_ = connection_id.length();
   ASSERT_TRUE(Initialize());
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
@@ -2318,7 +2360,7 @@
       TestConnectionIdToUInt64(client_connection->connection_id()) + 1);
   std::unique_ptr<QuicEncryptedPacket> packet(
       QuicFramer::BuildVersionNegotiationPacket(
-          incorrect_connection_id,
+          incorrect_connection_id, EmptyQuicConnectionId(),
           client_connection->transport_version() > QUIC_VERSION_43,
           server_supported_versions_));
   testing::NiceMock<MockQuicConnectionDebugVisitor> visitor;
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 77d105c..0d6b36c 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -504,7 +504,7 @@
   session_->ProcessUdpPacket(client_address, server_address, valid_packet);
 
   // Verify that a non-decryptable packet doesn't close the connection.
-  QuicFramerPeer::SetLastSerializedConnectionId(
+  QuicFramerPeer::SetLastSerializedServerConnectionId(
       QuicConnectionPeer::GetFramer(connection_), connection_id);
   ParsedQuicVersionVector versions = SupportedVersions(GetParam());
   QuicConnectionId destination_connection_id = EmptyQuicConnectionId();
@@ -549,7 +549,7 @@
   QuicConnectionId destination_connection_id =
       session_->connection()->connection_id();
   QuicConnectionId source_connection_id = EmptyQuicConnectionId();
-  QuicFramerPeer::SetLastSerializedConnectionId(
+  QuicFramerPeer::SetLastSerializedServerConnectionId(
       QuicConnectionPeer::GetFramer(connection_), destination_connection_id);
   ParsedQuicVersionVector versions = {GetParam()};
   bool version_flag = false;
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index e61bae4..169b17b 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -219,7 +219,7 @@
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
 QuicConnection::QuicConnection(
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
     QuicSocketAddress initial_peer_address,
     QuicConnectionHelperInterface* helper,
     QuicAlarmFactory* alarm_factory,
@@ -230,7 +230,7 @@
     : framer_(supported_versions,
               helper->GetClock()->ApproximateNow(),
               perspective,
-              connection_id.length()),
+              server_connection_id.length()),
       current_packet_content_(NO_FRAMES_RECEIVED),
       is_current_packet_connectivity_probing_(false),
       current_effective_peer_migration_type_(NO_CHANGE),
@@ -242,7 +242,7 @@
       encryption_level_(ENCRYPTION_INITIAL),
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
-      connection_id_(connection_id),
+      server_connection_id_(server_connection_id),
       peer_address_(initial_peer_address),
       direct_peer_address_(initial_peer_address),
       active_effective_peer_migration_type_(NO_CHANGE),
@@ -302,7 +302,10 @@
           &arena_)),
       visitor_(nullptr),
       debug_visitor_(nullptr),
-      packet_generator_(connection_id_, &framer_, random_generator_, this),
+      packet_generator_(server_connection_id_,
+                        &framer_,
+                        random_generator_,
+                        this),
       idle_network_timeout_(QuicTime::Delta::Infinite()),
       handshake_timeout_(QuicTime::Delta::Infinite()),
       time_of_first_packet_sent_after_receiving_(
@@ -373,14 +376,14 @@
   if (use_uber_received_packet_manager_) {
     QUIC_RELOADABLE_FLAG_COUNT(quic_use_uber_received_packet_manager);
   }
-  QUIC_DLOG(INFO) << ENDPOINT
-                  << "Created connection with connection_id: " << connection_id
+  QUIC_DLOG(INFO) << ENDPOINT << "Created connection with server connection ID "
+                  << server_connection_id
                   << " and version: " << ParsedQuicVersionToString(version());
 
-  QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(connection_id,
+  QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(server_connection_id,
                                                         transport_version()))
-      << "QuicConnection: attempted to use connection ID " << connection_id
-      << " which is invalid with version "
+      << "QuicConnection: attempted to use server connection ID "
+      << server_connection_id << " which is invalid with version "
       << QuicVersionToString(transport_version());
 
   framer_.set_visitor(this);
@@ -444,7 +447,7 @@
   sent_packet_manager_.SetFromConfig(config);
   if (config.HasReceivedBytesForConnectionId() &&
       can_truncate_connection_ids_) {
-    packet_generator_.SetConnectionIdLength(
+    packet_generator_.SetServerConnectionIdLength(
         config.ReceivedBytesForConnectionId());
   }
   max_undecryptable_packets_ = config.max_undecryptable_packets();
@@ -592,7 +595,7 @@
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.  (Check for a bug regression.)
-  DCHECK_EQ(connection_id_, packet.connection_id);
+  DCHECK_EQ(server_connection_id_, packet.connection_id);
   DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPublicResetPacket(packet);
@@ -683,7 +686,7 @@
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.  (Check for a bug regression.)
-  DCHECK_EQ(connection_id_, packet.connection_id);
+  DCHECK_EQ(server_connection_id_, packet.connection_id);
   if (perspective_ == Perspective::IS_SERVER) {
     const std::string error_details =
         "Server received version negotiation packet.";
@@ -766,10 +769,10 @@
 void QuicConnection::OnRetryPacket(QuicConnectionId original_connection_id,
                                    QuicConnectionId new_connection_id,
                                    QuicStringPiece retry_token) {
-  if (original_connection_id != connection_id_) {
+  if (original_connection_id != server_connection_id_) {
     QUIC_DLOG(ERROR) << "Ignoring RETRY with original connection ID "
                      << original_connection_id << " not matching expected "
-                     << connection_id_ << " token "
+                     << server_connection_id_ << " token "
                      << QuicTextUtils::HexEncode(retry_token);
     return;
   }
@@ -780,17 +783,18 @@
   }
   retry_has_been_parsed_ = true;
   QUIC_DLOG(INFO) << "Received RETRY, replacing connection ID "
-                  << connection_id_ << " with " << new_connection_id
+                  << server_connection_id_ << " with " << new_connection_id
                   << ", received token "
                   << QuicTextUtils::HexEncode(retry_token);
-  connection_id_ = new_connection_id;
-  packet_generator_.SetConnectionId(connection_id_);
+  server_connection_id_ = new_connection_id;
+  packet_generator_.SetServerConnectionId(server_connection_id_);
   packet_generator_.SetRetryToken(retry_token);
 
   // Reinstall initial crypters because the connection ID changed.
   CrypterPair crypters;
-  CryptoUtils::CreateTlsInitialCrypters(
-      Perspective::IS_CLIENT, transport_version(), connection_id_, &crypters);
+  CryptoUtils::CreateTlsInitialCrypters(Perspective::IS_CLIENT,
+                                        transport_version(),
+                                        server_connection_id_, &crypters);
   SetEncrypter(ENCRYPTION_INITIAL, std::move(crypters.encrypter));
   InstallDecrypter(ENCRYPTION_INITIAL, std::move(crypters.decrypter));
 }
@@ -817,29 +821,53 @@
   QuicConnectionId server_connection_id =
       GetServerConnectionIdAsRecipient(header, perspective_);
 
-  if (server_connection_id == connection_id_ ||
-      HasIncomingConnectionId(server_connection_id)) {
+  if (server_connection_id != server_connection_id_ &&
+      !HasIncomingConnectionId(server_connection_id)) {
+    if (PacketCanReplaceConnectionId(header, perspective_)) {
+      QUIC_DLOG(INFO) << ENDPOINT << "Accepting packet with new connection ID "
+                      << server_connection_id << " instead of "
+                      << server_connection_id_;
+      return true;
+    }
+
+    ++stats_.packets_dropped;
+    QUIC_DLOG(INFO)
+        << ENDPOINT << "Ignoring packet from unexpected server connection ID "
+        << server_connection_id << " instead of " << server_connection_id_;
+    QUIC_BUG
+        << ENDPOINT << "Ignoring packet from unexpected server connection ID "
+        << server_connection_id << " instead of " << server_connection_id_
+    << " header " << header;
+    if (debug_visitor_ != nullptr) {
+      debug_visitor_->OnIncorrectConnectionId(server_connection_id);
+    }
+    // If this is a server, the dispatcher routes each packet to the
+    // QuicConnection responsible for the packet's connection ID.  So if control
+    // arrives here and this is a server, the dispatcher must be malfunctioning.
+    DCHECK_NE(Perspective::IS_SERVER, perspective_);
+    return false;
+  }
+
+  if (!version().SupportsClientConnectionIds()) {
     return true;
   }
 
-  if (PacketCanReplaceConnectionId(header, perspective_)) {
-    QUIC_DLOG(INFO) << ENDPOINT << "Accepting packet with new connection ID "
-                    << server_connection_id << " instead of " << connection_id_;
-    return true;
+  QuicConnectionId client_connection_id =
+      GetClientConnectionIdAsRecipient(header, perspective_);
+
+  if (client_connection_id != client_connection_id_) {
+    ++stats_.packets_dropped;
+    QUIC_DLOG(INFO)
+        << ENDPOINT << "Ignoring packet from unexpected client connection ID "
+        << client_connection_id << " instead of " << client_connection_id_;
+    QUIC_BUG
+        << ENDPOINT << "Ignoring packet from unexpected client connection ID "
+        << client_connection_id << " instead of " << client_connection_id_
+    << " header " << header;
+    return false;
   }
 
-  ++stats_.packets_dropped;
-  QUIC_DLOG(INFO) << ENDPOINT
-                  << "Ignoring packet from unexpected ConnectionId: "
-                  << server_connection_id << " instead of " << connection_id_;
-  if (debug_visitor_ != nullptr) {
-    debug_visitor_->OnIncorrectConnectionId(server_connection_id);
-  }
-  // If this is a server, the dispatcher routes each packet to the
-  // QuicConnection responsible for the packet's connection ID.  So if control
-  // arrives here and this is a server, the dispatcher must be malfunctioning.
-  DCHECK_NE(Perspective::IS_SERVER, perspective_);
-  return false;
+  return true;
 }
 
 bool QuicConnection::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
@@ -851,7 +879,7 @@
   // routed to this QuicConnection has been redirected before control reaches
   // here.
   DCHECK(GetServerConnectionIdAsRecipient(header, perspective_) ==
-             connection_id_ ||
+             server_connection_id_ ||
          HasIncomingConnectionId(
              GetServerConnectionIdAsRecipient(header, perspective_)) ||
          PacketCanReplaceConnectionId(header, perspective_));
@@ -1109,7 +1137,7 @@
                    << " packet_number:" << last_header_.packet_number
                    << " largest seen with ack:"
                    << GetLargestReceivedPacketWithAck()
-                   << " connection_id: " << connection_id_;
+                   << " server_connection_id: " << server_connection_id_;
     // A new ack has a diminished largest_observed value.
     // If this was an old packet, we wouldn't even have checked.
     CloseConnection(QUIC_INVALID_ACK_DATA, "Largest observed too low.",
@@ -2132,11 +2160,12 @@
   }
 
   if (PacketCanReplaceConnectionId(header, perspective_) &&
-      connection_id_ != header.source_connection_id) {
-    QUIC_DLOG(INFO) << ENDPOINT << "Replacing connection ID " << connection_id_
-                    << " with " << header.source_connection_id;
-    connection_id_ = header.source_connection_id;
-    packet_generator_.SetConnectionId(connection_id_);
+      server_connection_id_ != header.source_connection_id) {
+    QUIC_DLOG(INFO) << ENDPOINT << "Replacing connection ID "
+                    << server_connection_id_ << " with "
+                    << header.source_connection_id;
+    server_connection_id_ = header.source_connection_id;
+    packet_generator_.SetServerConnectionId(server_connection_id_);
   }
 
   if (!ValidateReceivedPacketNumber(header.packet_number)) {
@@ -3578,7 +3607,7 @@
 
   QUIC_DLOG(INFO) << ENDPOINT
                   << "Sending path probe packet for connection_id = "
-                  << connection_id_;
+                  << server_connection_id_;
 
   OwningSerializedPacketPointer probing_packet;
   if (transport_version() != QUIC_VERSION_99) {
@@ -4215,5 +4244,22 @@
   return received_packet_manager_.ack_frame();
 }
 
+void QuicConnection::set_client_connection_id(
+    QuicConnectionId client_connection_id) {
+  if (!version().SupportsClientConnectionIds()) {
+    QUIC_BUG_IF(!client_connection_id.IsEmpty())
+        << ENDPOINT << "Attempted to use client connection ID "
+        << client_connection_id << " with unsupported version " << version();
+    return;
+  }
+  client_connection_id_ = client_connection_id;
+  QUIC_DLOG(INFO) << ENDPOINT << "setting client connection ID to "
+                  << client_connection_id_
+                  << " for connection with server connection ID "
+                  << server_connection_id_;
+  packet_generator_.SetClientConnectionId(client_connection_id_);
+  framer_.SetExpectedClientConnectionIdLength(client_connection_id_.length());
+}
+
 #undef ENDPOINT  // undef for jumbo builds
 }  // namespace quic
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 8c8ed2b..00902a9 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -341,7 +341,7 @@
   // |initial_peer_address| using |writer| to write packets. |owns_writer|
   // specifies whether the connection takes ownership of |writer|. |helper| must
   // outlive this connection.
-  QuicConnection(QuicConnectionId connection_id,
+  QuicConnection(QuicConnectionId server_connection_id,
                  QuicSocketAddress initial_peer_address,
                  QuicConnectionHelperInterface* helper,
                  QuicAlarmFactory* alarm_factory,
@@ -582,7 +582,11 @@
   const QuicSocketAddress& effective_peer_address() const {
     return effective_peer_address_;
   }
-  QuicConnectionId connection_id() const { return connection_id_; }
+  QuicConnectionId connection_id() const { return server_connection_id_; }
+  QuicConnectionId client_connection_id() const {
+    return client_connection_id_;
+  }
+  void set_client_connection_id(QuicConnectionId client_connection_id);
   const QuicClock* clock() const { return clock_; }
   QuicRandom* random_generator() const { return random_generator_; }
   QuicByteCount max_packet_length() const;
@@ -1168,7 +1172,8 @@
   const QuicClock* clock_;
   QuicRandom* random_generator_;
 
-  QuicConnectionId connection_id_;
+  QuicConnectionId server_connection_id_;
+  QuicConnectionId client_connection_id_;
   // Address on the last successfully processed packet received from the
   // direct peer.
   QuicSocketAddress self_address_;
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 4ecb780..5c98970 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -938,7 +938,7 @@
       peer_creator_.SetEncrypter(
           level, QuicMakeUnique<NullEncrypter>(peer_framer_.perspective()));
     }
-    QuicFramerPeer::SetLastSerializedConnectionId(
+    QuicFramerPeer::SetLastSerializedServerConnectionId(
         QuicConnectionPeer::GetFramer(&connection_), connection_id_);
     if (version().transport_version > QUIC_VERSION_43) {
       EXPECT_TRUE(QuicConnectionPeer::GetNoStopWaitingFrames(&connection_));
@@ -6877,7 +6877,8 @@
   // Send a version negotiation packet.
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       peer_framer_.BuildVersionNegotiationPacket(
-          connection_id_, connection_.transport_version() > QUIC_VERSION_43,
+          connection_id_, EmptyQuicConnectionId(),
+          connection_.transport_version() > QUIC_VERSION_43,
           AllSupportedVersions()));
   std::unique_ptr<QuicReceivedPacket> received(
       ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 9af5f84..b57f398 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -115,17 +115,17 @@
 // list manager.
 class StatelessConnectionTerminator {
  public:
-  StatelessConnectionTerminator(QuicConnectionId connection_id,
+  StatelessConnectionTerminator(QuicConnectionId server_connection_id,
                                 const ParsedQuicVersion version,
                                 QuicConnectionHelperInterface* helper,
                                 QuicTimeWaitListManager* time_wait_list_manager)
-      : connection_id_(connection_id),
+      : server_connection_id_(server_connection_id),
         framer_(ParsedQuicVersionVector{version},
                 /*unused*/ QuicTime::Zero(),
                 Perspective::IS_SERVER,
                 /*unused*/ kQuicDefaultConnectionIdLength),
         collector_(helper->GetStreamSendBufferAllocator()),
-        creator_(connection_id, &framer_, &collector_),
+        creator_(server_connection_id, &framer_, &collector_),
         time_wait_list_manager_(time_wait_list_manager) {
     framer_.set_data_producer(&collector_);
   }
@@ -154,7 +154,7 @@
     creator_.Flush();
     DCHECK_EQ(1u, collector_.packets()->size());
     time_wait_list_manager_->AddConnectionIdToTimeWait(
-        connection_id_, ietf_quic,
+        server_connection_id_, ietf_quic,
         QuicTimeWaitListManager::SEND_TERMINATION_PACKETS,
         quic::ENCRYPTION_INITIAL, collector_.packets());
   }
@@ -195,14 +195,15 @@
       creator_.Flush();
     }
     time_wait_list_manager_->AddConnectionIdToTimeWait(
-        connection_id_, ietf_quic,
+        server_connection_id_, ietf_quic,
         QuicTimeWaitListManager::SEND_TERMINATION_PACKETS, ENCRYPTION_INITIAL,
         collector_.packets());
-    DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id_));
+    DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(
+        server_connection_id_));
   }
 
  private:
-  QuicConnectionId connection_id_;
+  QuicConnectionId server_connection_id_;
   QuicFramer framer_;
   // Set as the visitor of |creator_| to collect any generated packets.
   PacketCollector collector_;
@@ -214,7 +215,7 @@
 class ChloAlpnExtractor : public ChloExtractor::Delegate {
  public:
   void OnChlo(QuicTransportVersion version,
-              QuicConnectionId connection_id,
+              QuicConnectionId server_connection_id,
               const CryptoHandshakeMessage& chlo) override {
     QuicStringPiece alpn_value;
     if (chlo.GetStringPiece(kALPN, &alpn_value)) {
@@ -247,16 +248,17 @@
 
   // ChloExtractor::Delegate implementation.
   void OnChlo(QuicTransportVersion version,
-              QuicConnectionId connection_id,
+              QuicConnectionId server_connection_id,
               const CryptoHandshakeMessage& chlo) override {
     // Extract the ALPN
-    ChloAlpnExtractor::OnChlo(version, connection_id, chlo);
+    ChloAlpnExtractor::OnChlo(version, server_connection_id, chlo);
     if (helper_->CanAcceptClientHello(chlo, client_address_, peer_address_,
                                       self_address_, &error_details_)) {
       can_accept_ = true;
       rejector_->OnChlo(
-          version, connection_id,
-          helper_->GenerateConnectionIdForReject(version, connection_id), chlo);
+          version, server_connection_id,
+          helper_->GenerateConnectionIdForReject(version, server_connection_id),
+          chlo);
     }
   }
 
@@ -285,7 +287,7 @@
     std::unique_ptr<QuicConnectionHelperInterface> helper,
     std::unique_ptr<QuicCryptoServerStream::Helper> session_helper,
     std::unique_ptr<QuicAlarmFactory> alarm_factory,
-    uint8_t expected_connection_id_length)
+    uint8_t expected_server_connection_id_length)
     : config_(config),
       crypto_config_(crypto_config),
       compressed_certs_cache_(
@@ -301,14 +303,15 @@
       framer_(GetSupportedVersions(),
               /*unused*/ QuicTime::Zero(),
               Perspective::IS_SERVER,
-              expected_connection_id_length),
+              expected_server_connection_id_length),
       last_error_(QUIC_NO_ERROR),
       new_sessions_allowed_per_event_loop_(0u),
       accept_new_connections_(true),
-      allow_short_initial_connection_ids_(false),
+      allow_short_initial_server_connection_ids_(false),
       last_version_label_(0),
-      expected_connection_id_length_(expected_connection_id_length),
-      should_update_expected_connection_id_length_(false),
+      expected_server_connection_id_length_(
+          expected_server_connection_id_length),
+      should_update_expected_server_connection_id_length_(false),
       no_framer_(GetQuicRestartFlag(quic_no_framer_object_in_dispatcher)) {
   if (!no_framer_) {
     framer_.set_visitor(this);
@@ -345,12 +348,11 @@
   }
   QUIC_RESTART_FLAG_COUNT(quic_no_framer_object_in_dispatcher);
   QuicPacketHeader header;
-  uint8_t destination_connection_id_length;
   std::string detailed_error;
   const QuicErrorCode error = QuicFramer::ProcessPacketDispatcher(
-      packet, expected_connection_id_length_, &header.form,
+      packet, expected_server_connection_id_length_, &header.form,
       &header.version_flag, &last_version_label_,
-      &destination_connection_id_length, &header.destination_connection_id,
+      &header.destination_connection_id, &header.source_connection_id,
       &detailed_error);
   if (error != QUIC_NO_ERROR) {
     // Packet has framing error.
@@ -359,16 +361,18 @@
     return;
   }
   header.version = ParseQuicVersionLabel(last_version_label_);
-  if (destination_connection_id_length != expected_connection_id_length_ &&
-      !should_update_expected_connection_id_length_ &&
+  if (header.destination_connection_id.length() !=
+          expected_server_connection_id_length_ &&
+      !should_update_expected_server_connection_id_length_ &&
       !QuicUtils::VariableLengthConnectionIdAllowedForVersion(
           header.version.transport_version)) {
     SetLastError(QUIC_INVALID_PACKET_HEADER);
     QUIC_DLOG(ERROR) << "Invalid Connection Id Length";
     return;
   }
-  if (should_update_expected_connection_id_length_) {
-    expected_connection_id_length_ = destination_connection_id_length;
+  if (should_update_expected_server_connection_id_length_) {
+    expected_server_connection_id_length_ =
+        header.destination_connection_id.length();
   }
   // TODO(fayang): Instead of passing in QuicPacketHeader, pass format,
   // version_flag, version and destination_connection_id. Combine
@@ -382,34 +386,36 @@
   //            the next packet does not use them incorrectly.
 }
 
-QuicConnectionId QuicDispatcher::MaybeReplaceConnectionId(
-    QuicConnectionId connection_id,
+QuicConnectionId QuicDispatcher::MaybeReplaceServerConnectionId(
+    QuicConnectionId server_connection_id,
     ParsedQuicVersion version) {
-  const uint8_t expected_connection_id_length =
-      no_framer_ ? expected_connection_id_length_
-                 : framer_.GetExpectedConnectionIdLength();
-  if (connection_id.length() == expected_connection_id_length) {
-    return connection_id;
+  const uint8_t expected_server_connection_id_length =
+      no_framer_ ? expected_server_connection_id_length_
+                 : framer_.GetExpectedServerConnectionIdLength();
+  if (server_connection_id.length() == expected_server_connection_id_length) {
+    return server_connection_id;
   }
   DCHECK(QuicUtils::VariableLengthConnectionIdAllowedForVersion(
       version.transport_version));
-  auto it = connection_id_map_.find(connection_id);
+  auto it = connection_id_map_.find(server_connection_id);
   if (it != connection_id_map_.end()) {
     return it->second;
   }
   QuicConnectionId new_connection_id =
       session_helper_->GenerateConnectionIdForReject(version.transport_version,
-                                                     connection_id);
-  DCHECK_EQ(expected_connection_id_length, new_connection_id.length());
-  connection_id_map_.insert(std::make_pair(connection_id, new_connection_id));
-  QUIC_DLOG(INFO) << "Replacing incoming connection ID " << connection_id
+                                                     server_connection_id);
+  DCHECK_EQ(expected_server_connection_id_length, new_connection_id.length());
+  connection_id_map_.insert(
+      std::make_pair(server_connection_id, new_connection_id));
+  QUIC_DLOG(INFO) << "Replacing incoming connection ID " << server_connection_id
                   << " with " << new_connection_id;
   return new_connection_id;
 }
 
 bool QuicDispatcher::OnUnauthenticatedPublicHeader(
     const QuicPacketHeader& header) {
-  current_connection_id_ = header.destination_connection_id;
+  current_server_connection_id_ = header.destination_connection_id;
+  current_client_connection_id_ = header.source_connection_id;
 
   // Port zero is only allowed for unidirectional UDP, so is disallowed by QUIC.
   // Given that we can't even send a reply rejecting the packet, just drop the
@@ -423,52 +429,54 @@
   if (header.destination_connection_id_included != CONNECTION_ID_PRESENT) {
     return false;
   }
-  QuicConnectionId connection_id = header.destination_connection_id;
+  QuicConnectionId server_connection_id = header.destination_connection_id;
+  QuicConnectionId client_connection_id = header.source_connection_id;
 
   // The IETF spec requires the client to generate an initial server
   // connection ID that is at least 64 bits long. After that initial
   // connection ID, the dispatcher picks a new one of its expected length.
   // Therefore we should never receive a connection ID that is smaller
   // than 64 bits and smaller than what we expect.
-  const uint8_t expected_connection_id_length =
-      no_framer_ ? expected_connection_id_length_
-                 : framer_.GetExpectedConnectionIdLength();
-  if (connection_id.length() < kQuicMinimumInitialConnectionIdLength &&
-      connection_id.length() < expected_connection_id_length &&
-      !allow_short_initial_connection_ids_) {
+  const uint8_t expected_server_connection_id_length =
+      no_framer_ ? expected_server_connection_id_length_
+                 : framer_.GetExpectedServerConnectionIdLength();
+  if (server_connection_id.length() < kQuicMinimumInitialConnectionIdLength &&
+      server_connection_id.length() < expected_server_connection_id_length &&
+      !allow_short_initial_server_connection_ids_) {
     DCHECK(header.version_flag);
     DCHECK(QuicUtils::VariableLengthConnectionIdAllowedForVersion(
         header.version.transport_version));
     QUIC_DLOG(INFO) << "Packet with short destination connection ID "
-                    << connection_id << " expected "
-                    << static_cast<int>(expected_connection_id_length);
-    ProcessUnauthenticatedHeaderFate(kFateTimeWait, connection_id, header.form,
-                                     header.version_flag, header.version);
+                    << server_connection_id << " expected "
+                    << static_cast<int>(expected_server_connection_id_length);
+    ProcessUnauthenticatedHeaderFate(kFateTimeWait, server_connection_id,
+                                     header.form, header.version_flag,
+                                     header.version);
     return false;
   }
 
   // Packets with connection IDs for active connections are processed
   // immediately.
-  auto it = session_map_.find(connection_id);
+  auto it = session_map_.find(server_connection_id);
   if (it != session_map_.end()) {
-    DCHECK(!buffered_packets_.HasBufferedPackets(connection_id));
+    DCHECK(!buffered_packets_.HasBufferedPackets(server_connection_id));
     it->second->ProcessUdpPacket(current_self_address_, current_peer_address_,
                                  *current_packet_);
     return false;
   }
 
-  if (buffered_packets_.HasChloForConnection(connection_id)) {
-    BufferEarlyPacket(connection_id, header.form != GOOGLE_QUIC_PACKET,
+  if (buffered_packets_.HasChloForConnection(server_connection_id)) {
+    BufferEarlyPacket(server_connection_id, header.form != GOOGLE_QUIC_PACKET,
                       header.version);
     return false;
   }
 
   // Check if we are buffering packets for this connection ID
-  if (temporarily_buffered_connections_.find(connection_id) !=
+  if (temporarily_buffered_connections_.find(server_connection_id) !=
       temporarily_buffered_connections_.end()) {
     // This packet was received while the a CHLO for the same connection ID was
     // being processed.  Buffer it.
-    BufferEarlyPacket(connection_id, header.form != GOOGLE_QUIC_PACKET,
+    BufferEarlyPacket(server_connection_id, header.form != GOOGLE_QUIC_PACKET,
                       header.version);
     return false;
   }
@@ -483,7 +491,7 @@
     return false;
   }
 
-  if (time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
+  if (time_wait_list_manager_->IsConnectionIdInTimeWait(server_connection_id)) {
     // This connection ID is already in time-wait state.
     time_wait_list_manager_->ProcessPacket(
         current_self_address_, current_peer_address_,
@@ -513,9 +521,10 @@
         // Since the version is not supported, send a version negotiation
         // packet and stop processing the current packet.
         time_wait_list_manager()->SendVersionNegotiationPacket(
-            connection_id, header.form != GOOGLE_QUIC_PACKET,
-            GetSupportedVersions(), current_self_address_,
-            current_peer_address_, GetPerPacketContext());
+            server_connection_id, client_connection_id,
+            header.form != GOOGLE_QUIC_PACKET, GetSupportedVersions(),
+            current_self_address_, current_peer_address_,
+            GetPerPacketContext());
       }
       return false;
     }
@@ -539,25 +548,25 @@
 }
 
 void QuicDispatcher::ProcessHeader(const QuicPacketHeader& header) {
-  QuicConnectionId connection_id = header.destination_connection_id;
+  QuicConnectionId server_connection_id = header.destination_connection_id;
   // Packet's connection ID is unknown.  Apply the validity checks.
   QuicPacketFate fate = ValidityChecks(header);
   if (fate == kFateProcess) {
     // Execute stateless rejection logic to determine the packet fate, then
     // invoke ProcessUnauthenticatedHeaderFate.
-    MaybeRejectStatelessly(connection_id, header.form, header.version_flag,
-                           header.version);
+    MaybeRejectStatelessly(server_connection_id, header.form,
+                           header.version_flag, header.version);
   } else {
     // If the fate is already known, process it without executing stateless
     // rejection logic.
-    ProcessUnauthenticatedHeaderFate(fate, connection_id, header.form,
+    ProcessUnauthenticatedHeaderFate(fate, server_connection_id, header.form,
                                      header.version_flag, header.version);
   }
 }
 
 void QuicDispatcher::ProcessUnauthenticatedHeaderFate(
     QuicPacketFate fate,
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
     PacketHeaderFormat form,
     bool version_flag,
     ParsedQuicVersion version) {
@@ -570,33 +579,36 @@
       // MaybeRejectStatelessly or OnExpiredPackets might have already added the
       // connection to time wait, in which case it should not be added again.
       if (!GetQuicReloadableFlag(quic_use_cheap_stateless_rejects) ||
-          !time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
+          !time_wait_list_manager_->IsConnectionIdInTimeWait(
+              server_connection_id)) {
         // Add this connection_id to the time-wait state, to safely reject
         // future packets.
-        QUIC_DLOG(INFO) << "Adding connection ID " << connection_id
+        QUIC_DLOG(INFO) << "Adding connection ID " << server_connection_id
                         << " to time-wait list.";
         QUIC_CODE_COUNT(quic_reject_fate_time_wait);
         StatelesslyTerminateConnection(
-            connection_id, form, version_flag, version, QUIC_HANDSHAKE_FAILED,
-            "Reject connection",
+            server_connection_id, form, version_flag, version,
+            QUIC_HANDSHAKE_FAILED, "Reject connection",
             quic::QuicTimeWaitListManager::SEND_STATELESS_RESET);
       }
-      DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
+      DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(
+          server_connection_id));
       time_wait_list_manager_->ProcessPacket(
-          current_self_address_, current_peer_address_, connection_id, form,
-          GetPerPacketContext());
+          current_self_address_, current_peer_address_, server_connection_id,
+          form, GetPerPacketContext());
 
       // Any packets which were buffered while the stateless rejector logic was
       // running should be discarded.  Do not inform the time wait list manager,
       // which should already have a made a decision about sending a reject
       // based on the CHLO alone.
-      buffered_packets_.DiscardPackets(connection_id);
+      buffered_packets_.DiscardPackets(server_connection_id);
       break;
     case kFateBuffer:
       // This packet is a non-CHLO packet which has arrived before the
       // corresponding CHLO, *or* this packet was received while the
       // corresponding CHLO was being processed.  Buffer it.
-      BufferEarlyPacket(connection_id, form != GOOGLE_QUIC_PACKET, version);
+      BufferEarlyPacket(server_connection_id, form != GOOGLE_QUIC_PACKET,
+                        version);
       break;
     case kFateDrop:
       // Do nothing with the packet.
@@ -775,13 +787,13 @@
   DeleteSessions();
 }
 
-void QuicDispatcher::OnConnectionClosed(QuicConnectionId connection_id,
+void QuicDispatcher::OnConnectionClosed(QuicConnectionId server_connection_id,
                                         QuicErrorCode error,
                                         const std::string& error_details,
                                         ConnectionCloseSource source) {
-  auto it = session_map_.find(connection_id);
+  auto it = session_map_.find(server_connection_id);
   if (it == session_map_.end()) {
-    QUIC_BUG << "ConnectionId " << connection_id
+    QUIC_BUG << "ConnectionId " << server_connection_id
              << " does not exist in the session map.  Error: "
              << QuicErrorCodeToString(error);
     QUIC_BUG << QuicStackTrace();
@@ -789,7 +801,7 @@
   }
 
   QUIC_DLOG_IF(INFO, error != QUIC_NO_ERROR)
-      << "Closing connection (" << connection_id
+      << "Closing connection (" << server_connection_id
       << ") due to error: " << QuicErrorCodeToString(error)
       << ", with details: " << error_details;
 
@@ -828,13 +840,13 @@
 void QuicDispatcher::OnStopSendingReceived(const QuicStopSendingFrame& frame) {}
 
 void QuicDispatcher::OnConnectionAddedToTimeWaitList(
-    QuicConnectionId connection_id) {
-  QUIC_DLOG(INFO) << "Connection " << connection_id
+    QuicConnectionId server_connection_id) {
+  QUIC_DLOG(INFO) << "Connection " << server_connection_id
                   << " added to time wait list.";
 }
 
 void QuicDispatcher::StatelesslyTerminateConnection(
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
     PacketHeaderFormat format,
     bool version_flag,
     ParsedQuicVersion version,
@@ -844,26 +856,27 @@
   if (format != IETF_QUIC_LONG_HEADER_PACKET &&
       (!GetQuicReloadableFlag(quic_terminate_gquic_connection_as_ietf) ||
        !version_flag)) {
-    QUIC_DVLOG(1) << "Statelessly terminating " << connection_id
+    QUIC_DVLOG(1) << "Statelessly terminating " << server_connection_id
                   << " based on a non-ietf-long packet, action:" << action
                   << ", error_code:" << error_code
                   << ", error_details:" << error_details;
     time_wait_list_manager_->AddConnectionIdToTimeWait(
-        connection_id, format != GOOGLE_QUIC_PACKET, action, ENCRYPTION_INITIAL,
-        nullptr);
+        server_connection_id, format != GOOGLE_QUIC_PACKET, action,
+        ENCRYPTION_INITIAL, nullptr);
     return;
   }
 
   // If the version is known and supported by framer, send a connection close.
   if (IsSupportedVersion(version)) {
     QUIC_DVLOG(1)
-        << "Statelessly terminating " << connection_id
+        << "Statelessly terminating " << server_connection_id
         << " based on an ietf-long packet, which has a supported version:"
         << version << ", error_code:" << error_code
         << ", error_details:" << error_details;
 
-    StatelessConnectionTerminator terminator(
-        connection_id, version, helper_.get(), time_wait_list_manager_.get());
+    StatelessConnectionTerminator terminator(server_connection_id, version,
+                                             helper_.get(),
+                                             time_wait_list_manager_.get());
     // This also adds the connection to time wait list.
     if (format == GOOGLE_QUIC_PACKET) {
       QUIC_RELOADABLE_FLAG_COUNT_N(quic_terminate_gquic_connection_as_ietf, 1,
@@ -875,7 +888,7 @@
   }
 
   QUIC_DVLOG(1)
-      << "Statelessly terminating " << connection_id
+      << "Statelessly terminating " << server_connection_id
       << " based on an ietf-long packet, which has an unsupported version:"
       << version << ", error_code:" << error_code
       << ", error_details:" << error_details;
@@ -883,13 +896,14 @@
   // with an empty version list, which can be understood by the client.
   std::vector<std::unique_ptr<QuicEncryptedPacket>> termination_packets;
   termination_packets.push_back(QuicFramer::BuildVersionNegotiationPacket(
-      connection_id, /*ietf_quic=*/format != GOOGLE_QUIC_PACKET,
+      server_connection_id, EmptyQuicConnectionId(),
+      /*ietf_quic=*/format != GOOGLE_QUIC_PACKET,
       ParsedQuicVersionVector{UnsupportedQuicVersion()}));
   if (format == GOOGLE_QUIC_PACKET) {
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_terminate_gquic_connection_as_ietf, 2, 2);
   }
   time_wait_list_manager()->AddConnectionIdToTimeWait(
-      connection_id, /*ietf_quic=*/format != GOOGLE_QUIC_PACKET,
+      server_connection_id, /*ietf_quic=*/format != GOOGLE_QUIC_PACKET,
       QuicTimeWaitListManager::SEND_TERMINATION_PACKETS, ENCRYPTION_INITIAL,
       &termination_packets);
 }
@@ -913,7 +927,7 @@
   DCHECK(!no_framer_);
   QUIC_BUG_IF(
       !time_wait_list_manager_->IsConnectionIdInTimeWait(
-          current_connection_id_) &&
+          current_server_connection_id_) &&
       !ShouldCreateSessionForUnknownVersion(framer_.last_version_label()))
       << "Unexpected version mismatch: "
       << QuicVersionLabelToString(framer_.last_version_label());
@@ -1090,11 +1104,11 @@
 }
 
 void QuicDispatcher::OnExpiredPackets(
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
     BufferedPacketList early_arrived_packets) {
   QUIC_CODE_COUNT(quic_reject_buffered_packets_expired);
   StatelesslyTerminateConnection(
-      connection_id,
+      server_connection_id,
       early_arrived_packets.ietf_quic ? IETF_QUIC_LONG_HEADER_PACKET
                                       : GOOGLE_QUIC_PACKET,
       /*version_flag=*/true, early_arrived_packets.version,
@@ -1107,24 +1121,44 @@
   new_sessions_allowed_per_event_loop_ = max_connections_to_create;
   for (; new_sessions_allowed_per_event_loop_ > 0;
        --new_sessions_allowed_per_event_loop_) {
-    QuicConnectionId connection_id;
+    QuicConnectionId server_connection_id;
     BufferedPacketList packet_list =
-        buffered_packets_.DeliverPacketsForNextConnection(&connection_id);
+        buffered_packets_.DeliverPacketsForNextConnection(
+            &server_connection_id);
     const std::list<BufferedPacket>& packets = packet_list.buffered_packets;
     if (packets.empty()) {
       return;
     }
-    QuicConnectionId original_connection_id = connection_id;
-    connection_id =
-        MaybeReplaceConnectionId(connection_id, packet_list.version);
+    QuicConnectionId original_connection_id = server_connection_id;
+    server_connection_id = MaybeReplaceServerConnectionId(server_connection_id,
+                                                          packet_list.version);
     QuicSession* session =
-        CreateQuicSession(connection_id, packets.front().peer_address,
+        CreateQuicSession(server_connection_id, packets.front().peer_address,
                           packet_list.alpn, packet_list.version);
-    if (original_connection_id != connection_id) {
+    if (original_connection_id != server_connection_id) {
       session->connection()->AddIncomingConnectionId(original_connection_id);
     }
-    QUIC_DLOG(INFO) << "Created new session for " << connection_id;
-    session_map_.insert(std::make_pair(connection_id, QuicWrapUnique(session)));
+    if (packet_list.version.SupportsClientConnectionIds()) {
+      // Parse out the first packet's source connection ID and set it as the
+      // connection's client connection ID.
+      QuicPacketHeader header;
+      QuicVersionLabel version_label;
+      std::string detailed_error;
+      const QuicErrorCode error = QuicFramer::ProcessPacketDispatcher(
+          *packets.front().packet, expected_server_connection_id_length_,
+          &header.form, &header.version_flag, &version_label,
+          &header.destination_connection_id, &header.source_connection_id,
+          &detailed_error);
+      if (error == QUIC_NO_ERROR) {
+        session->connection()->set_client_connection_id(
+            header.source_connection_id);
+      } else {
+        QUIC_DLOG(ERROR) << detailed_error;
+      }
+    }
+    QUIC_DLOG(INFO) << "Created new session for " << server_connection_id;
+    session_map_.insert(
+        std::make_pair(server_connection_id, QuicWrapUnique(session)));
     DeliverPacketsToSession(packets, session);
   }
 }
@@ -1134,21 +1168,23 @@
 }
 
 bool QuicDispatcher::ShouldCreateOrBufferPacketForConnection(
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
     bool ietf_quic) {
-  QUIC_VLOG(1) << "Received packet from new connection " << connection_id;
+  QUIC_VLOG(1) << "Received packet from new connection "
+               << server_connection_id;
   return true;
 }
 
 // Return true if there is any packet buffered in the store.
-bool QuicDispatcher::HasBufferedPackets(QuicConnectionId connection_id) {
-  return buffered_packets_.HasBufferedPackets(connection_id);
+bool QuicDispatcher::HasBufferedPackets(QuicConnectionId server_connection_id) {
+  return buffered_packets_.HasBufferedPackets(server_connection_id);
 }
 
-void QuicDispatcher::OnBufferPacketFailure(EnqueuePacketResult result,
-                                           QuicConnectionId connection_id) {
-  QUIC_DLOG(INFO) << "Fail to buffer packet on connection " << connection_id
-                  << " because of " << result;
+void QuicDispatcher::OnBufferPacketFailure(
+    EnqueuePacketResult result,
+    QuicConnectionId server_connection_id) {
+  QUIC_DLOG(INFO) << "Fail to buffer packet on connection "
+                  << server_connection_id << " because of " << result;
 }
 
 bool QuicDispatcher::ShouldAttemptCheapStatelessRejection() {
@@ -1160,21 +1196,22 @@
                                      alarm_factory_.get());
 }
 
-void QuicDispatcher::BufferEarlyPacket(QuicConnectionId connection_id,
+void QuicDispatcher::BufferEarlyPacket(QuicConnectionId server_connection_id,
                                        bool ietf_quic,
                                        ParsedQuicVersion version) {
-  bool is_new_connection = !buffered_packets_.HasBufferedPackets(connection_id);
-  if (is_new_connection &&
-      !ShouldCreateOrBufferPacketForConnection(connection_id, ietf_quic)) {
+  bool is_new_connection =
+      !buffered_packets_.HasBufferedPackets(server_connection_id);
+  if (is_new_connection && !ShouldCreateOrBufferPacketForConnection(
+                               server_connection_id, ietf_quic)) {
     return;
   }
 
   EnqueuePacketResult rs = buffered_packets_.EnqueuePacket(
-      connection_id, ietf_quic, *current_packet_, current_self_address_,
+      server_connection_id, ietf_quic, *current_packet_, current_self_address_,
       current_peer_address_, /*is_chlo=*/false,
       /*alpn=*/"", version);
   if (rs != EnqueuePacketResult::SUCCESS) {
-    OnBufferPacketFailure(rs, connection_id);
+    OnBufferPacketFailure(rs, server_connection_id);
   }
 }
 
@@ -1184,48 +1221,56 @@
     // Don't any create new connection.
     QUIC_CODE_COUNT(quic_reject_stop_accepting_new_connections);
     StatelesslyTerminateConnection(
-        current_connection_id(), form, /*version_flag=*/true, version,
+        current_server_connection_id(), form, /*version_flag=*/true, version,
         QUIC_HANDSHAKE_FAILED, "Stop accepting new connections",
         quic::QuicTimeWaitListManager::SEND_STATELESS_RESET);
     // Time wait list will reject the packet correspondingly.
     time_wait_list_manager()->ProcessPacket(
-        current_self_address(), current_peer_address(), current_connection_id(),
-        form, GetPerPacketContext());
+        current_self_address(), current_peer_address(),
+        current_server_connection_id(), form, GetPerPacketContext());
     return;
   }
-  if (!buffered_packets_.HasBufferedPackets(current_connection_id_) &&
-      !ShouldCreateOrBufferPacketForConnection(current_connection_id_,
+  if (!buffered_packets_.HasBufferedPackets(current_server_connection_id_) &&
+      !ShouldCreateOrBufferPacketForConnection(current_server_connection_id_,
                                                form != GOOGLE_QUIC_PACKET)) {
     return;
   }
   if (FLAGS_quic_allow_chlo_buffering &&
       new_sessions_allowed_per_event_loop_ <= 0) {
     // Can't create new session any more. Wait till next event loop.
-    QUIC_BUG_IF(buffered_packets_.HasChloForConnection(current_connection_id_));
+    QUIC_BUG_IF(
+        buffered_packets_.HasChloForConnection(current_server_connection_id_));
     EnqueuePacketResult rs = buffered_packets_.EnqueuePacket(
-        current_connection_id_, form != GOOGLE_QUIC_PACKET, *current_packet_,
-        current_self_address_, current_peer_address_,
+        current_server_connection_id_, form != GOOGLE_QUIC_PACKET,
+        *current_packet_, current_self_address_, current_peer_address_,
         /*is_chlo=*/true, current_alpn_, version);
     if (rs != EnqueuePacketResult::SUCCESS) {
-      OnBufferPacketFailure(rs, current_connection_id_);
+      OnBufferPacketFailure(rs, current_server_connection_id_);
     }
     return;
   }
 
-  QuicConnectionId original_connection_id = current_connection_id_;
-  current_connection_id_ =
-      MaybeReplaceConnectionId(current_connection_id_, version);
+  QuicConnectionId original_connection_id = current_server_connection_id_;
+  current_server_connection_id_ =
+      MaybeReplaceServerConnectionId(current_server_connection_id_, version);
   // Creates a new session and process all buffered packets for this connection.
-  QuicSession* session = CreateQuicSession(
-      current_connection_id_, current_peer_address_, current_alpn_, version);
-  if (original_connection_id != current_connection_id_) {
+  QuicSession* session =
+      CreateQuicSession(current_server_connection_id_, current_peer_address_,
+                        current_alpn_, version);
+  if (original_connection_id != current_server_connection_id_) {
     session->connection()->AddIncomingConnectionId(original_connection_id);
   }
-  QUIC_DLOG(INFO) << "Created new session for " << current_connection_id_;
+  if (version.SupportsClientConnectionIds()) {
+    session->connection()->set_client_connection_id(
+        current_client_connection_id_);
+  }
+  QUIC_DLOG(INFO) << "Created new session for "
+                  << current_server_connection_id_;
   session_map_.insert(
-      std::make_pair(current_connection_id_, QuicWrapUnique(session)));
+      std::make_pair(current_server_connection_id_, QuicWrapUnique(session)));
   std::list<BufferedPacket> packets =
-      buffered_packets_.DeliverPackets(current_connection_id_).buffered_packets;
+      buffered_packets_.DeliverPackets(current_server_connection_id_)
+          .buffered_packets;
   // Process CHLO at first.
   session->ProcessUdpPacket(current_self_address_, current_peer_address_,
                             *current_packet_);
@@ -1295,12 +1340,13 @@
   bool current_version_flag_;
 };
 
-void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
-                                            PacketHeaderFormat form,
-                                            bool version_flag,
-                                            ParsedQuicVersion version) {
+void QuicDispatcher::MaybeRejectStatelessly(
+    QuicConnectionId server_connection_id,
+    PacketHeaderFormat form,
+    bool version_flag,
+    ParsedQuicVersion version) {
   if (version.handshake_protocol == PROTOCOL_TLS1_3) {
-    ProcessUnauthenticatedHeaderFate(kFateProcess, connection_id, form,
+    ProcessUnauthenticatedHeaderFate(kFateProcess, server_connection_id, form,
                                      version_flag, version);
     return;
     // TODO(nharper): Support buffering non-ClientHello packets when using TLS.
@@ -1315,14 +1361,15 @@
     if (FLAGS_quic_allow_chlo_buffering &&
         !ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
                                 config_->create_session_tag_indicators(),
-                                &alpn_extractor, connection_id.length())) {
+                                &alpn_extractor,
+                                server_connection_id.length())) {
       // Buffer non-CHLO packets.
-      ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id, form,
+      ProcessUnauthenticatedHeaderFate(kFateBuffer, server_connection_id, form,
                                        version_flag, version);
       return;
     }
     current_alpn_ = alpn_extractor.ConsumeAlpn();
-    ProcessUnauthenticatedHeaderFate(kFateProcess, connection_id, form,
+    ProcessUnauthenticatedHeaderFate(kFateProcess, server_connection_id, form,
                                      version_flag, version);
     return;
   }
@@ -1337,8 +1384,8 @@
                           rejector.get());
   if (!ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
                               config_->create_session_tag_indicators(),
-                              &validator, connection_id.length())) {
-    ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id, form,
+                              &validator, server_connection_id.length())) {
+    ProcessUnauthenticatedHeaderFate(kFateBuffer, server_connection_id, form,
                                      version_flag, version);
     return;
   }
@@ -1347,13 +1394,13 @@
   if (!validator.can_accept()) {
     // This CHLO is prohibited by policy.
     QUIC_CODE_COUNT(quic_reject_cant_accept_chlo);
-    StatelessConnectionTerminator terminator(connection_id, version, helper(),
-                                             time_wait_list_manager_.get());
+    StatelessConnectionTerminator terminator(
+        server_connection_id, version, helper(), time_wait_list_manager_.get());
     terminator.CloseConnection(QUIC_HANDSHAKE_FAILED, validator.error_details(),
                                form != GOOGLE_QUIC_PACKET);
     QuicSession::RecordConnectionCloseAtServer(
         QUIC_HANDSHAKE_FAILED, ConnectionCloseSource::FROM_SELF);
-    ProcessUnauthenticatedHeaderFate(kFateTimeWait, connection_id, form,
+    ProcessUnauthenticatedHeaderFate(kFateTimeWait, server_connection_id, form,
                                      version_flag, version);
     return;
   }
@@ -1368,10 +1415,10 @@
 
   // Insert into set of connection IDs to buffer
   const bool ok =
-      temporarily_buffered_connections_.insert(connection_id).second;
+      temporarily_buffered_connections_.insert(server_connection_id).second;
   QUIC_BUG_IF(!ok)
       << "Processing multiple stateless rejections for connection ID "
-      << connection_id;
+      << server_connection_id;
 
   // Continue stateless rejector processing
   std::unique_ptr<StatelessRejectorProcessDoneCallback> cb(
@@ -1395,7 +1442,7 @@
   current_peer_address_ = current_peer_address;
   current_self_address_ = current_self_address;
   current_packet_ = current_packet.get();
-  current_connection_id_ = rejector->connection_id();
+  current_server_connection_id_ = rejector->connection_id();
   if (!no_framer_) {
     framer_.set_version(first_version);
   }
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 6adf5f3..5e755dd 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -49,7 +49,7 @@
                  std::unique_ptr<QuicConnectionHelperInterface> helper,
                  std::unique_ptr<QuicCryptoServerStream::Helper> session_helper,
                  std::unique_ptr<QuicAlarmFactory> alarm_factory,
-                 uint8_t expected_connection_id_length);
+                 uint8_t expected_server_connection_id_length);
   QuicDispatcher(const QuicDispatcher&) = delete;
   QuicDispatcher& operator=(const QuicDispatcher&) = delete;
 
@@ -76,7 +76,7 @@
   // QuicSession::Visitor interface implementation (via inheritance of
   // QuicTimeWaitListManager::Visitor):
   // Ensure that the closed connection is cleaned up asynchronously.
-  void OnConnectionClosed(QuicConnectionId connection_id,
+  void OnConnectionClosed(QuicConnectionId server_connection_id,
                           QuicErrorCode error,
                           const std::string& error_details,
                           ConnectionCloseSource source) override;
@@ -99,7 +99,8 @@
   // QuicTimeWaitListManager::Visitor interface implementation
   // Called whenever the time wait list manager adds a new connection to the
   // time-wait list.
-  void OnConnectionAddedToTimeWaitList(QuicConnectionId connection_id) override;
+  void OnConnectionAddedToTimeWaitList(
+      QuicConnectionId server_connection_id) override;
 
   using SessionMap = QuicUnorderedMap<QuicConnectionId,
                                       std::unique_ptr<QuicSession>,
@@ -191,7 +192,7 @@
       const QuicIetfStatelessResetPacket& packet) override;
 
   // QuicBufferedPacketStore::VisitorInterface implementation.
-  void OnExpiredPackets(QuicConnectionId connection_id,
+  void OnExpiredPackets(QuicConnectionId server_connection_id,
                         QuicBufferedPacketStore::BufferedPacketList
                             early_arrived_packets) override;
 
@@ -202,7 +203,7 @@
   virtual bool HasChlosBuffered() const;
 
  protected:
-  virtual QuicSession* CreateQuicSession(QuicConnectionId connection_id,
+  virtual QuicSession* CreateQuicSession(QuicConnectionId server_connection_id,
                                          const QuicSocketAddress& peer_address,
                                          QuicStringPiece alpn,
                                          const ParsedQuicVersion& version) = 0;
@@ -238,9 +239,9 @@
   // will be owned by the dispatcher as time_wait_list_manager_
   virtual QuicTimeWaitListManager* CreateQuicTimeWaitListManager();
 
-  // Called when |connection_id| doesn't have an open connection yet, to buffer
-  // |current_packet_| until it can be delivered to the connection.
-  void BufferEarlyPacket(QuicConnectionId connection_id,
+  // Called when |server_connection_id| doesn't have an open connection yet,
+  // to buffer |current_packet_| until it can be delivered to the connection.
+  void BufferEarlyPacket(QuicConnectionId server_connection_id,
                          bool ietf_quic,
                          ParsedQuicVersion version);
 
@@ -269,8 +270,8 @@
 
   const ParsedQuicVersionVector& GetSupportedVersions();
 
-  QuicConnectionId current_connection_id() const {
-    return current_connection_id_;
+  QuicConnectionId current_server_connection_id() const {
+    return current_server_connection_id_;
   }
   const QuicSocketAddress& current_self_address() const {
     return current_self_address_;
@@ -319,15 +320,15 @@
   // for CHLO. Returns true if a new connection should be created or its packets
   // should be buffered, false otherwise.
   virtual bool ShouldCreateOrBufferPacketForConnection(
-      QuicConnectionId connection_id,
+      QuicConnectionId server_connection_id,
       bool ietf_quic);
 
-  bool HasBufferedPackets(QuicConnectionId connection_id);
+  bool HasBufferedPackets(QuicConnectionId server_connection_id);
 
   // Called when BufferEarlyPacket() fail to buffer the packet.
   virtual void OnBufferPacketFailure(
       QuicBufferedPacketStore::EnqueuePacketResult result,
-      QuicConnectionId connection_id);
+      QuicConnectionId server_connection_id);
 
   // Removes the session from the session map and write blocked list, and adds
   // the ConnectionId to the time-wait list.  If |session_closed_statelessly| is
@@ -344,7 +345,7 @@
   // connection to time wait list or 2) directly add connection to time wait
   // list with |action|.
   void StatelesslyTerminateConnection(
-      QuicConnectionId connection_id,
+      QuicConnectionId server_connection_id,
       PacketHeaderFormat format,
       bool version_flag,
       ParsedQuicVersion version,
@@ -363,21 +364,22 @@
   // If true, our framer will change its expected connection ID length
   // to the received destination connection ID length of all IETF long headers.
   void SetShouldUpdateExpectedConnectionIdLength(
-      bool should_update_expected_connection_id_length) {
+      bool should_update_expected_server_connection_id_length) {
     if (!no_framer_) {
       framer_.SetShouldUpdateExpectedConnectionIdLength(
-          should_update_expected_connection_id_length);
+          should_update_expected_server_connection_id_length);
       return;
     }
-    should_update_expected_connection_id_length_ =
-        should_update_expected_connection_id_length;
+    should_update_expected_server_connection_id_length_ =
+        should_update_expected_server_connection_id_length;
   }
 
   // If true, the dispatcher will allow incoming initial packets that have
-  // connection IDs shorter than 64 bits.
-  void SetAllowShortInitialConnectionIds(
-      bool allow_short_initial_connection_ids) {
-    allow_short_initial_connection_ids_ = allow_short_initial_connection_ids;
+  // destination connection IDs shorter than 64 bits.
+  void SetAllowShortInitialServerConnectionIds(
+      bool allow_short_initial_server_connection_ids) {
+    allow_short_initial_server_connection_ids_ =
+        allow_short_initial_server_connection_ids;
   }
 
  private:
@@ -395,7 +397,7 @@
   // possible and if the current packet contains a CHLO message.  Determines a
   // fate which describes what subsequent processing should be performed on the
   // packets, like ValidityChecks, and invokes ProcessUnauthenticatedHeaderFate.
-  void MaybeRejectStatelessly(QuicConnectionId connection_id,
+  void MaybeRejectStatelessly(QuicConnectionId server_connection_id,
                               PacketHeaderFormat form,
                               bool version_flag,
                               ParsedQuicVersion version);
@@ -408,7 +410,7 @@
   // Perform the appropriate actions on the current packet based on |fate| -
   // either process, buffer, or drop it.
   void ProcessUnauthenticatedHeaderFate(QuicPacketFate fate,
-                                        QuicConnectionId connection_id,
+                                        QuicConnectionId server_connection_id,
                                         PacketHeaderFormat form,
                                         bool version_flag,
                                         ParsedQuicVersion version);
@@ -440,8 +442,9 @@
   // If the connection ID length is different from what the dispatcher expects,
   // replace the connection ID with a random one of the right length,
   // and save it to make sure the mapping is persistent.
-  QuicConnectionId MaybeReplaceConnectionId(QuicConnectionId connection_id,
-                                            ParsedQuicVersion version);
+  QuicConnectionId MaybeReplaceServerConnectionId(
+      QuicConnectionId server_connection_id,
+      ParsedQuicVersion version);
 
   // Returns true if |version| is a supported protocol version.
   bool IsSupportedVersion(const ParsedQuicVersion version);
@@ -505,7 +508,8 @@
   const QuicReceivedPacket* current_packet_;
   // If |current_packet_| is a CHLO packet, the extracted alpn.
   std::string current_alpn_;
-  QuicConnectionId current_connection_id_;
+  QuicConnectionId current_server_connection_id_;
+  QuicConnectionId current_client_connection_id_;
 
   // Used to get the supported versions based on flag. Does not own.
   QuicVersionManager* version_manager_;
@@ -524,8 +528,9 @@
   bool accept_new_connections_;
 
   // If false, the dispatcher follows the IETF spec and rejects packets with
-  // invalid connection IDs lengths below 64 bits. If true they are allowed.
-  bool allow_short_initial_connection_ids_;
+  // invalid destination connection IDs lengths below 64 bits.
+  // If true they are allowed.
+  bool allow_short_initial_server_connection_ids_;
 
   // The last QUIC version label received. Used when no_framer_ is true.
   // TODO(fayang): remove this member variable, instead, add an argument to
@@ -537,14 +542,15 @@
   // encode its length. This variable contains the length we expect to read.
   // This is also used to signal an error when a long header packet with
   // different destination connection ID length is received when
-  // should_update_expected_connection_id_length_ is false and packet's version
-  // does not allow variable length connection ID. Used when no_framer_ is true.
-  uint8_t expected_connection_id_length_;
+  // should_update_expected_server_connection_id_length_ is false and packet's
+  // version does not allow variable length connection ID. Used when no_framer_
+  // is true.
+  uint8_t expected_server_connection_id_length_;
 
-  // If true, change expected_connection_id_length_ to be the received
+  // If true, change expected_server_connection_id_length_ to be the received
   // destination connection ID length of all IETF long headers. Used when
   // no_framer_ is true.
-  bool should_update_expected_connection_id_length_;
+  bool should_update_expected_server_connection_id_length_;
 
   // Latched value of quic_no_framer_object_in_dispatcher.
   const bool no_framer_;
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 46c5bc2..668541b 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -156,7 +156,7 @@
   using QuicDispatcher::current_client_address;
   using QuicDispatcher::current_peer_address;
   using QuicDispatcher::current_self_address;
-  using QuicDispatcher::SetAllowShortInitialConnectionIds;
+  using QuicDispatcher::SetAllowShortInitialServerConnectionIds;
   using QuicDispatcher::writer;
 };
 
@@ -493,7 +493,7 @@
 
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
-              SendVersionNegotiationPacket(_, _, _, _, _, _))
+              SendVersionNegotiationPacket(_, _, _, _, _, _, _))
       .Times(1);
   QuicTransportVersion version =
       static_cast<QuicTransportVersion>(QuicTransportVersionMin() - 1);
@@ -512,7 +512,7 @@
 
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
-              SendVersionNegotiationPacket(_, _, _, _, _, _))
+              SendVersionNegotiationPacket(_, _, _, _, _, _, _))
       .Times(0);
   QuicTransportVersion version =
       static_cast<QuicTransportVersion>(QuicTransportVersionMin() - 1);
@@ -538,7 +538,7 @@
 
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager_,
-              SendVersionNegotiationPacket(_, _, _, _, _, _))
+              SendVersionNegotiationPacket(_, _, _, _, _, _, _))
       .Times(1);
   QuicTransportVersion version =
       static_cast<QuicTransportVersion>(QuicTransportVersionMin() - 1);
@@ -686,7 +686,7 @@
       QuicUtils::CreateRandomConnectionId(mock_helper_.GetRandomGenerator());
 
   // Disable validation of invalid short connection IDs.
-  dispatcher_->SetAllowShortInitialConnectionIds(true);
+  dispatcher_->SetAllowShortInitialServerConnectionIds(true);
   // Note that StrayPacketTruncatedConnectionId covers the case where the
   // validation is still enabled.
 
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 27af834..c35c076 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -459,10 +459,11 @@
 QuicFramer::QuicFramer(const ParsedQuicVersionVector& supported_versions,
                        QuicTime creation_time,
                        Perspective perspective,
-                       uint8_t expected_connection_id_length)
+                       uint8_t expected_server_connection_id_length)
     : visitor_(nullptr),
       error_(QUIC_NO_ERROR),
-      last_serialized_connection_id_(EmptyQuicConnectionId()),
+      last_serialized_server_connection_id_(EmptyQuicConnectionId()),
+      last_serialized_client_connection_id_(EmptyQuicConnectionId()),
       last_version_label_(0),
       version_(PROTOCOL_UNSUPPORTED, QUIC_VERSION_UNSUPPORTED),
       supported_versions_(supported_versions),
@@ -478,8 +479,10 @@
       data_producer_(nullptr),
       infer_packet_header_type_from_version_(perspective ==
                                              Perspective::IS_CLIENT),
-      expected_connection_id_length_(expected_connection_id_length),
-      should_update_expected_connection_id_length_(false),
+      expected_server_connection_id_length_(
+          expected_server_connection_id_length),
+      expected_client_connection_id_length_(0),
+      should_update_expected_server_connection_id_length_(false),
       supports_multiple_packet_number_spaces_(false),
       last_written_packet_number_length_(0) {
   DCHECK(!supported_versions.empty());
@@ -1387,14 +1390,17 @@
 
 // static
 std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildVersionNegotiationPacket(
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
+    QuicConnectionId client_connection_id,
     bool ietf_quic,
     const ParsedQuicVersionVector& versions) {
   if (ietf_quic) {
-    return BuildIetfVersionNegotiationPacket(connection_id, versions);
+    return BuildIetfVersionNegotiationPacket(server_connection_id,
+                                             client_connection_id, versions);
   }
+  DCHECK(client_connection_id.IsEmpty());
   DCHECK(!versions.empty());
-  size_t len = kPublicFlagsSize + connection_id.length() +
+  size_t len = kPublicFlagsSize + server_connection_id.length() +
                versions.size() * kQuicVersionSize;
   std::unique_ptr<char[]> buffer(new char[len]);
   // Endianness is not a concern here, version negotiation packet does not have
@@ -1409,7 +1415,7 @@
     return nullptr;
   }
 
-  if (!writer.WriteConnectionId(connection_id)) {
+  if (!writer.WriteConnectionId(server_connection_id)) {
     return nullptr;
   }
 
@@ -1427,13 +1433,14 @@
 // static
 std::unique_ptr<QuicEncryptedPacket>
 QuicFramer::BuildIetfVersionNegotiationPacket(
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
+    QuicConnectionId client_connection_id,
     const ParsedQuicVersionVector& versions) {
   QUIC_DVLOG(1) << "Building IETF version negotiation packet: "
                 << ParsedQuicVersionVectorToString(versions);
   DCHECK(!versions.empty());
   size_t len = kPacketHeaderTypeSize + kConnectionIdLengthSize +
-               connection_id.length() +
+               client_connection_id.length() + server_connection_id.length() +
                (versions.size() + 1) * kQuicVersionSize;
   std::unique_ptr<char[]> buffer(new char[len]);
   QuicDataWriter writer(len, buffer.get());
@@ -1452,7 +1459,7 @@
     return nullptr;
   }
 
-  if (!AppendIetfConnectionIds(true, EmptyQuicConnectionId(), connection_id,
+  if (!AppendIetfConnectionIds(true, client_connection_id, server_connection_id,
                                &writer)) {
     return nullptr;
   }
@@ -2064,14 +2071,14 @@
     public_flags |= PACKET_PUBLIC_FLAGS_NONCE;
   }
 
-  QuicConnectionId connection_id =
+  QuicConnectionId server_connection_id =
       GetServerConnectionIdAsSender(header, perspective_);
-  QuicConnectionIdIncluded connection_id_included =
+  QuicConnectionIdIncluded server_connection_id_included =
       GetServerConnectionIdIncludedAsSender(header, perspective_);
   DCHECK_EQ(CONNECTION_ID_ABSENT,
             GetClientConnectionIdIncludedAsSender(header, perspective_));
 
-  switch (connection_id_included) {
+  switch (server_connection_id_included) {
     case CONNECTION_ID_ABSENT:
       if (!writer->WriteUInt8(public_flags |
                               PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
@@ -2080,9 +2087,9 @@
       break;
     case CONNECTION_ID_PRESENT:
       QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(
-          connection_id, transport_version()))
+          server_connection_id, transport_version()))
           << "AppendPacketHeader: attempted to use connection ID "
-          << connection_id << " which is invalid with version "
+          << server_connection_id << " which is invalid with version "
           << QuicVersionToString(transport_version());
 
       public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
@@ -2090,12 +2097,12 @@
         public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD;
       }
       if (!writer->WriteUInt8(public_flags) ||
-          !writer->WriteConnectionId(connection_id)) {
+          !writer->WriteConnectionId(server_connection_id)) {
         return false;
       }
       break;
   }
-  last_serialized_connection_id_ = connection_id;
+  last_serialized_server_connection_id_ = server_connection_id;
 
   if (header.version_flag) {
     DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
@@ -2194,7 +2201,10 @@
     return false;
   }
 
-  last_serialized_connection_id_ = server_connection_id;
+  last_serialized_server_connection_id_ = server_connection_id;
+  if (version_.SupportsClientConnectionIds()) {
+    last_serialized_client_connection_id_ = GetClientConnectionIdAsSender(header, perspective_);
+  }
 
   if (QuicVersionHasLongHeaderLengths(transport_version()) &&
       header.version_flag) {
@@ -2336,7 +2346,7 @@
       break;
     case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID:
       *header_connection_id_included = CONNECTION_ID_ABSENT;
-      *header_connection_id = last_serialized_connection_id_;
+      *header_connection_id = last_serialized_server_connection_id_;
       break;
   }
 
@@ -2521,11 +2531,15 @@
     // connection ID, and those received by server must include 8-byte
     // destination connection ID.
     header->destination_connection_id_included =
-        perspective_ == Perspective::IS_CLIENT ? CONNECTION_ID_ABSENT
-                                               : CONNECTION_ID_PRESENT;
+        (perspective_ == Perspective::IS_SERVER ||
+         version_.SupportsClientConnectionIds())
+            ? CONNECTION_ID_PRESENT
+            : CONNECTION_ID_ABSENT;
     header->source_connection_id_included =
-        perspective_ == Perspective::IS_CLIENT ? CONNECTION_ID_PRESENT
-                                               : CONNECTION_ID_ABSENT;
+        (perspective_ == Perspective::IS_CLIENT ||
+         version_.SupportsClientConnectionIds())
+            ? CONNECTION_ID_PRESENT
+            : CONNECTION_ID_ABSENT;
     // Read version tag.
     QuicVersionLabel version_label;
     if (!ProcessVersionLabel(reader, &version_label)) {
@@ -2580,8 +2594,10 @@
   // Connection ID length depends on the perspective. Client does not expect
   // destination connection ID, and server expects destination connection ID.
   header->destination_connection_id_included =
-      perspective_ == Perspective::IS_CLIENT ? CONNECTION_ID_ABSENT
-                                             : CONNECTION_ID_PRESENT;
+      (perspective_ == Perspective::IS_SERVER ||
+       version_.SupportsClientConnectionIds())
+          ? CONNECTION_ID_PRESENT
+          : CONNECTION_ID_ABSENT;
   header->source_connection_id_included = CONNECTION_ID_ABSENT;
   if (infer_packet_header_type_from_version_ &&
       transport_version() > QUIC_VERSION_44 && !(type & FLAGS_FIXED_BIT)) {
@@ -2614,11 +2630,21 @@
 bool QuicFramer::ProcessAndValidateIetfConnectionIdLength(
     QuicDataReader* reader,
     ParsedQuicVersion version,
-    bool should_update_expected_connection_id_length,
-    uint8_t* expected_connection_id_length,
+    Perspective perspective,
+    bool should_update_expected_server_connection_id_length,
+    uint8_t* expected_server_connection_id_length,
     uint8_t* destination_connection_id_length,
     uint8_t* source_connection_id_length,
     std::string* detailed_error) {
+  QUIC_LOG(ERROR) << "ds33 should_update_expected_server_connection_id_length "
+                  << (should_update_expected_server_connection_id_length ? "Y"
+                                                                         : "N")
+                  << " expected_server_connection_id_length "
+                  << (int)*expected_server_connection_id_length
+                  << " destination_connection_id_length "
+                  << (int)*destination_connection_id_length
+                  << " source_connection_id_length "
+                  << (int)*source_connection_id_length;
   uint8_t connection_id_lengths_byte;
   if (!reader->ReadBytes(&connection_id_lengths_byte, 1)) {
     *detailed_error = "Unable to read ConnectionId length.";
@@ -2629,18 +2655,21 @@
   if (dcil != 0) {
     dcil += kConnectionIdLengthAdjustment;
   }
-  if (should_update_expected_connection_id_length &&
-      *expected_connection_id_length != dcil) {
-    QUIC_DVLOG(1) << "Updating expected_connection_id_length: "
-                  << static_cast<int>(*expected_connection_id_length) << " -> "
-                  << static_cast<int>(dcil);
-    *expected_connection_id_length = dcil;
-  }
   uint8_t scil = connection_id_lengths_byte & kSourceConnectionIdLengthMask;
   if (scil != 0) {
     scil += kConnectionIdLengthAdjustment;
   }
-  if (!should_update_expected_connection_id_length &&
+  if (should_update_expected_server_connection_id_length) {
+    uint8_t server_connection_id_length =
+        perspective == Perspective::IS_SERVER ? dcil : scil;
+    if (*expected_server_connection_id_length != server_connection_id_length) {
+      QUIC_DVLOG(1) << "Updating expected_server_connection_id_length: "
+                    << static_cast<int>(*expected_server_connection_id_length)
+                    << " -> " << static_cast<int>(server_connection_id_length);
+      *expected_server_connection_id_length = server_connection_id_length;
+    }
+  }
+  if (!should_update_expected_server_connection_id_length &&
       (dcil != *destination_connection_id_length ||
        scil != *source_connection_id_length) &&
       !QuicUtils::VariableLengthConnectionIdAllowedForVersion(
@@ -2665,18 +2694,35 @@
 
   uint8_t destination_connection_id_length =
       header->destination_connection_id_included == CONNECTION_ID_PRESENT
-          ? expected_connection_id_length_
+          ? (perspective_ == Perspective::IS_SERVER
+                 ? expected_server_connection_id_length_
+                 : expected_client_connection_id_length_)
           : 0;
   uint8_t source_connection_id_length =
       header->source_connection_id_included == CONNECTION_ID_PRESENT
-          ? expected_connection_id_length_
+          ? (perspective_ == Perspective::IS_CLIENT
+                 ? expected_server_connection_id_length_
+                 : expected_client_connection_id_length_)
           : 0;
+  QUIC_LOG(ERROR) << ENDPOINT
+                  << "ds33 should_update_expected_server_connection_id_length_ "
+                  << (should_update_expected_server_connection_id_length_ ? "Y"
+                                                                          : "N")
+                  << " expected_server_connection_id_length_ "
+                  << (int)expected_server_connection_id_length_
+                  << " expected_client_connection_id_length_ "
+                  << (int)expected_client_connection_id_length_
+                  << " destination_connection_id_length "
+                  << (int)destination_connection_id_length
+                  << " source_connection_id_length "
+                  << (int)source_connection_id_length << " header " << *header;
   if (header->form == IETF_QUIC_LONG_HEADER_PACKET) {
     if (!ProcessAndValidateIetfConnectionIdLength(
-            reader, header->version,
-            should_update_expected_connection_id_length_,
-            &expected_connection_id_length_, &destination_connection_id_length,
-            &source_connection_id_length, &detailed_error_)) {
+            reader, header->version, perspective_,
+            should_update_expected_server_connection_id_length_,
+            &expected_server_connection_id_length_,
+            &destination_connection_id_length, &source_connection_id_length,
+            &detailed_error_)) {
       return false;
     }
   }
@@ -2709,13 +2755,17 @@
       header->destination_connection_id = header->source_connection_id;
     } else if (header->destination_connection_id_included ==
                CONNECTION_ID_ABSENT) {
-      header->destination_connection_id = last_serialized_connection_id_;
+      header->destination_connection_id = last_serialized_server_connection_id_;
     }
   } else {
     QUIC_RESTART_FLAG_COUNT_N(quic_do_not_override_connection_id, 5, 5);
     if (header->source_connection_id_included == CONNECTION_ID_ABSENT) {
       DCHECK_EQ(EmptyQuicConnectionId(), header->source_connection_id);
-      header->source_connection_id = last_serialized_connection_id_;
+      if (perspective_ == Perspective::IS_CLIENT) {
+        header->source_connection_id = last_serialized_server_connection_id_;
+      } else {
+        header->source_connection_id = last_serialized_client_connection_id_;
+      }
     }
   }
 
@@ -6042,28 +6092,30 @@
 // static
 QuicErrorCode QuicFramer::ProcessPacketDispatcher(
     const QuicEncryptedPacket& packet,
-    uint8_t expected_connection_id_length,
+    uint8_t expected_server_connection_id_length,
     PacketHeaderFormat* format,
     bool* version_flag,
     QuicVersionLabel* version_label,
-    uint8_t* destination_connection_id_length,
     QuicConnectionId* destination_connection_id,
+    QuicConnectionId* source_connection_id,
     std::string* detailed_error) {
   QuicDataReader reader(packet.data(), packet.length());
 
+  *source_connection_id = EmptyQuicConnectionId();
   uint8_t first_byte;
   if (!reader.ReadBytes(&first_byte, 1)) {
     *detailed_error = "Unable to read first byte.";
     return QUIC_INVALID_PACKET_HEADER;
   }
+  uint8_t destination_connection_id_length = 0, source_connection_id_length = 0;
   if (!QuicUtils::IsIetfPacketHeader(first_byte)) {
     *format = GOOGLE_QUIC_PACKET;
     *version_flag = (first_byte & PACKET_PUBLIC_FLAGS_VERSION) != 0;
-    *destination_connection_id_length =
+    destination_connection_id_length =
         first_byte & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
-    if (*destination_connection_id_length == 0 ||
+    if (destination_connection_id_length == 0 ||
         !reader.ReadConnectionId(destination_connection_id,
-                                 *destination_connection_id_length)) {
+                                 destination_connection_id_length)) {
       *detailed_error = "Unable to read ConnectionId.";
       return QUIC_INVALID_PACKET_HEADER;
     }
@@ -6083,27 +6135,33 @@
       *detailed_error = "Unable to read protocol version.";
       return QUIC_INVALID_PACKET_HEADER;
     }
-    // Set should_update_expected_connection_id_length to true to bypass
+    // Set should_update_expected_server_connection_id_length to true to bypass
     // connection ID lengths validation.
-    uint8_t unused_source_connection_id_length = 0;
-    uint8_t unused_expected_connection_id_length = 0;
+    uint8_t unused_expected_server_connection_id_length = 0;
     if (!ProcessAndValidateIetfConnectionIdLength(
             &reader, ParseQuicVersionLabel(*version_label),
-            /*should_update_expected_connection_id_length=*/true,
-            &unused_expected_connection_id_length,
-            destination_connection_id_length,
-            &unused_source_connection_id_length, detailed_error)) {
+            Perspective::IS_SERVER,
+            /*should_update_expected_server_connection_id_length=*/true,
+            &unused_expected_server_connection_id_length,
+            &destination_connection_id_length, &source_connection_id_length,
+            detailed_error)) {
       return QUIC_INVALID_PACKET_HEADER;
     }
   } else {
-    // For short header packets, expected_connection_id_length is used to
+    // For short header packets, expected_server_connection_id_length is used to
     // determine the destination_connection_id_length.
-    *destination_connection_id_length = expected_connection_id_length;
+    destination_connection_id_length = expected_server_connection_id_length;
   }
   // Read destination connection ID.
   if (!reader.ReadConnectionId(destination_connection_id,
-                               *destination_connection_id_length)) {
-    *detailed_error = "Unable to read Destination ConnectionId.";
+                               destination_connection_id_length)) {
+    *detailed_error = "Unable to read destination connection ID.";
+    return QUIC_INVALID_PACKET_HEADER;
+  }
+  // Read source connection ID.
+  if (!reader.ReadConnectionId(source_connection_id,
+                               source_connection_id_length)) {
+    *detailed_error = "Unable to read source connection ID.";
     return QUIC_INVALID_PACKET_HEADER;
   }
   return QUIC_NO_ERROR;
@@ -6234,13 +6292,14 @@
     *detailed_error = "Packet is not a version negotiation packet";
     return false;
   }
-  uint8_t expected_connection_id_length = 0,
+  uint8_t expected_server_connection_id_length = 0,
           destination_connection_id_length = 0, source_connection_id_length = 0;
   if (!ProcessAndValidateIetfConnectionIdLength(
-          &reader, UnsupportedQuicVersion(),
-          /*should_update_expected_connection_id_length=*/true,
-          &expected_connection_id_length, &destination_connection_id_length,
-          &source_connection_id_length, detailed_error)) {
+          &reader, UnsupportedQuicVersion(), Perspective::IS_CLIENT,
+          /*should_update_expected_server_connection_id_length=*/true,
+          &expected_server_connection_id_length,
+          &destination_connection_id_length, &source_connection_id_length,
+          detailed_error)) {
     return false;
   }
   if (destination_connection_id_length != 0) {
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index ab0e8d7..931dd4a 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -226,7 +226,7 @@
   QuicFramer(const ParsedQuicVersionVector& supported_versions,
              QuicTime creation_time,
              Perspective perspective,
-             uint8_t expected_connection_id_length);
+             uint8_t expected_server_connection_id_length);
   QuicFramer(const QuicFramer&) = delete;
   QuicFramer& operator=(const QuicFramer&) = delete;
 
@@ -374,18 +374,18 @@
       QuicVariableLengthIntegerLength length_length);
 
   // Lightweight parsing of |packet| and populates |format|, |version_flag|,
-  // |version_label|, |destination_connection_id_length|,
-  // |destination_connection_id| and |detailed_error|. Please note,
-  // |expected_connection_id_length| is only used to determine IETF short header
-  // packet's destination connection ID length.
+  // |version_label|, |destination_connection_id|, |source_connection_id| and
+  // |detailed_error|. Please note, |expected_server_connection_id_length| is
+  // only used to determine IETF short header packet's destination connection ID
+  // length.
   static QuicErrorCode ProcessPacketDispatcher(
       const QuicEncryptedPacket& packet,
-      uint8_t expected_connection_id_length,
+      uint8_t expected_server_connection_id_length,
       PacketHeaderFormat* format,
       bool* version_flag,
       QuicVersionLabel* version_label,
-      uint8_t* destination_connection_id_length,
       QuicConnectionId* destination_connection_id,
+      QuicConnectionId* source_connection_id,
       std::string* detailed_error);
 
   // Serializes a packet containing |frames| into |buffer|.
@@ -435,13 +435,15 @@
 
   // Returns a new version negotiation packet.
   static std::unique_ptr<QuicEncryptedPacket> BuildVersionNegotiationPacket(
-      QuicConnectionId connection_id,
+      QuicConnectionId server_connection_id,
+      QuicConnectionId client_connection_id,
       bool ietf_quic,
       const ParsedQuicVersionVector& versions);
 
   // Returns a new IETF version negotiation packet.
   static std::unique_ptr<QuicEncryptedPacket> BuildIetfVersionNegotiationPacket(
-      QuicConnectionId connection_id,
+      QuicConnectionId server_connection_id,
+      QuicConnectionId client_connection_id,
       const ParsedQuicVersionVector& versions);
 
   // If header.version_flag is set, the version in the
@@ -576,14 +578,23 @@
   // If true, QuicFramer will change its expected connection ID length
   // to the received destination connection ID length of all IETF long headers.
   void SetShouldUpdateExpectedConnectionIdLength(
-      bool should_update_expected_connection_id_length) {
-    should_update_expected_connection_id_length_ =
-        should_update_expected_connection_id_length;
+      bool should_update_expected_server_connection_id_length) {
+    should_update_expected_server_connection_id_length_ =
+        should_update_expected_server_connection_id_length;
   }
 
-  // The connection ID length the framer expects on incoming IETF short headers.
-  uint8_t GetExpectedConnectionIdLength() {
-    return expected_connection_id_length_;
+  // The connection ID length the framer expects on incoming IETF short headers
+  // on the server.
+  uint8_t GetExpectedServerConnectionIdLength() {
+    return expected_server_connection_id_length_;
+  }
+
+  // Change the expected destination connection ID length for short headers on
+  // the client.
+  void SetExpectedClientConnectionIdLength(
+      uint8_t expected_client_connection_id_length) {
+    expected_client_connection_id_length_ =
+        expected_client_connection_id_length;
   }
 
   void EnableMultiplePacketNumberSpacesSupport();
@@ -715,8 +726,9 @@
   static bool ProcessAndValidateIetfConnectionIdLength(
       QuicDataReader* reader,
       ParsedQuicVersion version,
-      bool should_update_expected_connection_id_length,
-      uint8_t* expected_connection_id_length,
+      Perspective perspective,
+      bool should_update_expected_server_connection_id_length,
+      uint8_t* expected_server_connection_id_length,
       uint8_t* destination_connection_id_length,
       uint8_t* source_connection_id_length,
       std::string* detailed_error);
@@ -958,8 +970,10 @@
   // Largest successfully decrypted packet number per packet number space. Only
   // used when supports_multiple_packet_number_spaces_ is true.
   QuicPacketNumber largest_decrypted_packet_numbers_[NUM_PACKET_NUMBER_SPACES];
-  // Updated by WritePacketHeader.
-  QuicConnectionId last_serialized_connection_id_;
+  // Last server connection ID seen on the wire.
+  QuicConnectionId last_serialized_server_connection_id_;
+  // Last client connection ID seen on the wire.
+  QuicConnectionId last_serialized_client_connection_id_;
   // The last QUIC version label received.
   // TODO(fayang): Remove this when deprecating
   // quic_no_framer_object_in_dispatcher.
@@ -1014,18 +1028,18 @@
   bool infer_packet_header_type_from_version_;
 
   // IETF short headers contain a destination connection ID but do not
-  // encode its length. This variable contains the length we expect to read.
-  // This is also used to validate the long header connection ID lengths in
-  // older versions of QUIC.
-  // TODO(fayang): Remove this when deprecating
-  // quic_no_framer_object_in_dispatcher.
-  uint8_t expected_connection_id_length_;
+  // encode its length. These variables contains the length we expect to read.
+  // This is also used to validate the long header destination connection ID
+  // lengths in older versions of QUIC.
+  uint8_t expected_server_connection_id_length_;
+  uint8_t expected_client_connection_id_length_;
 
-  // When this is true, QuicFramer will change expected_connection_id_length_
-  // to the received destination connection ID length of all IETF long headers.
+  // When this is true, QuicFramer will change
+  // expected_server_connection_id_length_ to the received destination
+  // connection ID length of all IETF long headers.
   // TODO(fayang): Remove this when deprecating
   // quic_no_framer_object_in_dispatcher.
-  bool should_update_expected_connection_id_length_;
+  bool should_update_expected_server_connection_id_length_;
 
   // Indicates whether this framer supports multiple packet number spaces.
   bool supports_multiple_packet_number_spaces_;
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index bf87ace..5f46e8e 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -916,18 +916,17 @@
 
   PacketHeaderFormat format;
   bool version_flag;
-  uint8_t destination_connection_id_length;
-  QuicConnectionId destination_connection_id;
+  QuicConnectionId destination_connection_id, source_connection_id;
   QuicVersionLabel version_label;
   std::string detailed_error;
-  EXPECT_EQ(QUIC_NO_ERROR, QuicFramer::ProcessPacketDispatcher(
-                               *encrypted, kQuicDefaultConnectionIdLength,
-                               &format, &version_flag, &version_label,
-                               &destination_connection_id_length,
-                               &destination_connection_id, &detailed_error));
+  EXPECT_EQ(QUIC_NO_ERROR,
+            QuicFramer::ProcessPacketDispatcher(
+                *encrypted, kQuicDefaultConnectionIdLength, &format,
+                &version_flag, &version_label, &destination_connection_id,
+                &source_connection_id, &detailed_error));
   EXPECT_EQ(GOOGLE_QUIC_PACKET, format);
   EXPECT_FALSE(version_flag);
-  EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id_length);
+  EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id.length());
   EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
 }
 
@@ -994,25 +993,24 @@
 
   PacketHeaderFormat format;
   bool version_flag;
-  uint8_t destination_connection_id_length;
-  QuicConnectionId destination_connection_id;
+  QuicConnectionId destination_connection_id, source_connection_id;
   QuicVersionLabel version_label;
   std::string detailed_error;
-  EXPECT_EQ(QUIC_NO_ERROR, QuicFramer::ProcessPacketDispatcher(
-                               *encrypted, kQuicDefaultConnectionIdLength,
-                               &format, &version_flag, &version_label,
-                               &destination_connection_id_length,
-                               &destination_connection_id, &detailed_error));
+  EXPECT_EQ(QUIC_NO_ERROR,
+            QuicFramer::ProcessPacketDispatcher(
+                *encrypted, kQuicDefaultConnectionIdLength, &format,
+                &version_flag, &version_label, &destination_connection_id,
+                &source_connection_id, &detailed_error));
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
   EXPECT_TRUE(version_flag);
-  EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id_length);
+  EXPECT_EQ(kQuicDefaultConnectionIdLength, destination_connection_id.length());
   EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) {
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
-  QuicFramerPeer::SetLastSerializedConnectionId(&framer_,
-                                                FramerTestConnectionId());
+  QuicFramerPeer::SetLastSerializedServerConnectionId(&framer_,
+                                                      FramerTestConnectionId());
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
 
   // clang-format off
@@ -6626,7 +6624,8 @@
   QuicConnectionId connection_id = FramerTestConnectionId();
   std::unique_ptr<QuicEncryptedPacket> data(
       framer_.BuildVersionNegotiationPacket(
-          connection_id, framer_.transport_version() > QUIC_VERSION_43,
+          connection_id, EmptyQuicConnectionId(),
+          framer_.transport_version() > QUIC_VERSION_43,
           SupportedVersions(GetParam())));
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
                                       data->length(), AsChars(p), p_size);
@@ -13182,8 +13181,8 @@
   QuicConnectionId connection_id(connection_id_bytes,
                                  sizeof(connection_id_bytes));
   QuicFramerPeer::SetLargestPacketNumber(&framer_, kPacketNumber - 2);
-  QuicFramerPeer::SetExpectedConnectionIDLength(&framer_,
-                                                connection_id.length());
+  QuicFramerPeer::SetExpectedServerConnectionIDLength(&framer_,
+                                                      connection_id.length());
 
   // clang-format off
   PacketFragments packet = {
@@ -13320,8 +13319,7 @@
 
   PacketHeaderFormat format;
   bool version_flag;
-  uint8_t destination_connection_id_length;
-  QuicConnectionId destination_connection_id;
+  QuicConnectionId destination_connection_id, source_connection_id;
   QuicVersionLabel version_label;
   std::string detailed_error;
   EXPECT_EQ(QUIC_NO_ERROR,
@@ -13329,21 +13327,21 @@
                 QuicEncryptedPacket(AsChars(long_header_packet),
                                     QUIC_ARRAYSIZE(long_header_packet)),
                 kQuicDefaultConnectionIdLength, &format, &version_flag,
-                &version_label, &destination_connection_id_length,
-                &destination_connection_id, &detailed_error));
+                &version_label, &destination_connection_id,
+                &source_connection_id, &detailed_error));
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
   EXPECT_TRUE(version_flag);
-  EXPECT_EQ(9, destination_connection_id_length);
+  EXPECT_EQ(9, destination_connection_id.length());
   EXPECT_EQ(FramerTestConnectionIdNineBytes(), destination_connection_id);
 
-  EXPECT_EQ(QUIC_NO_ERROR,
-            QuicFramer::ProcessPacketDispatcher(
-                short_header_encrypted, 9, &format, &version_flag,
-                &version_label, &destination_connection_id_length,
-                &destination_connection_id, &detailed_error));
+  EXPECT_EQ(
+      QUIC_NO_ERROR,
+      QuicFramer::ProcessPacketDispatcher(
+          short_header_encrypted, 9, &format, &version_flag, &version_label,
+          &destination_connection_id, &source_connection_id, &detailed_error));
   EXPECT_EQ(IETF_QUIC_SHORT_HEADER_PACKET, format);
   EXPECT_FALSE(version_flag);
-  EXPECT_EQ(9, destination_connection_id_length);
+  EXPECT_EQ(9, destination_connection_id.length());
   EXPECT_EQ(FramerTestConnectionIdNineBytes(), destination_connection_id);
 }
 
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index c013ce8..47af951 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -53,15 +53,15 @@
 #define ENDPOINT \
   (framer_->perspective() == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
-QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
+QuicPacketCreator::QuicPacketCreator(QuicConnectionId server_connection_id,
                                      QuicFramer* framer,
                                      DelegateInterface* delegate)
-    : QuicPacketCreator(connection_id,
+    : QuicPacketCreator(server_connection_id,
                         framer,
                         QuicRandom::GetInstance(),
                         delegate) {}
 
-QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
+QuicPacketCreator::QuicPacketCreator(QuicConnectionId server_connection_id,
                                      QuicFramer* framer,
                                      QuicRandom* random,
                                      DelegateInterface* delegate)
@@ -72,9 +72,10 @@
       send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
       have_diversification_nonce_(false),
       max_packet_length_(0),
-      connection_id_included_(CONNECTION_ID_PRESENT),
+      server_connection_id_included_(CONNECTION_ID_PRESENT),
       packet_size_(0),
-      connection_id_(connection_id),
+      server_connection_id_(server_connection_id),
+      client_connection_id_(EmptyQuicConnectionId()),
       packet_(QuicPacketNumber(),
               PACKET_1BYTE_PACKET_NUMBER,
               nullptr,
@@ -626,8 +627,9 @@
     const ParsedQuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
   std::unique_ptr<QuicEncryptedPacket> encrypted =
-      QuicFramer::BuildVersionNegotiationPacket(connection_id_, ietf_quic,
-                                                supported_versions);
+      QuicFramer::BuildVersionNegotiationPacket(server_connection_id_,
+                                                client_connection_id_,
+                                                ietf_quic, supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(max_packet_length_, encrypted->length());
   return encrypted;
@@ -737,24 +739,24 @@
 
 QuicConnectionId QuicPacketCreator::GetDestinationConnectionId() const {
   if (!GetQuicRestartFlag(quic_do_not_override_connection_id)) {
-    return connection_id_;
+    return server_connection_id_;
   }
   QUIC_RESTART_FLAG_COUNT_N(quic_do_not_override_connection_id, 1, 5);
   if (framer_->perspective() == Perspective::IS_SERVER) {
-    return EmptyQuicConnectionId();
+    return client_connection_id_;
   }
-  return connection_id_;
+  return server_connection_id_;
 }
 
 QuicConnectionId QuicPacketCreator::GetSourceConnectionId() const {
   if (!GetQuicRestartFlag(quic_do_not_override_connection_id)) {
-    return connection_id_;
+    return server_connection_id_;
   }
   QUIC_RESTART_FLAG_COUNT_N(quic_do_not_override_connection_id, 6, 6);
   if (framer_->perspective() == Perspective::IS_CLIENT) {
-    return EmptyQuicConnectionId();
+    return client_connection_id_;
   }
-  return connection_id_;
+  return server_connection_id_;
 }
 
 QuicConnectionIdIncluded QuicPacketCreator::GetDestinationConnectionIdIncluded()
@@ -763,30 +765,33 @@
       GetQuicRestartFlag(quic_do_not_override_connection_id)) {
     // Packets sent by client always include destination connection ID, and
     // those sent by the server do not include destination connection ID.
-    return framer_->perspective() == Perspective::IS_CLIENT
+    return (framer_->perspective() == Perspective::IS_CLIENT ||
+            framer_->version().SupportsClientConnectionIds())
                ? CONNECTION_ID_PRESENT
                : CONNECTION_ID_ABSENT;
   }
-  return connection_id_included_;
+  return server_connection_id_included_;
 }
 
 QuicConnectionIdIncluded QuicPacketCreator::GetSourceConnectionIdIncluded()
     const {
   // Long header packets sent by server include source connection ID.
-  if (HasIetfLongHeader() && framer_->perspective() == Perspective::IS_SERVER) {
+  if (HasIetfLongHeader() &&
+      (framer_->perspective() == Perspective::IS_SERVER ||
+       framer_->version().SupportsClientConnectionIds())) {
     return CONNECTION_ID_PRESENT;
   }
   if (GetQuicRestartFlag(quic_do_not_override_connection_id) &&
       framer_->perspective() == Perspective::IS_SERVER) {
     QUIC_RESTART_FLAG_COUNT_N(quic_do_not_override_connection_id, 2, 5);
-    return connection_id_included_;
+    return server_connection_id_included_;
   }
   return CONNECTION_ID_ABSENT;
 }
 
 QuicConnectionIdLength QuicPacketCreator::GetDestinationConnectionIdLength()
     const {
-  DCHECK(QuicUtils::IsConnectionIdValidForVersion(connection_id_,
+  DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
                                                   transport_version()));
   return GetDestinationConnectionIdIncluded() == CONNECTION_ID_PRESENT
              ? static_cast<QuicConnectionIdLength>(
@@ -795,7 +800,7 @@
 }
 
 QuicConnectionIdLength QuicPacketCreator::GetSourceConnectionIdLength() const {
-  DCHECK(QuicUtils::IsConnectionIdValidForVersion(connection_id_,
+  DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
                                                   transport_version()));
   return GetSourceConnectionIdIncluded() == CONNECTION_ID_PRESENT
              ? static_cast<QuicConnectionIdLength>(
@@ -1019,17 +1024,25 @@
   return packet_.encryption_level == ENCRYPTION_INITIAL;
 }
 
-void QuicPacketCreator::SetConnectionIdIncluded(
-    QuicConnectionIdIncluded connection_id_included) {
-  DCHECK(connection_id_included == CONNECTION_ID_PRESENT ||
-         connection_id_included == CONNECTION_ID_ABSENT);
+void QuicPacketCreator::SetServerConnectionIdIncluded(
+    QuicConnectionIdIncluded server_connection_id_included) {
+  DCHECK(server_connection_id_included == CONNECTION_ID_PRESENT ||
+         server_connection_id_included == CONNECTION_ID_ABSENT);
   DCHECK(framer_->perspective() == Perspective::IS_SERVER ||
-         connection_id_included != CONNECTION_ID_ABSENT);
-  connection_id_included_ = connection_id_included;
+         server_connection_id_included != CONNECTION_ID_ABSENT);
+  server_connection_id_included_ = server_connection_id_included;
 }
 
-void QuicPacketCreator::SetConnectionId(QuicConnectionId connection_id) {
-  connection_id_ = connection_id;
+void QuicPacketCreator::SetServerConnectionId(
+    QuicConnectionId server_connection_id) {
+  server_connection_id_ = server_connection_id;
+}
+
+void QuicPacketCreator::SetClientConnectionId(
+    QuicConnectionId client_connection_id) {
+  DCHECK(client_connection_id.IsEmpty() ||
+         framer_->version().SupportsClientConnectionIds());
+  client_connection_id_ = client_connection_id;
 }
 
 void QuicPacketCreator::SetTransmissionType(TransmissionType type) {
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 6e1f7a2..b666f71 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -56,10 +56,10 @@
     virtual void OnFrameAddedToPacket(const QuicFrame& frame) {}
   };
 
-  QuicPacketCreator(QuicConnectionId connection_id,
+  QuicPacketCreator(QuicConnectionId server_connection_id,
                     QuicFramer* framer,
                     DelegateInterface* delegate);
-  QuicPacketCreator(QuicConnectionId connection_id,
+  QuicPacketCreator(QuicConnectionId server_connection_id,
                     QuicFramer* framer,
                     QuicRandom* random,
                     DelegateInterface* delegate);
@@ -222,11 +222,15 @@
   // Returns length of source connection ID to send over the wire.
   QuicConnectionIdLength GetSourceConnectionIdLength() const;
 
-  // Sets whether the connection ID should be sent over the wire.
-  void SetConnectionIdIncluded(QuicConnectionIdIncluded connection_id_included);
+  // Sets whether the server connection ID should be sent over the wire.
+  void SetServerConnectionIdIncluded(
+      QuicConnectionIdIncluded server_connection_id_included);
 
-  // Update the connection ID used in outgoing packets.
-  void SetConnectionId(QuicConnectionId connection_id);
+  // Update the server connection ID used in outgoing packets.
+  void SetServerConnectionId(QuicConnectionId server_connection_id);
+
+  // Update the client connection ID used in outgoing packets.
+  void SetClientConnectionId(QuicConnectionId client_connection_id);
 
   // Sets the encryption level that will be applied to new packets.
   void set_encryption_level(EncryptionLevel level) {
@@ -393,8 +397,8 @@
   // Maximum length including headers and encryption (UDP payload length.)
   QuicByteCount max_packet_length_;
   size_t max_plaintext_size_;
-  // Whether the connection_id is sent over the wire.
-  QuicConnectionIdIncluded connection_id_included_;
+  // Whether the server_connection_id is sent over the wire.
+  QuicConnectionIdIncluded server_connection_id_included_;
 
   // Frames to be added to the next SerializedPacket
   QuicFrames queued_frames_;
@@ -403,7 +407,8 @@
   // TODO(ianswett): Move packet_size_ into SerializedPacket once
   // QuicEncryptedPacket has been flattened into SerializedPacket.
   size_t packet_size_;
-  QuicConnectionId connection_id_;
+  QuicConnectionId server_connection_id_;
+  QuicConnectionId client_connection_id_;
 
   // Packet used to invoke OnSerializedPacket.
   SerializedPacket packet_;
diff --git a/quic/core/quic_packet_generator.cc b/quic/core/quic_packet_generator.cc
index d811f9d..766f8ca 100644
--- a/quic/core/quic_packet_generator.cc
+++ b/quic/core/quic_packet_generator.cc
@@ -17,12 +17,12 @@
 
 namespace quic {
 
-QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId connection_id,
+QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId server_connection_id,
                                          QuicFramer* framer,
                                          QuicRandom* random_generator,
                                          DelegateInterface* delegate)
     : delegate_(delegate),
-      packet_creator_(connection_id, framer, random_generator, delegate),
+      packet_creator_(server_connection_id, framer, random_generator, delegate),
       next_transmission_type_(NOT_RETRANSMISSION),
       flusher_attached_(false),
       should_send_ack_(false),
@@ -438,11 +438,11 @@
                                                   max_packets_in_flight);
 }
 
-void QuicPacketGenerator::SetConnectionIdLength(uint32_t length) {
+void QuicPacketGenerator::SetServerConnectionIdLength(uint32_t length) {
   if (length == 0) {
-    packet_creator_.SetConnectionIdIncluded(CONNECTION_ID_ABSENT);
+    packet_creator_.SetServerConnectionIdIncluded(CONNECTION_ID_ABSENT);
   } else {
-    packet_creator_.SetConnectionIdIncluded(CONNECTION_ID_PRESENT);
+    packet_creator_.SetServerConnectionIdIncluded(CONNECTION_ID_PRESENT);
   }
 }
 
@@ -569,8 +569,14 @@
   return packet_creator_.GetGuaranteedLargestMessagePayload();
 }
 
-void QuicPacketGenerator::SetConnectionId(QuicConnectionId connection_id) {
-  packet_creator_.SetConnectionId(connection_id);
+void QuicPacketGenerator::SetServerConnectionId(
+    QuicConnectionId server_connection_id) {
+  packet_creator_.SetServerConnectionId(server_connection_id);
+}
+
+void QuicPacketGenerator::SetClientConnectionId(
+    QuicConnectionId client_connection_id) {
+  packet_creator_.SetClientConnectionId(client_connection_id);
 }
 
 }  // namespace quic
diff --git a/quic/core/quic_packet_generator.h b/quic/core/quic_packet_generator.h
index 417fda6..ec25550 100644
--- a/quic/core/quic_packet_generator.h
+++ b/quic/core/quic_packet_generator.h
@@ -76,7 +76,7 @@
         QuicStopWaitingFrame* stop_waiting) = 0;
   };
 
-  QuicPacketGenerator(QuicConnectionId connection_id,
+  QuicPacketGenerator(QuicConnectionId server_connection_id,
                       QuicFramer* framer,
                       QuicRandom* random_generator,
                       DelegateInterface* delegate);
@@ -185,8 +185,8 @@
   void UpdatePacketNumberLength(QuicPacketNumber least_packet_awaited_by_peer,
                                 QuicPacketCount max_packets_in_flight);
 
-  // Set the minimum number of bytes for the connection id length;
-  void SetConnectionIdLength(uint32_t length);
+  // Set the minimum number of bytes for the server connection id length;
+  void SetServerConnectionIdLength(uint32_t length);
 
   // Sets the encrypter to use for the encryption level.
   void SetEncrypter(EncryptionLevel level,
@@ -235,8 +235,11 @@
   QuicPacketLength GetCurrentLargestMessagePayload() const;
   QuicPacketLength GetGuaranteedLargestMessagePayload() const;
 
-  // Update the connection ID used in outgoing packets.
-  void SetConnectionId(QuicConnectionId connection_id);
+  // Update the server connection ID used in outgoing packets.
+  void SetServerConnectionId(QuicConnectionId server_connection_id);
+
+  // Update the client connection ID used in outgoing packets.
+  void SetClientConnectionId(QuicConnectionId client_connection_id);
 
   void set_debug_delegate(QuicPacketCreator::DebugDelegate* debug_delegate) {
     packet_creator_.set_debug_delegate(debug_delegate);
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index 676d6e7..e1899ff 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -1139,12 +1139,12 @@
 
 TEST_F(QuicPacketGeneratorTest, TestConnectionIdLength) {
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
-  generator_.SetConnectionIdLength(0);
+  generator_.SetServerConnectionIdLength(0);
   EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
             creator_->GetDestinationConnectionIdLength());
 
   for (size_t i = 1; i < 10; i++) {
-    generator_.SetConnectionIdLength(i);
+    generator_.SetServerConnectionIdLength(i);
     if (framer_.transport_version() > QUIC_VERSION_43) {
       EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
                 creator_->GetDestinationConnectionIdLength());
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index 57bda54..738cc6e 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -27,6 +27,16 @@
   return header.source_connection_id;
 }
 
+QuicConnectionId GetClientConnectionIdAsRecipient(
+    const QuicPacketHeader& header,
+    Perspective perspective) {
+  DCHECK(GetQuicRestartFlag(quic_do_not_override_connection_id));
+  if (perspective == Perspective::IS_CLIENT) {
+    return header.destination_connection_id;
+  }
+  return header.source_connection_id;
+}
+
 QuicConnectionId GetServerConnectionIdAsSender(const QuicPacketHeader& header,
                                                Perspective perspective) {
   if (perspective == Perspective::IS_CLIENT ||
@@ -48,6 +58,16 @@
   return header.source_connection_id_included;
 }
 
+QuicConnectionId GetClientConnectionIdAsSender(const QuicPacketHeader& header,
+                                               Perspective perspective) {
+  if (perspective == Perspective::IS_CLIENT ||
+      !GetQuicRestartFlag(quic_do_not_override_connection_id)) {
+    return header.source_connection_id;
+  }
+  QUIC_RESTART_FLAG_COUNT_N(quic_do_not_override_connection_id, 3, 5);
+  return header.destination_connection_id;
+}
+
 QuicConnectionIdIncluded GetClientConnectionIdIncludedAsSender(
     const QuicPacketHeader& header,
     Perspective perspective) {
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h
index d3c2600..b1964e7 100644
--- a/quic/core/quic_packets.h
+++ b/quic/core/quic_packets.h
@@ -41,6 +41,12 @@
 // Returns the destination connection ID of |header| when |perspective| is
 // client, and the source connection ID when |perspective| is server.
 QUIC_EXPORT_PRIVATE QuicConnectionId
+GetClientConnectionIdAsRecipient(const QuicPacketHeader& header,
+                                 Perspective perspective);
+
+// Returns the destination connection ID of |header| when |perspective| is
+// client, and the source connection ID when |perspective| is server.
+QUIC_EXPORT_PRIVATE QuicConnectionId
 GetServerConnectionIdAsSender(const QuicPacketHeader& header,
                               Perspective perspective);
 
@@ -51,6 +57,12 @@
 GetServerConnectionIdIncludedAsSender(const QuicPacketHeader& header,
                                       Perspective perspective);
 
+// Returns the destination connection ID of |header| when |perspective| is
+// server, and the source connection ID when |perspective| is client.
+QUIC_EXPORT_PRIVATE QuicConnectionId
+GetClientConnectionIdAsSender(const QuicPacketHeader& header,
+                              Perspective perspective);
+
 // Returns the destination connection ID included of |header| when |perspective|
 // is server, and the source connection ID included when |perspective| is
 // client.
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index d8f40c9..dc7153a 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -52,7 +52,7 @@
     virtual ~Visitor() {}
 
     // Called when the connection is closed after the streams have been closed.
-    virtual void OnConnectionClosed(QuicConnectionId connection_id,
+    virtual void OnConnectionClosed(QuicConnectionId server_connection_id,
                                     QuicErrorCode error,
                                     const std::string& error_details,
                                     ConnectionCloseSource source) = 0;
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc
index fa62fc5..d646f41 100644
--- a/quic/core/quic_time_wait_list_manager.cc
+++ b/quic/core/quic_time_wait_list_manager.cc
@@ -200,7 +200,8 @@
 }
 
 void QuicTimeWaitListManager::SendVersionNegotiationPacket(
-    QuicConnectionId connection_id,
+    QuicConnectionId server_connection_id,
+    QuicConnectionId client_connection_id,
     bool ietf_quic,
     const ParsedQuicVersionVector& supported_versions,
     const QuicSocketAddress& self_address,
@@ -209,7 +210,8 @@
   SendOrQueuePacket(QuicMakeUnique<QueuedPacket>(
                         self_address, peer_address,
                         QuicFramer::BuildVersionNegotiationPacket(
-                            connection_id, ietf_quic, supported_versions)),
+                            server_connection_id, client_connection_id,
+                            ietf_quic, supported_versions)),
                     packet_context.get());
 }
 
diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h
index dee5d11..26e894d 100644
--- a/quic/core/quic_time_wait_list_manager.h
+++ b/quic/core/quic_time_wait_list_manager.h
@@ -121,7 +121,8 @@
   // Sends a version negotiation packet for |connection_id| announcing support
   // for |supported_versions| to |peer_address| from |self_address|.
   virtual void SendVersionNegotiationPacket(
-      QuicConnectionId connection_id,
+      QuicConnectionId server_connection_id,
+      QuicConnectionId client_connection_id,
       bool ietf_quic,
       const ParsedQuicVersionVector& supported_versions,
       const QuicSocketAddress& self_address,
diff --git a/quic/core/quic_time_wait_list_manager_test.cc b/quic/core/quic_time_wait_list_manager_test.cc
index a391390..c1dadba 100644
--- a/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quic/core/quic_time_wait_list_manager_test.cc
@@ -251,15 +251,16 @@
 
 TEST_F(QuicTimeWaitListManagerTest, SendVersionNegotiationPacket) {
   std::unique_ptr<QuicEncryptedPacket> packet(
-      QuicFramer::BuildVersionNegotiationPacket(connection_id_, false,
+      QuicFramer::BuildVersionNegotiationPacket(connection_id_,
+                                                EmptyQuicConnectionId(), false,
                                                 AllSupportedVersions()));
   EXPECT_CALL(writer_, WritePacket(_, packet->length(), self_address_.host(),
                                    peer_address_, _))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 
   time_wait_list_manager_.SendVersionNegotiationPacket(
-      connection_id_, false, AllSupportedVersions(), self_address_,
-      peer_address_, QuicMakeUnique<QuicPerPacketContext>());
+      connection_id_, EmptyQuicConnectionId(), false, AllSupportedVersions(),
+      self_address_, peer_address_, QuicMakeUnique<QuicPerPacketContext>());
   EXPECT_EQ(0u, time_wait_list_manager_.num_connections());
 }
 
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index a1f4d8e..ed493a5 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -55,6 +55,16 @@
   return transport_version > QUIC_VERSION_46;
 }
 
+bool ParsedQuicVersion::SupportsClientConnectionIds() const {
+  if (!GetQuicRestartFlag(quic_do_not_override_connection_id)) {
+    // Do not enable this feature in a production version until this flag has
+    // been deprecated.
+    return false;
+  }
+  return transport_version >= QUIC_VERSION_99 ||
+         transport_version == QUIC_VERSION_UNSUPPORTED;
+}
+
 std::ostream& operator<<(std::ostream& os, const ParsedQuicVersion& version) {
   os << ParsedQuicVersionToString(version);
   return os;
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 7853134..1f6a431 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -162,6 +162,9 @@
 
   // Returns whether this version supports IETF RETRY packets.
   bool SupportsRetry() const;
+
+  // Returns whether this version supports client connection ID.
+  bool SupportsClientConnectionIds() const;
 };
 
 QUIC_EXPORT_PRIVATE ParsedQuicVersion UnsupportedQuicVersion();
diff --git a/quic/quartc/quartc_dispatcher.cc b/quic/quartc/quartc_dispatcher.cc
index fd4f289..091d56b 100644
--- a/quic/quartc/quartc_dispatcher.cc
+++ b/quic/quartc/quartc_dispatcher.cc
@@ -39,7 +39,7 @@
   // Allow incoming packets to set our expected connection ID length.
   SetShouldUpdateExpectedConnectionIdLength(true);
   // Allow incoming packets with connection ID lengths shorter than allowed.
-  SetAllowShortInitialConnectionIds(true);
+  SetAllowShortInitialServerConnectionIds(true);
   // QuicDispatcher takes ownership of the writer.
   QuicDispatcher::InitializeWithWriter(packet_writer.release());
   // NB: This must happen *after* InitializeWithWriter.  It can call us back
diff --git a/quic/quartc/quartc_dispatcher.h b/quic/quartc/quartc_dispatcher.h
index 26b52ac..239b6ef 100644
--- a/quic/quartc/quartc_dispatcher.h
+++ b/quic/quartc/quartc_dispatcher.h
@@ -41,7 +41,7 @@
       Delegate* delegate);
   ~QuartcDispatcher() override;
 
-  QuartcSession* CreateQuicSession(QuicConnectionId connection_id,
+  QuartcSession* CreateQuicSession(QuicConnectionId server_connection_id,
                                    const QuicSocketAddress& client_address,
                                    QuicStringPiece alpn,
                                    const ParsedQuicVersion& version) override;
diff --git a/quic/test_tools/mock_quic_time_wait_list_manager.h b/quic/test_tools/mock_quic_time_wait_list_manager.h
index d13d5ac..8a39442 100644
--- a/quic/test_tools/mock_quic_time_wait_list_manager.h
+++ b/quic/test_tools/mock_quic_time_wait_list_manager.h
@@ -45,8 +45,9 @@
                     PacketHeaderFormat header_format,
                     std::unique_ptr<QuicPerPacketContext> packet_context));
 
-  MOCK_METHOD6(SendVersionNegotiationPacket,
-               void(QuicConnectionId connection_id,
+  MOCK_METHOD7(SendVersionNegotiationPacket,
+               void(QuicConnectionId server_connection_id,
+                    QuicConnectionId client_connection_id,
                     bool ietf_quic,
                     const ParsedQuicVersionVector& supported_versions,
                     const QuicSocketAddress& server_address,
diff --git a/quic/test_tools/quic_framer_peer.cc b/quic/test_tools/quic_framer_peer.cc
index 23486ea..6eedd60 100644
--- a/quic/test_tools/quic_framer_peer.cc
+++ b/quic/test_tools/quic_framer_peer.cc
@@ -22,10 +22,10 @@
 }
 
 // static
-void QuicFramerPeer::SetLastSerializedConnectionId(
+void QuicFramerPeer::SetLastSerializedServerConnectionId(
     QuicFramer* framer,
-    QuicConnectionId connection_id) {
-  framer->last_serialized_connection_id_ = connection_id;
+    QuicConnectionId server_connection_id) {
+  framer->last_serialized_server_connection_id_ = server_connection_id;
 }
 
 // static
@@ -337,11 +337,11 @@
 }
 
 // static
-void QuicFramerPeer::SetExpectedConnectionIDLength(
+void QuicFramerPeer::SetExpectedServerConnectionIDLength(
     QuicFramer* framer,
-    uint8_t expected_connection_id_length) {
-  *const_cast<uint8_t*>(&framer->expected_connection_id_length_) =
-      expected_connection_id_length;
+    uint8_t expected_server_connection_id_length) {
+  *const_cast<uint8_t*>(&framer->expected_server_connection_id_length_) =
+      expected_server_connection_id_length;
 }
 
 // static
diff --git a/quic/test_tools/quic_framer_peer.h b/quic/test_tools/quic_framer_peer.h
index 4a5efa6..0b17c19 100644
--- a/quic/test_tools/quic_framer_peer.h
+++ b/quic/test_tools/quic_framer_peer.h
@@ -22,8 +22,9 @@
       QuicPacketNumberLength packet_number_length,
       QuicPacketNumber last_packet_number,
       uint64_t packet_number);
-  static void SetLastSerializedConnectionId(QuicFramer* framer,
-                                            QuicConnectionId connection_id);
+  static void SetLastSerializedServerConnectionId(
+      QuicFramer* framer,
+      QuicConnectionId server_connection_id);
   static void SetLargestPacketNumber(QuicFramer* framer,
                                      QuicPacketNumber packet_number);
   static void SetPerspective(QuicFramer* framer, Perspective perspective);
@@ -159,9 +160,9 @@
                                    QuicPacketNumberLength packet_number_length);
   static void SetFirstSendingPacketNumber(QuicFramer* framer,
                                           uint64_t packet_number);
-  static void SetExpectedConnectionIDLength(
+  static void SetExpectedServerConnectionIDLength(
       QuicFramer* framer,
-      uint8_t expected_connection_id_length);
+      uint8_t expected_server_connection_id_length);
   static QuicPacketNumber GetLargestDecryptedPacketNumber(
       QuicFramer* framer,
       PacketNumberSpace packet_number_space);
diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index 497dd8a..a290e7d 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -209,8 +209,10 @@
                                                                this),
           QuicWrapUnique(
               new RecordingProofVerifier(std::move(proof_verifier)))),
-      override_connection_id_(EmptyQuicConnectionId()),
-      connection_id_overridden_(false) {}
+      override_server_connection_id_(EmptyQuicConnectionId()),
+      server_connection_id_overridden_(false),
+      override_client_connection_id_(EmptyQuicConnectionId()),
+      client_connection_id_overridden_(false) {}
 
 MockableQuicClient::~MockableQuicClient() {
   if (connected()) {
@@ -231,13 +233,26 @@
 }
 
 QuicConnectionId MockableQuicClient::GenerateNewConnectionId() {
-  return connection_id_overridden_ ? override_connection_id_
-                                   : QuicClient::GenerateNewConnectionId();
+  return server_connection_id_overridden_
+             ? override_server_connection_id_
+             : QuicClient::GenerateNewConnectionId();
 }
 
-void MockableQuicClient::UseConnectionId(QuicConnectionId connection_id) {
-  connection_id_overridden_ = true;
-  override_connection_id_ = connection_id;
+void MockableQuicClient::UseConnectionId(
+    QuicConnectionId server_connection_id) {
+  server_connection_id_overridden_ = true;
+  override_server_connection_id_ = server_connection_id;
+}
+
+QuicConnectionId MockableQuicClient::GetClientConnectionId() {
+  return client_connection_id_overridden_ ? override_client_connection_id_
+                                          : QuicClient::GetClientConnectionId();
+}
+
+void MockableQuicClient::UseClientConnectionId(
+    QuicConnectionId client_connection_id) {
+  client_connection_id_overridden_ = true;
+  override_client_connection_id_ = client_connection_id;
 }
 
 void MockableQuicClient::UseWriter(QuicPacketWriterWrapper* writer) {
@@ -759,9 +774,15 @@
   client_->UseWriter(writer);
 }
 
-void QuicTestClient::UseConnectionId(QuicConnectionId connection_id) {
+void QuicTestClient::UseConnectionId(QuicConnectionId server_connection_id) {
   DCHECK(!connected());
-  client_->UseConnectionId(connection_id);
+  client_->UseConnectionId(server_connection_id);
+}
+
+void QuicTestClient::UseClientConnectionId(
+    QuicConnectionId client_connection_id) {
+  DCHECK(!connected());
+  client_->UseClientConnectionId(client_connection_id);
 }
 
 bool QuicTestClient::MigrateSocket(const QuicIpAddress& new_host) {
diff --git a/quic/test_tools/quic_test_client.h b/quic/test_tools/quic_test_client.h
index 353c29e..5f1b6fa 100644
--- a/quic/test_tools/quic_test_client.h
+++ b/quic/test_tools/quic_test_client.h
@@ -55,7 +55,9 @@
   ~MockableQuicClient() override;
 
   QuicConnectionId GenerateNewConnectionId() override;
-  void UseConnectionId(QuicConnectionId connection_id);
+  void UseConnectionId(QuicConnectionId server_connection_id);
+  QuicConnectionId GetClientConnectionId() override;
+  void UseClientConnectionId(QuicConnectionId client_connection_id);
 
   void UseWriter(QuicPacketWriterWrapper* writer);
   void set_peer_address(const QuicSocketAddress& address);
@@ -69,9 +71,12 @@
   const MockableQuicClientEpollNetworkHelper* mockable_network_helper() const;
 
  private:
-  // ConnectionId to use, if connection_id_overridden_
-  QuicConnectionId override_connection_id_;
-  bool connection_id_overridden_;
+  // Server connection ID to use, if server_connection_id_overridden_
+  QuicConnectionId override_server_connection_id_;
+  bool server_connection_id_overridden_;
+  // Client connection ID to use, if client_connection_id_overridden_
+  QuicConnectionId override_client_connection_id_;
+  bool client_connection_id_overridden_;
   CachedNetworkParameters cached_network_paramaters_;
 };
 
@@ -219,9 +224,12 @@
   // Configures client_ to take ownership of and use the writer.
   // Must be called before initial connect.
   void UseWriter(QuicPacketWriterWrapper* writer);
-  // If the given ConnectionId is nonzero, configures client_ to use a specific
-  // ConnectionId instead of a random one.
-  void UseConnectionId(QuicConnectionId connection_id);
+  // Configures client_ to use a specific server connection ID instead of a
+  // random one.
+  void UseConnectionId(QuicConnectionId server_connection_id);
+  // Configures client_ to use a specific client connection ID instead of an
+  // empty one.
+  void UseClientConnectionId(QuicConnectionId client_connection_id);
 
   // Returns nullptr if the maximum number of streams have already been created.
   QuicSpdyClientStream* GetOrCreateStream();
diff --git a/quic/test_tools/quic_test_server.cc b/quic/test_tools/quic_test_server.cc
index bda2148..68c500e 100644
--- a/quic/test_tools/quic_test_server.cc
+++ b/quic/test_tools/quic_test_server.cc
@@ -77,7 +77,7 @@
       std::unique_ptr<QuicCryptoServerStream::Helper> session_helper,
       std::unique_ptr<QuicAlarmFactory> alarm_factory,
       QuicSimpleServerBackend* quic_simple_server_backend,
-      uint8_t expected_connection_id_length)
+      uint8_t expected_server_connection_id_length)
       : QuicSimpleDispatcher(config,
                              crypto_config,
                              version_manager,
@@ -85,7 +85,7 @@
                              std::move(session_helper),
                              std::move(alarm_factory),
                              quic_simple_server_backend,
-                             expected_connection_id_length),
+                             expected_server_connection_id_length),
         session_factory_(nullptr),
         stream_factory_(nullptr),
         crypto_stream_factory_(nullptr) {}
@@ -170,13 +170,13 @@
     const QuicConfig& config,
     const ParsedQuicVersionVector& supported_versions,
     QuicSimpleServerBackend* quic_simple_server_backend,
-    uint8_t expected_connection_id_length)
+    uint8_t expected_server_connection_id_length)
     : QuicServer(std::move(proof_source),
                  config,
                  QuicCryptoServerConfig::ConfigOptions(),
                  supported_versions,
                  quic_simple_server_backend,
-                 expected_connection_id_length) {}
+                 expected_server_connection_id_length) {}
 
 QuicDispatcher* QuicTestServer::CreateQuicDispatcher() {
   return new QuicTestDispatcher(
@@ -186,7 +186,7 @@
       std::unique_ptr<QuicCryptoServerStream::Helper>(
           new QuicSimpleCryptoServerStreamHelper(QuicRandom::GetInstance())),
       QuicMakeUnique<QuicEpollAlarmFactory>(epoll_server()), server_backend(),
-      expected_connection_id_length());
+      expected_server_connection_id_length());
 }
 
 void QuicTestServer::SetSessionFactory(SessionFactory* factory) {
diff --git a/quic/test_tools/quic_test_server.h b/quic/test_tools/quic_test_server.h
index 52fb7c5..3661b7a 100644
--- a/quic/test_tools/quic_test_server.h
+++ b/quic/test_tools/quic_test_server.h
@@ -69,7 +69,7 @@
                  const QuicConfig& config,
                  const ParsedQuicVersionVector& supported_versions,
                  QuicSimpleServerBackend* quic_simple_server_backend,
-                 uint8_t expected_connection_id_length);
+                 uint8_t expected_server_connection_id_length);
 
   // Create a custom dispatcher which creates custom sessions.
   QuicDispatcher* CreateQuicDispatcher() override;
diff --git a/quic/tools/quic_client_base.cc b/quic/tools/quic_client_base.cc
index 57cbd9a..fd4776f 100644
--- a/quic/tools/quic_client_base.cc
+++ b/quic/tools/quic_client_base.cc
@@ -135,6 +135,7 @@
                          can_reconnect_with_different_version
                              ? ParsedQuicVersionVector{mutual_version}
                              : supported_versions()));
+  session()->connection()->set_client_connection_id(GetClientConnectionId());
   if (initial_max_packet_length_ != 0) {
     session()->connection()->SetMaxPacketLength(initial_max_packet_length_);
   }
@@ -333,6 +334,10 @@
   return QuicUtils::CreateRandomConnectionId();
 }
 
+QuicConnectionId QuicClientBase::GetClientConnectionId() {
+  return EmptyQuicConnectionId();
+}
+
 bool QuicClientBase::CanReconnectWithDifferentVersion(
     ParsedQuicVersion* version) const {
   if (session_ == nullptr || session_->connection() == nullptr ||
diff --git a/quic/tools/quic_client_base.h b/quic/tools/quic_client_base.h
index 0cc4d71..134404b 100644
--- a/quic/tools/quic_client_base.h
+++ b/quic/tools/quic_client_base.h
@@ -268,6 +268,9 @@
   // connection ID).
   virtual QuicConnectionId GenerateNewConnectionId();
 
+  // Returns the client connection ID to use.
+  virtual QuicConnectionId GetClientConnectionId();
+
   QuicAlarmFactory* alarm_factory() { return alarm_factory_.get(); }
 
   // Subclasses may need to explicitly clear the session on destruction
diff --git a/quic/tools/quic_server.cc b/quic/tools/quic_server.cc
index 4ac1dac..3696b7c 100644
--- a/quic/tools/quic_server.cc
+++ b/quic/tools/quic_server.cc
@@ -64,7 +64,7 @@
     const QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
     const ParsedQuicVersionVector& supported_versions,
     QuicSimpleServerBackend* quic_simple_server_backend,
-    uint8_t expected_connection_id_length)
+    uint8_t expected_server_connection_id_length)
     : port_(0),
       fd_(-1),
       packets_dropped_(0),
@@ -80,7 +80,8 @@
       version_manager_(supported_versions),
       packet_reader_(new QuicPacketReader()),
       quic_simple_server_backend_(quic_simple_server_backend),
-      expected_connection_id_length_(expected_connection_id_length) {
+      expected_server_connection_id_length_(
+          expected_server_connection_id_length) {
   DCHECK(quic_simple_server_backend_);
   Initialize();
 }
@@ -159,7 +160,7 @@
           new QuicSimpleCryptoServerStreamHelper(QuicRandom::GetInstance())),
       std::unique_ptr<QuicEpollAlarmFactory>(
           new QuicEpollAlarmFactory(&epoll_server_)),
-      quic_simple_server_backend_, expected_connection_id_length_);
+      quic_simple_server_backend_, expected_server_connection_id_length_);
 }
 
 void QuicServer::HandleEventsForever() {
diff --git a/quic/tools/quic_server.h b/quic/tools/quic_server.h
index 6fb1646..1f9c225 100644
--- a/quic/tools/quic_server.h
+++ b/quic/tools/quic_server.h
@@ -43,7 +43,7 @@
              const QuicCryptoServerConfig::ConfigOptions& server_config_options,
              const ParsedQuicVersionVector& supported_versions,
              QuicSimpleServerBackend* quic_simple_server_backend,
-             uint8_t expected_connection_id_length);
+             uint8_t expected_server_connection_id_length);
   QuicServer(const QuicServer&) = delete;
   QuicServer& operator=(const QuicServer&) = delete;
 
@@ -103,8 +103,8 @@
 
   void set_silent_close(bool value) { silent_close_ = value; }
 
-  uint8_t expected_connection_id_length() {
-    return expected_connection_id_length_;
+  uint8_t expected_server_connection_id_length() {
+    return expected_server_connection_id_length_;
   }
 
  private:
@@ -155,7 +155,7 @@
   QuicSimpleServerBackend* quic_simple_server_backend_;  // unowned.
 
   // Connection ID length expected to be read on incoming IETF short headers.
-  uint8_t expected_connection_id_length_;
+  uint8_t expected_server_connection_id_length_;
 };
 
 }  // namespace quic
diff --git a/quic/tools/quic_simple_dispatcher.cc b/quic/tools/quic_simple_dispatcher.cc
index 4706b60..0f4d447 100644
--- a/quic/tools/quic_simple_dispatcher.cc
+++ b/quic/tools/quic_simple_dispatcher.cc
@@ -16,14 +16,14 @@
     std::unique_ptr<QuicCryptoServerStream::Helper> session_helper,
     std::unique_ptr<QuicAlarmFactory> alarm_factory,
     QuicSimpleServerBackend* quic_simple_server_backend,
-    uint8_t expected_connection_id_length)
+    uint8_t expected_server_connection_id_length)
     : QuicDispatcher(config,
                      crypto_config,
                      version_manager,
                      std::move(helper),
                      std::move(session_helper),
                      std::move(alarm_factory),
-                     expected_connection_id_length),
+                     expected_server_connection_id_length),
       quic_simple_server_backend_(quic_simple_server_backend) {}
 
 QuicSimpleDispatcher::~QuicSimpleDispatcher() = default;
diff --git a/quic/tools/quic_simple_dispatcher.h b/quic/tools/quic_simple_dispatcher.h
index 46d976c..8a6cf85 100644
--- a/quic/tools/quic_simple_dispatcher.h
+++ b/quic/tools/quic_simple_dispatcher.h
@@ -21,7 +21,7 @@
       std::unique_ptr<QuicCryptoServerStream::Helper> session_helper,
       std::unique_ptr<QuicAlarmFactory> alarm_factory,
       QuicSimpleServerBackend* quic_simple_server_backend,
-      uint8_t expected_connection_id_length);
+      uint8_t expected_server_connection_id_length);
 
   ~QuicSimpleDispatcher() override;