diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index dd40098..c3f50ef 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -741,10 +741,17 @@
     ASSERT_TRUE(Initialize());
     return;
   }
-  QuicConnectionId connection_id = TestConnectionIdNineBytesLong(1);
+  QuicConnectionId connection_id =
+      TestConnectionIdNineBytesLong(UINT64_C(0xBADbadBADbad));
   override_connection_id_ = &connection_id;
-  ASSERT_FALSE(Initialize());
-  EXPECT_EQ(QUIC_HANDSHAKE_FAILED, client_->connection_error());
+  ASSERT_TRUE(Initialize());
+  EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
+  EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
+  EXPECT_EQ(kQuicDefaultConnectionIdLength, client_->client()
+                                                ->client_session()
+                                                ->connection()
+                                                ->connection_id()
+                                                .length());
 }
 
 TEST_P(EndToEndTest, MixGoodAndBadConnectionIdLengths) {
@@ -754,14 +761,14 @@
     return;
   }
 
-  // Start client_ which will fail due to bad connection ID length.
-  QuicConnectionId connection_id = TestConnectionIdNineBytesLong(1);
+  // Start client_ which will use a bad connection ID length.
+  QuicConnectionId connection_id =
+      TestConnectionIdNineBytesLong(UINT64_C(0xBADbadBADbad));
   override_connection_id_ = &connection_id;
-  ASSERT_FALSE(Initialize());
-  EXPECT_EQ(QUIC_HANDSHAKE_FAILED, client_->connection_error());
+  ASSERT_TRUE(Initialize());
   override_connection_id_ = nullptr;
 
-  // Start client2 which will succeed.
+  // Start client2 which will use a good connection ID length.
   std::unique_ptr<QuicTestClient> client2(CreateQuicClient(nullptr));
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
@@ -771,9 +778,23 @@
   headers["content-length"] = "3";
   client2->SendMessage(headers, "", /*fin=*/false);
   client2->SendData("eep", true);
+
+  EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
+  EXPECT_EQ("200", client_->response_headers()->find(":status")->second);
+  EXPECT_EQ(kQuicDefaultConnectionIdLength, client_->client()
+                                                ->client_session()
+                                                ->connection()
+                                                ->connection_id()
+                                                .length());
+
   client2->WaitForResponse();
   EXPECT_EQ(kFooResponseBody, client2->response_body());
   EXPECT_EQ("200", client2->response_headers()->find(":status")->second);
+  EXPECT_EQ(kQuicDefaultConnectionIdLength, client2->client()
+                                                ->client_session()
+                                                ->connection()
+                                                ->connection_id()
+                                                .length());
 }
 
 TEST_P(EndToEndTest, SimpleRequestResponseWithLargeReject) {
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 17752a6..dcea61d 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -21,6 +21,7 @@
 #include "net/third_party/quiche/src/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/third_party/quiche/src/quic/core/quic_bandwidth.h"
 #include "net/third_party/quiche/src/quic/core/quic_config.h"
+#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_packet_generator.h"
 #include "net/third_party/quiche/src/quic/core/quic_pending_retransmission.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -206,6 +207,17 @@
   QuicConnection* connection_;
 };
 
+// Whether this incoming packet is allowed to replace our connection ID.
+bool PacketCanReplaceConnectionId(const QuicPacketHeader& header,
+                                  Perspective perspective) {
+  return perspective == Perspective::IS_CLIENT &&
+         header.form == IETF_QUIC_LONG_HEADER_PACKET &&
+         QuicUtils::VariableLengthConnectionIdAllowedForVersion(
+             header.version.transport_version) &&
+         (header.long_packet_type == INITIAL ||
+          header.long_packet_type == RETRY);
+}
+
 }  // namespace
 
 #define ENDPOINT \
@@ -719,9 +731,34 @@
   RetransmitUnackedPackets(ALL_UNACKED_RETRANSMISSION);
 }
 
