diff --git a/quic/core/quic_connection_id.cc b/quic/core/quic_connection_id.cc
index 4022283..e1487e3 100644
--- a/quic/core/quic_connection_id.cc
+++ b/quic/core/quic_connection_id.cc
@@ -19,27 +19,70 @@
 
 namespace quic {
 
-QuicConnectionId::QuicConnectionId() : length_(0) {}
+QuicConnectionId::QuicConnectionId() : QuicConnectionId(nullptr, 0) {}
 
 QuicConnectionId::QuicConnectionId(const char* data, uint8_t length) {
+  static_assert(
+      kQuicMaxConnectionIdLength <= std::numeric_limits<uint8_t>::max(),
+      "kQuicMaxConnectionIdLength too high");
   if (length > kQuicMaxConnectionIdLength) {
     QUIC_BUG << "Attempted to create connection ID of length " << length;
     length = kQuicMaxConnectionIdLength;
   }
   length_ = length;
-  if (length_ > 0) {
+  if (length_ == 0) {
+    return;
+  }
+  if (!GetQuicRestartFlag(quic_use_allocated_connection_ids)) {
     memcpy(data_, data, length_);
+    return;
+  }
+  if (length_ <= sizeof(data_short_)) {
+    memcpy(data_short_, data, length_);
+    return;
+  }
+  data_long_ = reinterpret_cast<char*>(malloc(length_));
+  CHECK_NE(nullptr, data_long_);
+  memcpy(data_long_, data, length_);
+}
+
+QuicConnectionId::~QuicConnectionId() {
+  if (!GetQuicRestartFlag(quic_use_allocated_connection_ids)) {
+    return;
+  }
+  if (length_ > sizeof(data_short_)) {
+    free(data_long_);
+    data_long_ = nullptr;
   }
 }
 
-QuicConnectionId::~QuicConnectionId() {}
+QuicConnectionId::QuicConnectionId(const QuicConnectionId& other)
+    : QuicConnectionId(other.data(), other.length()) {}
+
+QuicConnectionId& QuicConnectionId::operator=(const QuicConnectionId& other) {
+  set_length(other.length());
+  memcpy(mutable_data(), other.data(), length_);
+  return *this;
+}
 
 const char* QuicConnectionId::data() const {
-  return data_;
+  if (!GetQuicRestartFlag(quic_use_allocated_connection_ids)) {
+    return data_;
+  }
+  if (length_ <= sizeof(data_short_)) {
+    return data_short_;
+  }
+  return data_long_;
 }
 
 char* QuicConnectionId::mutable_data() {
-  return data_;
+  if (!GetQuicRestartFlag(quic_use_allocated_connection_ids)) {
+    return data_;
+  }
+  if (length_ <= sizeof(data_short_)) {
+    return data_short_;
+  }
+  return data_long_;
 }
 
 uint8_t QuicConnectionId::length() const {
@@ -47,6 +90,30 @@
 }
 
 void QuicConnectionId::set_length(uint8_t length) {
+  if (GetQuicRestartFlag(quic_use_allocated_connection_ids)) {
+    char temporary_data[sizeof(data_short_)];
+    if (length > sizeof(data_short_)) {
+      if (length_ <= sizeof(data_short_)) {
+        // Copy data from data_short_ to data_long_.
+        memcpy(temporary_data, data_short_, length_);
+        data_long_ = reinterpret_cast<char*>(malloc(length));
+        CHECK_NE(nullptr, data_long_);
+        memcpy(data_long_, temporary_data, length_);
+      } else {
+        // Resize data_long_.
+        char* realloc_result =
+            reinterpret_cast<char*>(realloc(data_long_, length));
+        CHECK_NE(nullptr, realloc_result);
+        data_long_ = realloc_result;
+      }
+    } else if (length_ > sizeof(data_short_)) {
+      // Copy data from data_long_ to data_short_.
+      memcpy(temporary_data, data_long_, length);
+      free(data_long_);
+      data_long_ = nullptr;
+      memcpy(data_short_, temporary_data, length);
+    }
+  }
   length_ = length;
 }
 
@@ -56,8 +123,9 @@
 
 size_t QuicConnectionId::Hash() const {
   uint64_t data_bytes[3] = {0, 0, 0};
-  static_assert(sizeof(data_bytes) >= sizeof(data_), "sizeof(data_) changed");
-  memcpy(data_bytes, data_, length_);
+  static_assert(sizeof(data_bytes) >= kQuicMaxConnectionIdLength,
+                "kQuicMaxConnectionIdLength changed");
+  memcpy(data_bytes, data(), length_);
   // This Hash function is designed to return the same value as the host byte
   // order representation when the connection ID length is 64 bits.
   return QuicEndian::NetToHost64(kQuicDefaultConnectionIdLength ^ length_ ^
@@ -68,7 +136,7 @@
   if (IsEmpty()) {
     return std::string("0");
   }
-  return QuicTextUtils::HexEncode(data_, length_);
+  return QuicTextUtils::HexEncode(data(), length_);
 }
 
 std::ostream& operator<<(std::ostream& os, const QuicConnectionId& v) {
@@ -77,7 +145,7 @@
 }
 
 bool QuicConnectionId::operator==(const QuicConnectionId& v) const {
-  return length_ == v.length_ && memcmp(data_, v.data_, length_) == 0;
+  return length_ == v.length_ && memcmp(data(), v.data(), length_) == 0;
 }
 
 bool QuicConnectionId::operator!=(const QuicConnectionId& v) const {
@@ -91,7 +159,7 @@
   if (length_ > v.length_) {
     return false;
   }
-  return memcmp(data_, v.data_, length_) < 0;
+  return memcmp(data(), v.data(), length_) < 0;
 }
 
 QuicConnectionId EmptyQuicConnectionId() {
diff --git a/quic/core/quic_connection_id.h b/quic/core/quic_connection_id.h
index d51366f..4b76f31 100644
--- a/quic/core/quic_connection_id.h
+++ b/quic/core/quic_connection_id.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_CORE_QUIC_CONNECTION_ID_H_
 
 #include <string>
+#include <vector>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
@@ -43,12 +44,21 @@
   // Creates a connection ID from network order bytes.
   QuicConnectionId(const char* data, uint8_t length);
 
+  // Creates a connection ID from another connection ID.
+  QuicConnectionId(const QuicConnectionId& other);
+
+  // Assignment operator.
+  QuicConnectionId& operator=(const QuicConnectionId& other);
+
   ~QuicConnectionId();
 
   // Returns the length of the connection ID, in bytes.
   uint8_t length() const;
 
   // Sets the length of the connection ID, in bytes.
+  // WARNING: Calling set_length() can change the in-memory location of the
+  // connection ID. Callers must therefore ensure they call data() or
+  // mutable_data() after they call set_length().
   void set_length(uint8_t length);
 
   // Returns a pointer to the connection ID bytes, in network byte order.
@@ -79,10 +89,21 @@
   bool operator<(const QuicConnectionId& v) const;
 
  private:
-  // The connection ID is represented in network byte order
-  // in the first |length_| bytes of |data_|.
-  char data_[kQuicMaxConnectionIdLength];
-  uint8_t length_;
+  uint8_t length_;  // length of the connection ID, in bytes.
+  // The connection ID is represented in network byte order.
+  union {
+    // When quic_use_allocated_connection_ids is false, the connection ID is
+    // stored in the first |length_| bytes of |data_|.
+    char data_[kQuicMaxConnectionIdLength];
+    // When quic_use_allocated_connection_ids is true, if the connection ID
+    // fits in |data_short_|, it is stored in the first |length_| bytes of
+    // |data_short_|. Otherwise it is stored in |data_long_| which is
+    // guaranteed to have a size equal to |length_|. A value of 11 was chosen
+    // because our commonly used connection ID length is 8 and with the length,
+    // the class is padded to 12 bytes anyway.
+    char data_short_[11];
+    char* data_long_;
+  };
 };
 
 // Creates a connection ID of length zero, unless the restart flag
diff --git a/quic/core/quic_connection_id_test.cc b/quic/core/quic_connection_id_test.cc
index bbe04f9..1d290fc 100644
--- a/quic/core/quic_connection_id_test.cc
+++ b/quic/core/quic_connection_id_test.cc
@@ -91,6 +91,53 @@
   EXPECT_NE(connection_id64_2.Hash(), connection_id64_3.Hash());
 }
 
+TEST_F(QuicConnectionIdTest, AssignAndCopy) {
+  QuicConnectionId connection_id = test::TestConnectionId(1);
+  QuicConnectionId connection_id2 = test::TestConnectionId(2);
+  connection_id = connection_id2;
+  EXPECT_EQ(connection_id, test::TestConnectionId(2));
+  EXPECT_NE(connection_id, test::TestConnectionId(1));
+  connection_id = QuicConnectionId(test::TestConnectionId(1));
+  EXPECT_EQ(connection_id, test::TestConnectionId(1));
+  EXPECT_NE(connection_id, test::TestConnectionId(2));
+}
+
+TEST_F(QuicConnectionIdTest, ChangeLength) {
+  QuicConnectionId connection_id64_1 = test::TestConnectionId(1);
+  QuicConnectionId connection_id64_2 = test::TestConnectionId(2);
+  QuicConnectionId connection_id136_2 = test::TestConnectionId(2);
+  connection_id136_2.set_length(17);
+  memset(connection_id136_2.mutable_data() + 8, 0, 9);
+  char connection_id136_2_bytes[17] = {0, 0, 0, 0, 0, 0, 0, 2, 0,
+                                       0, 0, 0, 0, 0, 0, 0, 0};
+  QuicConnectionId connection_id136_2b(connection_id136_2_bytes,
+                                       sizeof(connection_id136_2_bytes));
+  EXPECT_EQ(connection_id136_2, connection_id136_2b);
+  QuicConnectionId connection_id = connection_id64_1;
+  connection_id.set_length(17);
+  EXPECT_NE(connection_id64_1, connection_id);
+  // Check resizing big to small.
+  connection_id.set_length(8);
+  EXPECT_EQ(connection_id64_1, connection_id);
+  // Check resizing small to big.
+  connection_id.set_length(17);
+  memset(connection_id.mutable_data(), 0, connection_id.length());
+  memcpy(connection_id.mutable_data(), connection_id64_2.data(),
+         connection_id64_2.length());
+  EXPECT_EQ(connection_id136_2, connection_id);
+  EXPECT_EQ(connection_id136_2b, connection_id);
+  QuicConnectionId connection_id120(connection_id136_2_bytes, 15);
+  connection_id.set_length(15);
+  EXPECT_EQ(connection_id120, connection_id);
+  // Check resizing big to big.
+  QuicConnectionId connection_id2 = connection_id120;
+  connection_id2.set_length(17);
+  connection_id2.mutable_data()[15] = 0;
+  connection_id2.mutable_data()[16] = 0;
+  EXPECT_EQ(connection_id136_2, connection_id2);
+  EXPECT_EQ(connection_id136_2b, connection_id2);
+}
+
 }  // namespace
 
 }  // namespace quic