+bool QuicConnection::HasIncomingConnectionId(QuicConnectionId connection_id) {
+  for (QuicConnectionId const& incoming_connection_id :
+       incoming_connection_ids_) {
+    if (incoming_connection_id == connection_id) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void QuicConnection::AddIncomingConnectionId(QuicConnectionId connection_id) {
+  if (HasIncomingConnectionId(connection_id)) {
+    return;
+  }
+  incoming_connection_ids_.push_back(connection_id);
+}
+
 bool QuicConnection::OnUnauthenticatedPublicHeader(
     const QuicPacketHeader& header) {
-  if (header.destination_connection_id == connection_id_) {
+  if (header.destination_connection_id == connection_id_ ||
+      HasIncomingConnectionId(header.destination_connection_id)) {
+    return true;
+  }
+
+  if (PacketCanReplaceConnectionId(header, perspective_)) {
+    QUIC_DLOG(INFO) << ENDPOINT << "Accepting packet with new connection ID "
+                    << header.destination_connection_id << " instead of "
+                    << connection_id_;
     return true;
   }
 
@@ -748,7 +785,9 @@
   // Check that any public reset packet with a different connection ID that was
   // routed to this QuicConnection has been redirected before control reaches
   // here.
-  DCHECK_EQ(connection_id_, header.destination_connection_id);
+  DCHECK(header.destination_connection_id == connection_id_ ||
+         HasIncomingConnectionId(header.destination_connection_id) ||
+         PacketCanReplaceConnectionId(header, perspective_));
 
   if (!packet_generator_.IsPendingPacketEmpty()) {
     // Incoming packets may change a queued ACK frame.
@@ -1947,6 +1986,14 @@
     self_address_ = last_packet_destination_address_;
   }
 
+  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_);
+  }
+
   if (!ValidateReceivedPacketNumber(header.packet_number)) {
     return false;
   }
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index a2202ee..715a449 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -30,6 +30,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_alarm.h"
 #include "net/third_party/quiche/src/quic/core/quic_alarm_factory.h"
 #include "net/third_party/quiche/src/quic/core/quic_blocked_writer_interface.h"
+#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_stats.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_one_block_arena.h"
@@ -864,6 +865,10 @@
     return sent_packet_manager_.handshake_confirmed();
   }
 
+  // Adds the connection ID to a set of connection IDs that are accepted as
+  // destination on incoming packets.
+  void AddIncomingConnectionId(QuicConnectionId connection_id);
+
  protected:
   // Calls cancel() on all the alarms owned by this connection.
   void CancelAllAlarms();
@@ -1111,6 +1116,9 @@
   // Returns the largest sent packet number that has been ACKed by peer.
   QuicPacketNumber GetLargestAckedPacket() const;
 
+  // Whether incoming_connection_ids_ contains connection_id.
+  bool HasIncomingConnectionId(QuicConnectionId connection_id);
+
   QuicFramer framer_;
 
   // Contents received in the current packet, especially used to identify
@@ -1136,7 +1144,7 @@
   const QuicClock* clock_;
   QuicRandom* random_generator_;
 
-  const QuicConnectionId connection_id_;
+  QuicConnectionId connection_id_;
   // Address on the last successfully processed packet received from the
   // direct peer.
   QuicSocketAddress self_address_;
@@ -1463,6 +1471,11 @@
   // saved and responded to.
   QuicDeque<QuicPathFrameBuffer> received_path_challenge_payloads_;
 
+  // Set of connection IDs that should be accepted as destination on
+  // received packets. This is conceptually a set but is implemented as a
+  // vector to improve performance since it is expected to be very small.
+  std::vector<QuicConnectionId> incoming_connection_ids_;
+
   // Latched value of quic_fix_termination_packets.
   const bool fix_termination_packets_;
 
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 5fddab6..7ef2869 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -329,6 +329,30 @@
   //            next packet does not use them incorrectly.
 }
 
+QuicConnectionId QuicDispatcher::MaybeReplaceConnectionId(
+    QuicConnectionId connection_id,
+    ParsedQuicVersion version) {
+  const uint8_t expected_connection_id_length =
+      framer_.GetExpectedConnectionIdLength();
+  if (connection_id.length() == expected_connection_id_length) {
+    return connection_id;
+  }
+  DCHECK(QuicUtils::VariableLengthConnectionIdAllowedForVersion(
+      version.transport_version));
+  auto it = connection_id_map_.find(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
+                  << " with " << new_connection_id;
+  return new_connection_id;
+}
+
 bool QuicDispatcher::OnUnauthenticatedPublicHeader(
     const QuicPacketHeader& header) {
   current_connection_id_ = header.destination_connection_id;
@@ -345,28 +369,10 @@
   if (header.destination_connection_id_included != CONNECTION_ID_PRESENT) {
     return false;
   }
-
-  // We currently do not support having the server change its connection ID
-  // length during the handshake. Until then, fast-fail connections.
-  // TODO(dschinazi): actually support changing connection IDs from the server.
-  if (header.destination_connection_id.length() !=
-      framer_.GetExpectedConnectionIdLength()) {
-    DCHECK(QuicUtils::VariableLengthConnectionIdAllowedForVersion(
-        header.version.transport_version));
-    QUIC_DLOG(INFO)
-        << "Packet with unexpected connection ID lengths: destination "
-        << header.destination_connection_id << " source "
-        << header.source_connection_id << " expected "
-        << static_cast<int>(framer_.GetExpectedConnectionIdLength());
-    ProcessUnauthenticatedHeaderFate(kFateTimeWait,
-                                     header.destination_connection_id,
-                                     header.form, header.version);
-    return false;
-  }
+  QuicConnectionId connection_id = header.destination_connection_id;
 
   // Packets with connection IDs for active connections are processed
   // immediately.
-  QuicConnectionId connection_id = header.destination_connection_id;
   auto it = session_map_.find(connection_id);
   if (it != session_map_.end()) {
     DCHECK(!buffered_packets_.HasBufferedPackets(connection_id));
@@ -998,9 +1004,15 @@
     if (packets.empty()) {
       return;
     }
+    QuicConnectionId original_connection_id = connection_id;
+    connection_id =
+        MaybeReplaceConnectionId(connection_id, packet_list.version);
     QuicSession* session =
         CreateQuicSession(connection_id, packets.front().peer_address,
                           packet_list.alpn, packet_list.version);
+    if (original_connection_id != 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)));
     DeliverPacketsToSession(packets, session);
@@ -1093,10 +1105,17 @@
     }
     return;
   }
+
+  QuicConnectionId original_connection_id = current_connection_id_;
+  current_connection_id_ =
+      MaybeReplaceConnectionId(current_connection_id_, framer_.version());
   // Creates a new session and process all buffered packets for this connection.
   QuicSession* session =
       CreateQuicSession(current_connection_id_, current_peer_address_,
                         current_alpn_, framer_.version());
+  if (original_connection_id != current_connection_id_) {
+    session->connection()->AddIncomingConnectionId(original_connection_id);
+  }
   QUIC_DLOG(INFO) << "Created new session for " << current_connection_id_;
   session_map_.insert(
       std::make_pair(current_connection_id_, QuicWrapUnique(session)));
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 63bba64..cdd1196 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -110,6 +110,14 @@
   // Deletes all sessions on the closed session list and clears the list.
   virtual void DeleteSessions();
 
+  using ConnectionIdMap = QuicUnorderedMap<QuicConnectionId,
+                                           QuicConnectionId,
+                                           QuicConnectionIdHash>;
+
+  const ConnectionIdMap& connection_id_map() const {
+    return connection_id_map_;
+  }
+
   // The largest packet number we expect to receive with a connection
   // ID for a connection that is not established yet.  The current design will
   // send a handshake and then up to 50 or so data packets, and then it may