diff --git a/quic/core/quic_data_reader.cc b/quic/core/quic_data_reader.cc
index ef09483..951a144 100644
--- a/quic/core/quic_data_reader.cc
+++ b/quic/core/quic_data_reader.cc
@@ -146,10 +146,21 @@
     return true;
   }
 
-  const bool ok = ReadBytes(connection_id->mutable_data(), length);
-  if (ok) {
-    connection_id->set_length(length);
+  if (!GetQuicRestartFlag(quic_use_allocated_connection_ids)) {
+    const bool ok = ReadBytes(connection_id->mutable_data(), length);
+    if (ok) {
+      connection_id->set_length(length);
+    }
+    return ok;
   }
+
+  if (BytesRemaining() < length) {
+    return false;
+  }
+
+  connection_id->set_length(length);
+  const bool ok = ReadBytes(connection_id->mutable_data(), length);
+  DCHECK(ok);
   return ok;
 }
 
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index d76b6be..11f8ea1 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -441,6 +441,7 @@
                      true);
   SetQuicRestartFlag(quic_do_not_override_connection_id, true);
   SetQuicRestartFlag(quic_no_framer_object_in_dispatcher, true);
+  SetQuicRestartFlag(quic_use_allocated_connection_ids, true);
 }
 
 void QuicEnableVersion(ParsedQuicVersion parsed_version) {