@@ -405,6 +413,12 @@
       QuicTransportVersion first_version,
       PacketHeaderFormat form);
 
+  // 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);
+
   void set_new_sessions_allowed_per_event_loop(
       int16_t new_sessions_allowed_per_event_loop) {
     new_sessions_allowed_per_event_loop_ = new_sessions_allowed_per_event_loop;
@@ -422,6 +436,9 @@
 
   SessionMap session_map_;
 
+  // Map of connection IDs with bad lengths to their replacements.
+  ConnectionIdMap connection_id_map_;
+
   // Entity that manages connection_ids in time wait state.
   std::unique_ptr<QuicTimeWaitListManager> time_wait_list_manager_;
 
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 9e86875..3f4ef0e 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -116,14 +116,14 @@
  public:
   TestDispatcher(const QuicConfig* config,
                  const QuicCryptoServerConfig* crypto_config,
-                 QuicVersionManager* version_manager)
+                 QuicVersionManager* version_manager,
+                 QuicRandom* random)
       : QuicDispatcher(config,
                        crypto_config,
                        version_manager,
                        QuicMakeUnique<MockQuicConnectionHelper>(),
                        std::unique_ptr<QuicCryptoServerStream::Helper>(
-                           new QuicSimpleCryptoServerStreamHelper(
-                               QuicRandom::GetInstance())),
+                           new QuicSimpleCryptoServerStreamHelper(random)),
                        QuicMakeUnique<MockAlarmFactory>(),
                        kQuicDefaultConnectionIdLength) {}
 
@@ -208,9 +208,11 @@
                        KeyExchangeSource::Default(),
                        TlsServerHandshaker::CreateSslCtx()),
         server_address_(QuicIpAddress::Any4(), 5),
-        dispatcher_(new NiceMock<TestDispatcher>(&config_,
-                                                 &crypto_config_,
-                                                 &version_manager_)),
+        dispatcher_(
+            new NiceMock<TestDispatcher>(&config_,
+                                         &crypto_config_,
+                                         &version_manager_,
+                                         mock_helper_.GetRandomGenerator())),
         time_wait_list_manager_(nullptr),
         session1_(nullptr),
         session2_(nullptr),
@@ -636,39 +638,52 @@
   ProcessPacket(client_address, connection_id, false, SerializeCHLO());
 }
 
-// Makes sure nine-byte connection IDs end up in the time wait list.
-TEST_F(QuicDispatcherTest, BadConnectionIdLengthPacketToTimeWaitListManager) {
+// Makes sure nine-byte connection IDs are replaced by 8-byte ones.
+TEST_F(QuicDispatcherTest, BadConnectionIdLengthReplaced) {
   if (!QuicUtils::VariableLengthConnectionIdAllowedForVersion(
           CurrentSupportedVersions()[0].transport_version)) {
+    // When variable length connection IDs are not supported, the connection
+    // fails. See StrayPacketTruncatedConnectionId.
     return;
   }
-  CreateTimeWaitListManager();
-
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
-  // Dispatcher forwards all packets for this connection_id to the time wait
-  // list manager.
-  EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, QuicStringPiece("hq"), _))
-      .Times(0);
-  EXPECT_CALL(*time_wait_list_manager_,
-              ProcessPacket(_, _, TestConnectionIdNineBytesLong(2), _, _))
-      .Times(1);
-  EXPECT_CALL(*time_wait_list_manager_,
-              AddConnectionIdToTimeWait(_, _, _, _, _))
-      .Times(1);
-  ProcessPacket(client_address, TestConnectionIdNineBytesLong(2), true,
-                SerializeCHLO());
+  QuicConnectionId bad_connection_id = TestConnectionIdNineBytesLong(2);
+  QuicConnectionId fixed_connection_id =
+      QuicUtils::CreateRandomConnectionId(mock_helper_.GetRandomGenerator());
+
+  EXPECT_CALL(*dispatcher_,
+              CreateQuicSession(fixed_connection_id, client_address,
+                                QuicStringPiece("hq"), _))
+      .WillOnce(testing::Return(CreateSession(
+          dispatcher_.get(), config_, fixed_connection_id, client_address,
+          &mock_helper_, &mock_alarm_factory_, &crypto_config_,
+          QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
+              ProcessUdpPacket(_, _, _))
+      .WillOnce(WithArg<2>(
+          Invoke([this, bad_connection_id](const QuicEncryptedPacket& packet) {
+            ValidatePacket(bad_connection_id, packet);
+          })));
+  EXPECT_CALL(*dispatcher_,
+              ShouldCreateOrBufferPacketForConnection(bad_connection_id, _));
+  ProcessPacket(client_address, bad_connection_id, true, SerializeCHLO());
+  EXPECT_EQ(client_address, dispatcher_->current_peer_address());
+  EXPECT_EQ(server_address_, dispatcher_->current_self_address());
 }
 
-// Makes sure TestConnectionId(1) creates a new connection but
-// TestConnectionIdNineBytesLong(2) ends up in the time wait list.
+// Makes sure TestConnectionId(1) creates a new connection and
+// TestConnectionIdNineBytesLong(2) gets replaced.
 TEST_F(QuicDispatcherTest, MixGoodAndBadConnectionIdLengthPackets) {
   if (!QuicUtils::VariableLengthConnectionIdAllowedForVersion(
           CurrentSupportedVersions()[0].transport_version)) {
     return;
   }
-  CreateTimeWaitListManager();
+
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+  QuicConnectionId bad_connection_id = TestConnectionIdNineBytesLong(2);
+  QuicConnectionId fixed_connection_id =
+      QuicUtils::CreateRandomConnectionId(mock_helper_.GetRandomGenerator());
 
   EXPECT_CALL(*dispatcher_,
               CreateQuicSession(TestConnectionId(1), client_address,
@@ -688,18 +703,22 @@
   EXPECT_EQ(client_address, dispatcher_->current_peer_address());
   EXPECT_EQ(server_address_, dispatcher_->current_self_address());
 
-  EXPECT_CALL(*dispatcher_, CreateQuicSession(TestConnectionIdNineBytesLong(2),
-                                              _, QuicStringPiece("hq"), _))
-      .Times(0);
-  EXPECT_CALL(*time_wait_list_manager_,
-              ProcessPacket(_, _, TestConnectionIdNineBytesLong(2), _, _))
-      .Times(1);
-  EXPECT_CALL(*time_wait_list_manager_,
-              AddConnectionIdToTimeWait(_, _, _, _, _))
-      .Times(1);
-
-  ProcessPacket(client_address, TestConnectionIdNineBytesLong(2), true,
-                SerializeCHLO());
+  EXPECT_CALL(*dispatcher_,
+              CreateQuicSession(fixed_connection_id, client_address,
+                                QuicStringPiece("hq"), _))
+      .WillOnce(testing::Return(CreateSession(
+          dispatcher_.get(), config_, fixed_connection_id, client_address,
+          &mock_helper_, &mock_alarm_factory_, &crypto_config_,
+          QuicDispatcherPeer::GetCache(dispatcher_.get()), &session2_)));
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session2_->connection()),
+              ProcessUdpPacket(_, _, _))
+      .WillOnce(WithArg<2>(
+          Invoke([this, bad_connection_id](const QuicEncryptedPacket& packet) {
+            ValidatePacket(bad_connection_id, packet);
+          })));
+  EXPECT_CALL(*dispatcher_,
+              ShouldCreateOrBufferPacketForConnection(bad_connection_id, _));
+  ProcessPacket(client_address, bad_connection_id, true, SerializeCHLO());
 
   EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
@@ -1304,15 +1323,20 @@
 // Packets with truncated connection IDs should be dropped.
 TEST_F(QuicDispatcherTestStrayPacketConnectionId,
        StrayPacketTruncatedConnectionId) {
+  if (QuicUtils::VariableLengthConnectionIdAllowedForVersion(
+          CurrentSupportedVersions()[0].transport_version)) {
+    // When variable length connection IDs are supported, the server
+    // transparently replaces empty connection IDs with one it chooses.
+    // See BadConnectionIdLengthReplaced.
+    return;
+  }
   CreateTimeWaitListManager();
 
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   QuicConnectionId connection_id = TestConnectionId(1);
   EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, QuicStringPiece("hq"), _))
       .Times(0);
-  if (CurrentSupportedVersions()[0].transport_version > QUIC_VERSION_43 &&
-      !QuicUtils::VariableLengthConnectionIdAllowedForVersion(
-          CurrentSupportedVersions()[0].transport_version)) {
+  if (CurrentSupportedVersions()[0].transport_version > QUIC_VERSION_43) {
     // This IETF packet has invalid connection ID length.
     EXPECT_CALL(*time_wait_list_manager_, ProcessPacket(_, _, _, _, _))
         .Times(0);
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 9bd3b11..d9b481c 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -970,6 +970,10 @@
   connection_id_included_ = connection_id_included;
 }
 
+void QuicPacketCreator::SetConnectionId(QuicConnectionId connection_id) {
+  connection_id_ = connection_id;
+}
+
 void QuicPacketCreator::SetTransmissionType(TransmissionType type) {
   DCHECK(can_set_transmission_type_);
 
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 76e7726..150cb9c 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -215,6 +215,9 @@
   // Sets whether the connection ID should be sent over the wire.
   void SetConnectionIdIncluded(QuicConnectionIdIncluded connection_id_included);
 
+  // Update the connection ID used in outgoing packets.
+  void SetConnectionId(QuicConnectionId connection_id);
+
   // Sets the encryption level that will be applied to new packets.
   void set_encryption_level(EncryptionLevel level) {
     packet_.encryption_level = level;
diff --git a/quic/core/quic_packet_generator.cc b/quic/core/quic_packet_generator.cc
index fd18064..c2b3d48 100644
--- a/quic/core/quic_packet_generator.cc
+++ b/quic/core/quic_packet_generator.cc
@@ -535,4 +535,8 @@
   return packet_creator_.GetLargestMessagePayload();
 }
 
+void QuicPacketGenerator::SetConnectionId(QuicConnectionId connection_id) {
+  packet_creator_.SetConnectionId(connection_id);
+}
+
 }  // namespace quic
diff --git a/quic/core/quic_packet_generator.h b/quic/core/quic_packet_generator.h
index 32e95c3..4c780f5 100644
--- a/quic/core/quic_packet_generator.h
+++ b/quic/core/quic_packet_generator.h
@@ -229,6 +229,9 @@
   // Returns the largest payload that will fit into a single MESSAGE frame.
   QuicPacketLength GetLargestMessagePayload() const;
 
+  // Update the connection ID used in outgoing packets.
+  void SetConnectionId(QuicConnectionId connection_id);
+
   void set_debug_delegate(QuicPacketCreator::DebugDelegate* debug_delegate) {
     packet_creator_.set_debug_delegate(debug_delegate);
   }
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 6aaa67b..d03cc0e 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -8,6 +8,7 @@
 #include <cstdint>
 #include <string>
 
+#include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_aligned.h"
@@ -456,15 +457,37 @@
 
 // static
 QuicConnectionId QuicUtils::CreateRandomConnectionId() {
-  return CreateRandomConnectionId(QuicRandom::GetInstance());
+  return CreateRandomConnectionId(kQuicDefaultConnectionIdLength,
+                                  QuicRandom::GetInstance());
 }
 
 // static
 QuicConnectionId QuicUtils::CreateRandomConnectionId(QuicRandom* random) {
-  char connection_id_bytes[kQuicDefaultConnectionIdLength];
-  random->RandBytes(connection_id_bytes, QUIC_ARRAYSIZE(connection_id_bytes));
+  return CreateRandomConnectionId(kQuicDefaultConnectionIdLength, random);
+}
+// static
+QuicConnectionId QuicUtils::CreateRandomConnectionId(
+    uint8_t connection_id_length) {
+  return CreateRandomConnectionId(connection_id_length,
+                                  QuicRandom::GetInstance());
+}
+
+// static
+QuicConnectionId QuicUtils::CreateRandomConnectionId(
+    uint8_t connection_id_length,
+    QuicRandom* random) {
+  if (connection_id_length == 0) {
+    return EmptyQuicConnectionId();
+  }
+  if (connection_id_length > kQuicMaxConnectionIdLength) {
+    QUIC_BUG << "Tried to CreateRandomConnectionId of invalid length "
+             << static_cast<int>(connection_id_length);
+    connection_id_length = kQuicMaxConnectionIdLength;
+  }
+  char connection_id_bytes[kQuicMaxConnectionIdLength];
+  random->RandBytes(connection_id_bytes, connection_id_length);
   return QuicConnectionId(static_cast<char*>(connection_id_bytes),
-                          QUIC_ARRAYSIZE(connection_id_bytes));
+                          connection_id_length);
 }
 
 // static
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 9a052bd..709ea64 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -154,6 +154,15 @@
   // Generates a random 64bit connection ID using the provided QuicRandom.
   static QuicConnectionId CreateRandomConnectionId(QuicRandom* random);
 
+  // Generates a random connection ID of the given length.
+  static QuicConnectionId CreateRandomConnectionId(
+      uint8_t connection_id_length);
+
+  // Generates a random connection ID of the given length using the provided
+  // QuicRandom.
+  static QuicConnectionId CreateRandomConnectionId(uint8_t connection_id_length,
+                                                   QuicRandom* random);
+
   // Returns true if the QUIC version allows variable length connection IDs.
   static bool VariableLengthConnectionIdAllowedForVersion(
       QuicTransportVersion version);
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index 6ee6a2a..d0ce7e8 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -177,6 +177,28 @@
   EXPECT_NE(connection_id, EmptyQuicConnectionId());
   EXPECT_NE(connection_id, TestConnectionId());
   EXPECT_NE(connection_id, TestConnectionId(1));
+  EXPECT_NE(connection_id, TestConnectionIdNineBytesLong(1));
+  EXPECT_EQ(QuicUtils::CreateRandomConnectionId().length(),
+            kQuicDefaultConnectionIdLength);
+}
+
+TEST_F(QuicUtilsTest, RandomConnectionIdVariableLength) {
+  MockRandom random(1337);
+  const uint8_t connection_id_length = 9;
+  QuicConnectionId connection_id =
+      QuicUtils::CreateRandomConnectionId(connection_id_length, &random);
+  EXPECT_EQ(connection_id.length(), connection_id_length);
+  char connection_id_bytes[connection_id_length];
+  random.RandBytes(connection_id_bytes, QUIC_ARRAYSIZE(connection_id_bytes));
+  EXPECT_EQ(connection_id,
+            QuicConnectionId(static_cast<char*>(connection_id_bytes),
+                             QUIC_ARRAYSIZE(connection_id_bytes)));
+  EXPECT_NE(connection_id, EmptyQuicConnectionId());
+  EXPECT_NE(connection_id, TestConnectionId());
+  EXPECT_NE(connection_id, TestConnectionId(1));
+  EXPECT_NE(connection_id, TestConnectionIdNineBytesLong(1));
+  EXPECT_EQ(QuicUtils::CreateRandomConnectionId(connection_id_length).length(),
+            connection_id_length);
 }
 
 TEST_F(QuicUtilsTest, VariableLengthConnectionId) {