diff --git a/quiche/common/quiche_ip_address.cc b/quiche/common/quiche_ip_address.cc
index fd90deb..342597b 100644
--- a/quiche/common/quiche_ip_address.cc
+++ b/quiche/common/quiche_ip_address.cc
@@ -9,6 +9,7 @@
 #include <cstring>
 #include <string>
 
+#include "absl/strings/str_cat.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_ip_address_family.h"
@@ -223,4 +224,35 @@
   return address_.v6;
 }
 
+QuicheIpPrefix::QuicheIpPrefix() : prefix_length_(0) {}
+QuicheIpPrefix::QuicheIpPrefix(const QuicheIpAddress& address)
+    : address_(address) {
+  if (address_.IsIPv6()) {
+    prefix_length_ = QuicheIpAddress::kIPv6AddressSize * 8;
+  } else if (address_.IsIPv4()) {
+    prefix_length_ = QuicheIpAddress::kIPv4AddressSize * 8;
+  } else {
+    prefix_length_ = 0;
+  }
+}
+QuicheIpPrefix::QuicheIpPrefix(const QuicheIpAddress& address,
+                               uint8_t prefix_length)
+    : address_(address), prefix_length_(prefix_length) {
+  QUICHE_DCHECK(prefix_length <= QuicheIpPrefix(address).prefix_length())
+      << "prefix_length cannot be longer than the size of the IP address";
+}
+
+std::string QuicheIpPrefix::ToString() const {
+  return absl::StrCat(address_.ToString(), "/", prefix_length_);
+}
+
+bool operator==(const QuicheIpPrefix& lhs, const QuicheIpPrefix& rhs) {
+  return lhs.address_ == rhs.address_ &&
+         lhs.prefix_length_ == rhs.prefix_length_;
+}
+
+bool operator!=(const QuicheIpPrefix& lhs, const QuicheIpPrefix& rhs) {
+  return !(lhs == rhs);
+}
+
 }  // namespace quiche
diff --git a/quiche/common/quiche_ip_address.h b/quiche/common/quiche_ip_address.h
index ef7714c..9267922 100644
--- a/quiche/common/quiche_ip_address.h
+++ b/quiche/common/quiche_ip_address.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_COMMON_QUICHE_IP_ADDRESS_H_
 #define QUICHE_COMMON_QUICHE_IP_ADDRESS_H_
 
+#include <cstdint>
 #if defined(_WIN32)
 #include <winsock2.h>
 #include <ws2tcpip.h>
@@ -93,6 +94,37 @@
   return os;
 }
 
+// Represents an IP prefix, which is an IP address and a prefix length in bits.
+class QUICHE_EXPORT_PRIVATE QuicheIpPrefix {
+ public:
+  QuicheIpPrefix();
+  explicit QuicheIpPrefix(const QuicheIpAddress& address);
+  explicit QuicheIpPrefix(const QuicheIpAddress& address,
+                          uint8_t prefix_length);
+
+  QuicheIpAddress address() const { return address_; }
+  uint8_t prefix_length() const { return prefix_length_; }
+  // Human-readable string representation of the prefix suitable for logging.
+  std::string ToString() const;
+
+  QuicheIpPrefix(const QuicheIpPrefix& other) = default;
+  QuicheIpPrefix& operator=(const QuicheIpPrefix& other) = default;
+  QuicheIpPrefix& operator=(QuicheIpPrefix&& other) = default;
+  QUICHE_EXPORT_PRIVATE friend bool operator==(const QuicheIpPrefix& lhs,
+                                               const QuicheIpPrefix& rhs);
+  QUICHE_EXPORT_PRIVATE friend bool operator!=(const QuicheIpPrefix& lhs,
+                                               const QuicheIpPrefix& rhs);
+
+ private:
+  QuicheIpAddress address_;
+  uint8_t prefix_length_;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const QuicheIpPrefix prefix) {
+  os << prefix.ToString();
+  return os;
+}
+
 }  // namespace quiche
 
 #endif  // QUICHE_COMMON_QUICHE_IP_ADDRESS_H_
diff --git a/quiche/quic/core/http/capsule.cc b/quiche/quic/core/http/capsule.cc
index 3fba85e..8f653f1 100644
--- a/quiche/quic/core/http/capsule.cc
+++ b/quiche/quic/core/http/capsule.cc
@@ -14,7 +14,9 @@
 #include "quiche/quic/core/quic_data_writer.h"
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/quic/platform/api/quic_ip_address.h"
 #include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_ip_address.h"
 
 namespace quic {
 
@@ -26,6 +28,12 @@
       return "DATAGRAM_WITHOUT_CONTEXT";
     case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
       return "CLOSE_WEBTRANSPORT_SESSION";
+    case CapsuleType::ADDRESS_REQUEST:
+      return "ADDRESS_REQUEST";
+    case CapsuleType::ADDRESS_ASSIGN:
+      return "ADDRESS_ASSIGN";
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      return "ROUTE_ADVERTISEMENT";
   }
   return absl::StrCat("Unknown(", static_cast<uint64_t>(capsule_type), ")");
 }
@@ -41,7 +49,7 @@
       static_assert(
           std::is_standard_layout<LegacyDatagramCapsule>::value &&
               std::is_trivially_destructible<LegacyDatagramCapsule>::value,
-          "All capsule structs must have these properties");
+          "All inline capsule structs must have these properties");
       legacy_datagram_capsule_ = LegacyDatagramCapsule();
       break;
     case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
@@ -49,7 +57,7 @@
           std::is_standard_layout<DatagramWithoutContextCapsule>::value &&
               std::is_trivially_destructible<
                   DatagramWithoutContextCapsule>::value,
-          "All capsule structs must have these properties");
+          "All inline capsule structs must have these properties");
       datagram_without_context_capsule_ = DatagramWithoutContextCapsule();
       break;
     case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
@@ -57,18 +65,50 @@
           std::is_standard_layout<CloseWebTransportSessionCapsule>::value &&
               std::is_trivially_destructible<
                   CloseWebTransportSessionCapsule>::value,
-          "All capsule structs must have these properties");
+          "All inline capsule structs must have these properties");
       close_web_transport_session_capsule_ = CloseWebTransportSessionCapsule();
       break;
+    case CapsuleType::ADDRESS_REQUEST:
+      address_request_capsule_ = new AddressRequestCapsule();
+      break;
+    case CapsuleType::ADDRESS_ASSIGN:
+      address_assign_capsule_ = new AddressAssignCapsule();
+      break;
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      route_advertisement_capsule_ = new RouteAdvertisementCapsule();
+      break;
     default:
       unknown_capsule_data_ = absl::string_view();
       break;
   }
 }
 
+void Capsule::Free() {
+  switch (capsule_type_) {
+    // Inlined capsule types.
+    case CapsuleType::LEGACY_DATAGRAM:
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
+      // Do nothing, these are guaranteed to be trivially destructible.
+      break;
+    // Out-of-line capsule types.
+    case CapsuleType::ADDRESS_REQUEST:
+      delete address_request_capsule_;
+      break;
+    case CapsuleType::ADDRESS_ASSIGN:
+      delete address_assign_capsule_;
+      break;
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      delete route_advertisement_capsule_;
+      break;
+  }
+  capsule_type_ = static_cast<CapsuleType>(0x17);  // Reserved unknown value.
+  unknown_capsule_data_ = absl::string_view();
+}
+Capsule::~Capsule() { Free(); }
+
 // static
-Capsule Capsule::LegacyDatagram(
-    absl::string_view http_datagram_payload) {
+Capsule Capsule::LegacyDatagram(absl::string_view http_datagram_payload) {
   Capsule capsule(CapsuleType::LEGACY_DATAGRAM);
   capsule.legacy_datagram_capsule().http_datagram_payload =
       http_datagram_payload;
@@ -94,6 +134,21 @@
 }
 
 // static
+Capsule Capsule::AddressRequest() {
+  return Capsule(CapsuleType::ADDRESS_REQUEST);
+}
+
+// static
+Capsule Capsule::AddressAssign() {
+  return Capsule(CapsuleType::ADDRESS_ASSIGN);
+}
+
+// static
+Capsule Capsule::RouteAdvertisement() {
+  return Capsule(CapsuleType::ROUTE_ADVERTISEMENT);
+}
+
+// static
 Capsule Capsule::Unknown(uint64_t capsule_type,
                          absl::string_view unknown_capsule_data) {
   Capsule capsule(static_cast<CapsuleType>(capsule_type));
@@ -102,6 +157,7 @@
 }
 
 Capsule& Capsule::operator=(const Capsule& other) {
+  Free();
   capsule_type_ = other.capsule_type_;
   switch (capsule_type_) {
     case CapsuleType::LEGACY_DATAGRAM:
@@ -115,6 +171,18 @@
       close_web_transport_session_capsule_ =
           other.close_web_transport_session_capsule_;
       break;
+    case CapsuleType::ADDRESS_ASSIGN:
+      address_assign_capsule_ = new AddressAssignCapsule();
+      *address_assign_capsule_ = *other.address_assign_capsule_;
+      break;
+    case CapsuleType::ADDRESS_REQUEST:
+      address_request_capsule_ = new AddressRequestCapsule();
+      *address_request_capsule_ = *other.address_request_capsule_;
+      break;
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      route_advertisement_capsule_ = new RouteAdvertisementCapsule();
+      *route_advertisement_capsule_ = *other.route_advertisement_capsule_;
+      break;
     default:
       unknown_capsule_data_ = other.unknown_capsule_data_;
       break;
@@ -142,6 +210,15 @@
                  other.close_web_transport_session_capsule_.error_code &&
              close_web_transport_session_capsule_.error_message ==
                  other.close_web_transport_session_capsule_.error_message;
+    case CapsuleType::ADDRESS_REQUEST:
+      return address_request_capsule_->requested_addresses ==
+             other.address_request_capsule_->requested_addresses;
+    case CapsuleType::ADDRESS_ASSIGN:
+      return address_assign_capsule_->assigned_addresses ==
+             other.address_assign_capsule_->assigned_addresses;
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      return route_advertisement_capsule_->ip_address_ranges ==
+             other.route_advertisement_capsule_->ip_address_ranges;
     default:
       return unknown_capsule_data_ == other.unknown_capsule_data_;
   }
@@ -169,6 +246,34 @@
           ",error_message=\"",
           close_web_transport_session_capsule_.error_message, "\")");
       break;
+    case CapsuleType::ADDRESS_REQUEST: {
+      absl::StrAppend(&rv, "[");
+      for (auto requested_address :
+           address_request_capsule_->requested_addresses) {
+        absl::StrAppend(&rv, "(", requested_address.request_id, "-",
+                        requested_address.ip_prefix.ToString(), ")");
+      }
+      absl::StrAppend(&rv, "]");
+    } break;
+    case CapsuleType::ADDRESS_ASSIGN: {
+      absl::StrAppend(&rv, "[");
+      for (auto assigned_address :
+           address_assign_capsule_->assigned_addresses) {
+        absl::StrAppend(&rv, "(", assigned_address.request_id, "-",
+                        assigned_address.ip_prefix.ToString(), ")");
+      }
+      absl::StrAppend(&rv, "]");
+    } break;
+    case CapsuleType::ROUTE_ADVERTISEMENT: {
+      absl::StrAppend(&rv, "[");
+      for (auto ip_address_range :
+           route_advertisement_capsule_->ip_address_ranges) {
+        absl::StrAppend(&rv, "(", ip_address_range.start_ip_address.ToString(),
+                        "-", ip_address_range.end_ip_address.ToString(), "-",
+                        static_cast<int>(ip_address_range.ip_protocol), ")");
+      }
+      absl::StrAppend(&rv, "]");
+    } break;
     default:
       absl::StrAppend(&rv, "[", absl::BytesToHexString(unknown_capsule_data_),
                       "]");
@@ -205,6 +310,42 @@
           sizeof(WebTransportSessionError) +
           capsule.close_web_transport_session_capsule().error_message.size();
       break;
+    case CapsuleType::ADDRESS_REQUEST:
+      capsule_data_length = 0;
+      for (auto requested_address :
+           capsule.address_request_capsule().requested_addresses) {
+        capsule_data_length +=
+            QuicDataWriter::GetVarInt62Len(requested_address.request_id) + 1 +
+            (requested_address.ip_prefix.address().IsIPv4()
+                 ? QuicIpAddress::kIPv4AddressSize
+                 : QuicIpAddress::kIPv6AddressSize) +
+            1;
+      }
+      break;
+    case CapsuleType::ADDRESS_ASSIGN:
+      capsule_data_length = 0;
+      for (auto assigned_address :
+           capsule.address_assign_capsule().assigned_addresses) {
+        capsule_data_length +=
+            QuicDataWriter::GetVarInt62Len(assigned_address.request_id) + 1 +
+            (assigned_address.ip_prefix.address().IsIPv4()
+                 ? QuicIpAddress::kIPv4AddressSize
+                 : QuicIpAddress::kIPv6AddressSize) +
+            1;
+      }
+      break;
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      capsule_data_length = 0;
+      for (auto ip_address_range :
+           capsule.route_advertisement_capsule().ip_address_ranges) {
+        capsule_data_length += 1 +
+                               (ip_address_range.start_ip_address.IsIPv4()
+                                    ? QuicIpAddress::kIPv4AddressSize
+                                    : QuicIpAddress::kIPv6AddressSize) *
+                                   2 +
+                               1;
+      }
+      break;
     default:
       capsule_data_length = capsule.unknown_capsule_data().length();
       break;
@@ -254,6 +395,88 @@
         return {};
       }
       break;
+    case CapsuleType::ADDRESS_REQUEST:
+      for (auto requested_address :
+           capsule.address_request_capsule().requested_addresses) {
+        if (!writer.WriteVarInt62(requested_address.request_id)) {
+          QUIC_BUG(address request capsule id write fail)
+              << "Failed to write ADDRESS_REQUEST ID";
+          return {};
+        }
+        if (!writer.WriteUInt8(
+                requested_address.ip_prefix.address().IsIPv4() ? 4 : 6)) {
+          QUIC_BUG(address request capsule family write fail)
+              << "Failed to write ADDRESS_REQUEST family";
+          return {};
+        }
+        if (!writer.WriteStringPiece(
+                requested_address.ip_prefix.address().ToPackedString())) {
+          QUIC_BUG(address request capsule address write fail)
+              << "Failed to write ADDRESS_REQUEST address";
+          return {};
+        }
+        if (!writer.WriteUInt8(requested_address.ip_prefix.prefix_length())) {
+          QUIC_BUG(address request capsule prefix length write fail)
+              << "Failed to write ADDRESS_REQUEST prefix length";
+          return {};
+        }
+      }
+      break;
+    case CapsuleType::ADDRESS_ASSIGN:
+      for (auto assigned_address :
+           capsule.address_assign_capsule().assigned_addresses) {
+        if (!writer.WriteVarInt62(assigned_address.request_id)) {
+          QUIC_BUG(address request capsule id write fail)
+              << "Failed to write ADDRESS_ASSIGN ID";
+          return {};
+        }
+        if (!writer.WriteUInt8(
+                assigned_address.ip_prefix.address().IsIPv4() ? 4 : 6)) {
+          QUIC_BUG(address request capsule family write fail)
+              << "Failed to write ADDRESS_ASSIGN family";
+          return {};
+        }
+        if (!writer.WriteStringPiece(
+                assigned_address.ip_prefix.address().ToPackedString())) {
+          QUIC_BUG(address request capsule address write fail)
+              << "Failed to write ADDRESS_ASSIGN address";
+          return {};
+        }
+        if (!writer.WriteUInt8(assigned_address.ip_prefix.prefix_length())) {
+          QUIC_BUG(address request capsule prefix length write fail)
+              << "Failed to write ADDRESS_ASSIGN prefix length";
+          return {};
+        }
+      }
+      break;
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      for (auto ip_address_range :
+           capsule.route_advertisement_capsule().ip_address_ranges) {
+        if (!writer.WriteUInt8(
+                ip_address_range.start_ip_address.IsIPv4() ? 4 : 6)) {
+          QUIC_BUG(route advertisement capsule family write fail)
+              << "Failed to write ROUTE_ADVERTISEMENT family";
+          return {};
+        }
+        if (!writer.WriteStringPiece(
+                ip_address_range.start_ip_address.ToPackedString())) {
+          QUIC_BUG(route advertisement capsule start address write fail)
+              << "Failed to write ROUTE_ADVERTISEMENT start address";
+          return {};
+        }
+        if (!writer.WriteStringPiece(
+                ip_address_range.end_ip_address.ToPackedString())) {
+          QUIC_BUG(route advertisement capsule end address write fail)
+              << "Failed to write ROUTE_ADVERTISEMENT end address";
+          return {};
+        }
+        if (!writer.WriteUInt8(ip_address_range.ip_protocol)) {
+          QUIC_BUG(route advertisement capsule IP protocol write fail)
+              << "Failed to write ROUTE_ADVERTISEMENT IP protocol";
+          return {};
+        }
+      }
+      break;
     default:
       if (!writer.WriteStringPiece(capsule.unknown_capsule_data())) {
         QUIC_BUG(capsule data write fail) << "Failed to write CAPSULE data";
@@ -334,6 +557,154 @@
       capsule.close_web_transport_session_capsule().error_message =
           capsule_data_reader.ReadRemainingPayload();
       break;
+    case CapsuleType::ADDRESS_REQUEST: {
+      while (!capsule_data_reader.IsDoneReading()) {
+        PrefixWithId requested_address;
+        if (!capsule_data_reader.ReadVarInt62(&requested_address.request_id)) {
+          ReportParseFailure(
+              "Unable to parse capsule ADDRESS_REQUEST request ID");
+          return 0;
+        }
+        uint8_t address_family;
+        if (!capsule_data_reader.ReadUInt8(&address_family)) {
+          ReportParseFailure("Unable to parse capsule ADDRESS_REQUEST family");
+          return 0;
+        }
+        if (address_family != 4 && address_family != 6) {
+          ReportParseFailure("Bad ADDRESS_REQUEST family");
+          return 0;
+        }
+        absl::string_view ip_address_bytes;
+        if (!capsule_data_reader.ReadStringPiece(
+                &ip_address_bytes, address_family == 4
+                                       ? QuicIpAddress::kIPv4AddressSize
+                                       : QuicIpAddress::kIPv6AddressSize)) {
+          ReportParseFailure("Unable to read capsule ADDRESS_REQUEST address");
+          return 0;
+        }
+        quiche::QuicheIpAddress ip_address;
+        if (!ip_address.FromPackedString(ip_address_bytes.data(),
+                                         ip_address_bytes.size())) {
+          ReportParseFailure("Unable to parse capsule ADDRESS_REQUEST address");
+          return 0;
+        }
+        uint8_t ip_prefix_length;
+        if (!capsule_data_reader.ReadUInt8(&ip_prefix_length)) {
+          ReportParseFailure(
+              "Unable to parse capsule ADDRESS_REQUEST IP prefix length");
+          return 0;
+        }
+        if (ip_prefix_length >
+            quiche::QuicheIpPrefix(ip_address).prefix_length()) {
+          ReportParseFailure("Invalid IP prefix length");
+          return 0;
+        }
+        requested_address.ip_prefix =
+            quiche::QuicheIpPrefix(ip_address, ip_prefix_length);
+        capsule.address_request_capsule().requested_addresses.push_back(
+            requested_address);
+      }
+    } break;
+    case CapsuleType::ADDRESS_ASSIGN: {
+      while (!capsule_data_reader.IsDoneReading()) {
+        PrefixWithId assigned_address;
+        if (!capsule_data_reader.ReadVarInt62(&assigned_address.request_id)) {
+          ReportParseFailure(
+              "Unable to parse capsule ADDRESS_ASSIGN request ID");
+          return 0;
+        }
+        uint8_t address_family;
+        if (!capsule_data_reader.ReadUInt8(&address_family)) {
+          ReportParseFailure("Unable to parse capsule ADDRESS_ASSIGN family");
+          return 0;
+        }
+        if (address_family != 4 && address_family != 6) {
+          ReportParseFailure("Bad ADDRESS_ASSIGN family");
+          return 0;
+        }
+        absl::string_view ip_address_bytes;
+        if (!capsule_data_reader.ReadStringPiece(
+                &ip_address_bytes, address_family == 4
+                                       ? QuicIpAddress::kIPv4AddressSize
+                                       : QuicIpAddress::kIPv6AddressSize)) {
+          ReportParseFailure("Unable to read capsule ADDRESS_ASSIGN address");
+          return 0;
+        }
+        quiche::QuicheIpAddress ip_address;
+        if (!ip_address.FromPackedString(ip_address_bytes.data(),
+                                         ip_address_bytes.size())) {
+          ReportParseFailure("Unable to parse capsule ADDRESS_ASSIGN address");
+          return 0;
+        }
+        uint8_t ip_prefix_length;
+        if (!capsule_data_reader.ReadUInt8(&ip_prefix_length)) {
+          ReportParseFailure(
+              "Unable to parse capsule ADDRESS_ASSIGN IP prefix length");
+          return 0;
+        }
+        if (ip_prefix_length >
+            quiche::QuicheIpPrefix(ip_address).prefix_length()) {
+          ReportParseFailure("Invalid IP prefix length");
+          return 0;
+        }
+        assigned_address.ip_prefix =
+            quiche::QuicheIpPrefix(ip_address, ip_prefix_length);
+        capsule.address_assign_capsule().assigned_addresses.push_back(
+            assigned_address);
+      }
+    } break;
+    case CapsuleType::ROUTE_ADVERTISEMENT: {
+      while (!capsule_data_reader.IsDoneReading()) {
+        uint8_t address_family;
+        if (!capsule_data_reader.ReadUInt8(&address_family)) {
+          ReportParseFailure(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT family");
+          return 0;
+        }
+        if (address_family != 4 && address_family != 6) {
+          ReportParseFailure("Bad ROUTE_ADVERTISEMENT family");
+          return 0;
+        }
+        IpAddressRange ip_address_range;
+        absl::string_view start_ip_address_bytes;
+        if (!capsule_data_reader.ReadStringPiece(
+                &start_ip_address_bytes,
+                address_family == 4 ? QuicIpAddress::kIPv4AddressSize
+                                    : QuicIpAddress::kIPv6AddressSize)) {
+          ReportParseFailure(
+              "Unable to read capsule ROUTE_ADVERTISEMENT start address");
+          return 0;
+        }
+        if (!ip_address_range.start_ip_address.FromPackedString(
+                start_ip_address_bytes.data(), start_ip_address_bytes.size())) {
+          ReportParseFailure(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT start address");
+          return 0;
+        }
+        absl::string_view end_ip_address_bytes;
+        if (!capsule_data_reader.ReadStringPiece(
+                &end_ip_address_bytes, address_family == 4
+                                           ? QuicIpAddress::kIPv4AddressSize
+                                           : QuicIpAddress::kIPv6AddressSize)) {
+          ReportParseFailure(
+              "Unable to read capsule ROUTE_ADVERTISEMENT end address");
+          return 0;
+        }
+        if (!ip_address_range.end_ip_address.FromPackedString(
+                end_ip_address_bytes.data(), end_ip_address_bytes.size())) {
+          ReportParseFailure(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT end address");
+          return 0;
+        }
+        if (!capsule_data_reader.ReadUInt8(&ip_address_range.ip_protocol)) {
+          ReportParseFailure(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT IP protocol");
+          return 0;
+        }
+        capsule.route_advertisement_capsule().ip_address_ranges.push_back(
+            ip_address_range);
+      }
+    } break;
     default:
       capsule.unknown_capsule_data() =
           capsule_data_reader.ReadRemainingPayload();
@@ -363,4 +734,28 @@
   }
 }
 
+bool PrefixWithId::operator==(const PrefixWithId& other) const {
+  return request_id == other.request_id && ip_prefix == other.ip_prefix;
+}
+
+bool IpAddressRange::operator==(const IpAddressRange& other) const {
+  return start_ip_address == other.start_ip_address &&
+         end_ip_address == other.end_ip_address &&
+         ip_protocol == other.ip_protocol;
+}
+
+bool AddressAssignCapsule::operator==(const AddressAssignCapsule& other) const {
+  return assigned_addresses == other.assigned_addresses;
+}
+
+bool AddressRequestCapsule::operator==(
+    const AddressRequestCapsule& other) const {
+  return requested_addresses == other.requested_addresses;
+}
+
+bool RouteAdvertisementCapsule::operator==(
+    const RouteAdvertisementCapsule& other) const {
+  return ip_address_ranges == other.ip_address_ranges;
+}
+
 }  // namespace quic
diff --git a/quiche/quic/core/http/capsule.h b/quiche/quic/core/http/capsule.h
index 7b4cc46..3d83a55 100644
--- a/quiche/quic/core/http/capsule.h
+++ b/quiche/quic/core/http/capsule.h
@@ -7,6 +7,7 @@
 
 #include <cstdint>
 #include <string>
+#include <vector>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -15,15 +16,20 @@
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_ip_address.h"
 
 namespace quic {
 
 enum class CapsuleType : uint64_t {
-  // Casing in this enum matches the IETF specification.
+  // Casing in this enum matches the IETF specifications.
   LEGACY_DATAGRAM = 0xff37a0,  // draft-ietf-masque-h3-datagram-04.
   DATAGRAM_WITHOUT_CONTEXT =
       0xff37a5,  // draft-ietf-masque-h3-datagram-05 to -08.
   CLOSE_WEBTRANSPORT_SESSION = 0x2843,
+  // draft-ietf-masque-connect-ip-03.
+  ADDRESS_ASSIGN = 0x1ECA6A00,
+  ADDRESS_REQUEST = 0x1ECA6A01,
+  ROUTE_ADVERTISEMENT = 0x1ECA6A02,
 };
 
 QUIC_EXPORT_PRIVATE std::string CapsuleTypeToString(CapsuleType capsule_type);
@@ -40,6 +46,29 @@
   WebTransportSessionError error_code;
   absl::string_view error_message;
 };
+struct QUIC_EXPORT_PRIVATE PrefixWithId {
+  uint64_t request_id;
+  quiche::QuicheIpPrefix ip_prefix;
+  bool operator==(const PrefixWithId& other) const;
+};
+struct QUIC_EXPORT_PRIVATE IpAddressRange {
+  quiche::QuicheIpAddress start_ip_address;
+  quiche::QuicheIpAddress end_ip_address;
+  uint8_t ip_protocol;
+  bool operator==(const IpAddressRange& other) const;
+};
+struct QUIC_EXPORT_PRIVATE AddressAssignCapsule {
+  std::vector<PrefixWithId> assigned_addresses;
+  bool operator==(const AddressAssignCapsule& other) const;
+};
+struct QUIC_EXPORT_PRIVATE AddressRequestCapsule {
+  std::vector<PrefixWithId> requested_addresses;
+  bool operator==(const AddressRequestCapsule& other) const;
+};
+struct QUIC_EXPORT_PRIVATE RouteAdvertisementCapsule {
+  std::vector<IpAddressRange> ip_address_ranges;
+  bool operator==(const RouteAdvertisementCapsule& other) const;
+};
 
 // Capsule from draft-ietf-masque-h3-datagram.
 // IMPORTANT NOTE: Capsule does not own any of the absl::string_view memory it
@@ -55,11 +84,15 @@
   static Capsule CloseWebTransportSession(
       WebTransportSessionError error_code = 0,
       absl::string_view error_message = "");
+  static Capsule AddressRequest();
+  static Capsule AddressAssign();
+  static Capsule RouteAdvertisement();
   static Capsule Unknown(
       uint64_t capsule_type,
       absl::string_view unknown_capsule_data = absl::string_view());
 
   explicit Capsule(CapsuleType capsule_type);
+  ~Capsule();
   Capsule(const Capsule& other);
   Capsule& operator=(const Capsule& other);
   bool operator==(const Capsule& other) const;
@@ -96,27 +129,61 @@
     QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::CLOSE_WEBTRANSPORT_SESSION);
     return close_web_transport_session_capsule_;
   }
+  AddressRequestCapsule& address_request_capsule() {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_REQUEST);
+    return *address_request_capsule_;
+  }
+  const AddressRequestCapsule& address_request_capsule() const {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_REQUEST);
+    return *address_request_capsule_;
+  }
+  AddressAssignCapsule& address_assign_capsule() {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_ASSIGN);
+    return *address_assign_capsule_;
+  }
+  const AddressAssignCapsule& address_assign_capsule() const {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_ASSIGN);
+    return *address_assign_capsule_;
+  }
+  RouteAdvertisementCapsule& route_advertisement_capsule() {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ROUTE_ADVERTISEMENT);
+    return *route_advertisement_capsule_;
+  }
+  const RouteAdvertisementCapsule& route_advertisement_capsule() const {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ROUTE_ADVERTISEMENT);
+    return *route_advertisement_capsule_;
+  }
   absl::string_view& unknown_capsule_data() {
     QUICHE_DCHECK(capsule_type_ != CapsuleType::LEGACY_DATAGRAM &&
                   capsule_type_ != CapsuleType::DATAGRAM_WITHOUT_CONTEXT &&
-                  capsule_type_ != CapsuleType::CLOSE_WEBTRANSPORT_SESSION)
+                  capsule_type_ != CapsuleType::CLOSE_WEBTRANSPORT_SESSION &&
+                  capsule_type_ != CapsuleType::ADDRESS_REQUEST &&
+                  capsule_type_ != CapsuleType::ADDRESS_ASSIGN &&
+                  capsule_type_ != CapsuleType::ROUTE_ADVERTISEMENT)
         << capsule_type_;
     return unknown_capsule_data_;
   }
   const absl::string_view& unknown_capsule_data() const {
     QUICHE_DCHECK(capsule_type_ != CapsuleType::LEGACY_DATAGRAM &&
                   capsule_type_ != CapsuleType::DATAGRAM_WITHOUT_CONTEXT &&
-                  capsule_type_ != CapsuleType::CLOSE_WEBTRANSPORT_SESSION)
+                  capsule_type_ != CapsuleType::CLOSE_WEBTRANSPORT_SESSION &&
+                  capsule_type_ != CapsuleType::ADDRESS_REQUEST &&
+                  capsule_type_ != CapsuleType::ADDRESS_ASSIGN &&
+                  capsule_type_ != CapsuleType::ROUTE_ADVERTISEMENT)
         << capsule_type_;
     return unknown_capsule_data_;
   }
 
  private:
+  void Free();
   CapsuleType capsule_type_;
   union {
     LegacyDatagramCapsule legacy_datagram_capsule_;
     DatagramWithoutContextCapsule datagram_without_context_capsule_;
     CloseWebTransportSessionCapsule close_web_transport_session_capsule_;
+    AddressRequestCapsule* address_request_capsule_;
+    AddressAssignCapsule* address_assign_capsule_;
+    RouteAdvertisementCapsule* route_advertisement_capsule_;
     absl::string_view unknown_capsule_data_;
   };
 };
diff --git a/quiche/quic/core/http/capsule_test.cc b/quiche/quic/core/http/capsule_test.cc
index 1791bb6..a686095 100644
--- a/quiche/quic/core/http/capsule_test.cc
+++ b/quiche/quic/core/http/capsule_test.cc
@@ -13,6 +13,7 @@
 #include "absl/strings/string_view.h"
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/common/quiche_ip_address.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
 
 using ::testing::_;
@@ -116,6 +117,123 @@
   TestSerialization(expected_capsule, capsule_fragment);
 }
 
+TEST_F(CapsuleTest, AddressAssignCapsule) {
+  std::string capsule_fragment = absl::HexStringToBytes(
+      "9ECA6A00"  // ADDRESS_ASSIGN capsule type
+      "1A"        // capsule length = 26
+      // first assigned address
+      "00"        // request ID = 0
+      "04"        // IP version = 4
+      "C000022A"  // 192.0.2.42
+      "1F"        // prefix length = 31
+      // second assigned address
+      "01"                                // request ID = 1
+      "06"                                // IP version = 6
+      "20010db8123456780000000000000000"  // 2001:db8:1234:5678::
+      "40"                                // prefix length = 64
+  );
+  Capsule expected_capsule = Capsule::AddressAssign();
+  quiche::QuicheIpAddress ip_address1;
+  ip_address1.FromString("192.0.2.42");
+  PrefixWithId assigned_address1;
+  assigned_address1.request_id = 0;
+  assigned_address1.ip_prefix =
+      quiche::QuicheIpPrefix(ip_address1, /*prefix_length=*/31);
+  expected_capsule.address_assign_capsule().assigned_addresses.push_back(
+      assigned_address1);
+  quiche::QuicheIpAddress ip_address2;
+  ip_address2.FromString("2001:db8:1234:5678::");
+  PrefixWithId assigned_address2;
+  assigned_address2.request_id = 1;
+  assigned_address2.ip_prefix =
+      quiche::QuicheIpPrefix(ip_address2, /*prefix_length=*/64);
+  expected_capsule.address_assign_capsule().assigned_addresses.push_back(
+      assigned_address2);
+  {
+    EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
+    ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));
+  }
+  ValidateParserIsEmpty();
+  TestSerialization(expected_capsule, capsule_fragment);
+}
+
+TEST_F(CapsuleTest, AddressRequestCapsule) {
+  std::string capsule_fragment = absl::HexStringToBytes(
+      "9ECA6A01"  // ADDRESS_REQUEST capsule type
+      "1A"        // capsule length = 26
+      // first requested address
+      "00"        // request ID = 0
+      "04"        // IP version = 4
+      "C000022A"  // 192.0.2.42
+      "1F"        // prefix length = 31
+      // second requested address
+      "01"                                // request ID = 1
+      "06"                                // IP version = 6
+      "20010db8123456780000000000000000"  // 2001:db8:1234:5678::
+      "40"                                // prefix length = 64
+  );
+  Capsule expected_capsule = Capsule::AddressRequest();
+  quiche::QuicheIpAddress ip_address1;
+  ip_address1.FromString("192.0.2.42");
+  PrefixWithId requested_address1;
+  requested_address1.request_id = 0;
+  requested_address1.ip_prefix =
+      quiche::QuicheIpPrefix(ip_address1, /*prefix_length=*/31);
+  expected_capsule.address_request_capsule().requested_addresses.push_back(
+      requested_address1);
+  quiche::QuicheIpAddress ip_address2;
+  ip_address2.FromString("2001:db8:1234:5678::");
+  PrefixWithId requested_address2;
+  requested_address2.request_id = 1;
+  requested_address2.ip_prefix =
+      quiche::QuicheIpPrefix(ip_address2, /*prefix_length=*/64);
+  expected_capsule.address_request_capsule().requested_addresses.push_back(
+      requested_address2);
+  {
+    EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
+    ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));
+  }
+  ValidateParserIsEmpty();
+  TestSerialization(expected_capsule, capsule_fragment);
+}
+
+TEST_F(CapsuleTest, RouteAdvertisementCapsule) {
+  std::string capsule_fragment = absl::HexStringToBytes(
+      "9ECA6A02"  // ROUTE_ADVERTISEMENT capsule type
+      "2C"        // capsule length = 44
+      // first IP address range
+      "04"        // IP version = 4
+      "C0000218"  // 192.0.2.24
+      "C000022A"  // 192.0.2.42
+      "00"        // ip protocol = 0
+      // second IP address range
+      "06"                                // IP version = 6
+      "00000000000000000000000000000000"  // ::
+      "ffffffffffffffffffffffffffffffff"  // all ones IPv6 address
+      "01"                                // ip protocol = 1 (ICMP)
+  );
+  Capsule expected_capsule = Capsule::RouteAdvertisement();
+  IpAddressRange ip_address_range1;
+  ip_address_range1.start_ip_address.FromString("192.0.2.24");
+  ip_address_range1.end_ip_address.FromString("192.0.2.42");
+  ip_address_range1.ip_protocol = 0;
+  expected_capsule.route_advertisement_capsule().ip_address_ranges.push_back(
+      ip_address_range1);
+  IpAddressRange ip_address_range2;
+  ip_address_range2.start_ip_address.FromString("::");
+  ip_address_range2.end_ip_address.FromString(
+      "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
+  ip_address_range2.ip_protocol = 1;
+  expected_capsule.route_advertisement_capsule().ip_address_ranges.push_back(
+      ip_address_range2);
+  {
+    EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
+    ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));
+  }
+  ValidateParserIsEmpty();
+  TestSerialization(expected_capsule, capsule_fragment);
+}
+
 TEST_F(CapsuleTest, UnknownCapsule) {
   std::string capsule_fragment = absl::HexStringToBytes(
       "33"                // unknown capsule type of 0x33
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index c2c269a..7b580be 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -292,6 +292,10 @@
     }
   }
 
+  if (connect_ip_visitor_ != nullptr) {
+    connect_ip_visitor_->OnHeadersWritten();
+  }
+
   return bytes_written;
 }
 
@@ -1361,6 +1365,24 @@
           capsule.close_web_transport_session_capsule().error_code,
           capsule.close_web_transport_session_capsule().error_message);
     } break;
+    case CapsuleType::ADDRESS_ASSIGN:
+      if (connect_ip_visitor_ == nullptr) {
+        return true;
+      }
+      return connect_ip_visitor_->OnAddressAssignCapsule(
+          capsule.address_assign_capsule());
+    case CapsuleType::ADDRESS_REQUEST:
+      if (connect_ip_visitor_ == nullptr) {
+        return true;
+      }
+      return connect_ip_visitor_->OnAddressRequestCapsule(
+          capsule.address_request_capsule());
+    case CapsuleType::ROUTE_ADVERTISEMENT:
+      if (connect_ip_visitor_ == nullptr) {
+        return true;
+      }
+      return connect_ip_visitor_->OnRouteAdvertisementCapsule(
+          capsule.route_advertisement_capsule());
   }
   return true;
 }
@@ -1441,6 +1463,43 @@
   datagram_visitor_ = visitor;
 }
 
+void QuicSpdyStream::RegisterConnectIpVisitor(ConnectIpVisitor* visitor) {
+  if (visitor == nullptr) {
+    QUIC_BUG(null connect - ip visitor)
+        << ENDPOINT << "Null connect-ip visitor for stream ID " << id();
+    return;
+  }
+  QUIC_DLOG(INFO) << ENDPOINT
+                  << "Registering CONNECT-IP visitor with stream ID " << id();
+
+  if (connect_ip_visitor_ != nullptr) {
+    QUIC_BUG(connect - ip double registration)
+        << ENDPOINT << "Attempted to doubly register CONNECT-IP with stream ID "
+        << id();
+    return;
+  }
+  connect_ip_visitor_ = visitor;
+}
+
+void QuicSpdyStream::UnregisterConnectIpVisitor() {
+  if (connect_ip_visitor_ == nullptr) {
+    QUIC_BUG(connect - ip visitor empty during unregistration)
+        << ENDPOINT << "Cannot unregister CONNECT-IP visitor for stream ID "
+        << id();
+    return;
+  }
+  QUIC_DLOG(INFO) << ENDPOINT
+                  << "Unregistering CONNECT-IP visitor for stream ID " << id();
+  connect_ip_visitor_ = nullptr;
+}
+
+void QuicSpdyStream::ReplaceConnectIpVisitor(ConnectIpVisitor* visitor) {
+  QUIC_BUG_IF(connect - ip unknown move, connect_ip_visitor_ == nullptr)
+      << "Attempted to move missing CONNECT-IP visitor on HTTP/3 stream ID "
+      << id();
+  connect_ip_visitor_ = visitor;
+}
+
 void QuicSpdyStream::SetMaxDatagramTimeInQueue(
     QuicTime::Delta max_time_in_queue) {
   spdy_session_->SetMaxDatagramTimeInQueueForStreamId(id(), max_time_in_queue);
diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h
index 62b0eea..b5b6e9e 100644
--- a/quiche/quic/core/http/quic_spdy_stream.h
+++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -279,6 +279,31 @@
   // Mainly meant to be used by the visitors' move operators.
   void ReplaceHttp3DatagramVisitor(Http3DatagramVisitor* visitor);
 
+  class QUIC_EXPORT_PRIVATE ConnectIpVisitor {
+   public:
+    virtual ~ConnectIpVisitor() {}
+
+    virtual bool OnAddressAssignCapsule(
+        const AddressAssignCapsule& capsule) = 0;
+    virtual bool OnAddressRequestCapsule(
+        const AddressRequestCapsule& capsule) = 0;
+    virtual bool OnRouteAdvertisementCapsule(
+        const RouteAdvertisementCapsule& capsule) = 0;
+    virtual void OnHeadersWritten() = 0;
+  };
+
+  // Registers |visitor| to receive CONNECT-IP capsules. |visitor| must be
+  // valid until a corresponding call to UnregisterConnectIpVisitor.
+  void RegisterConnectIpVisitor(ConnectIpVisitor* visitor);
+
+  // Unregisters a CONNECT-IP visitor. Must only be called after a call to
+  // RegisterConnectIpVisitor.
+  void UnregisterConnectIpVisitor();
+
+  // Replaces the current CONNECT-IP visitor with a different visitor.
+  // Mainly meant to be used by the visitors' move operators.
+  void ReplaceConnectIpVisitor(ConnectIpVisitor* visitor);
+
   // Sets max datagram time in queue.
   void SetMaxDatagramTimeInQueue(QuicTime::Delta max_time_in_queue);
 
@@ -449,6 +474,8 @@
 
   // HTTP/3 Datagram support.
   Http3DatagramVisitor* datagram_visitor_ = nullptr;
+  // CONNECT-IP support.
+  ConnectIpVisitor* connect_ip_visitor_ = nullptr;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/core/http/quic_spdy_stream_test.cc b/quiche/quic/core/http/quic_spdy_stream_test.cc
index 4695f25..c6cd92c 100644
--- a/quiche/quic/core/http/quic_spdy_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_stream_test.cc
@@ -15,6 +15,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/crypto/null_encrypter.h"
+#include "quiche/quic/core/http/capsule.h"
 #include "quiche/quic/core/http/http_encoder.h"
 #include "quiche/quic/core/http/quic_spdy_session.h"
 #include "quiche/quic/core/http/spdy_utils.h"
@@ -36,6 +37,7 @@
 #include "quiche/quic/test_tools/quic_spdy_stream_peer.h"
 #include "quiche/quic/test_tools/quic_stream_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/common/quiche_ip_address.h"
 #include "quiche/common/quiche_mem_slice_storage.h"
 #include "quiche/common/simple_buffer_allocator.h"
 
@@ -3161,6 +3163,64 @@
   EXPECT_GT(stream_->GetMaxDatagramSize(), 512u);
 }
 
+TEST_P(QuicSpdyStreamTest, Capsules) {
+  if (!UsesHttp3()) {
+    return;
+  }
+  Initialize(kShouldProcessData);
+  session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft09);
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft09);
+  SavingHttp3DatagramVisitor h3_datagram_visitor;
+  stream_->RegisterHttp3DatagramVisitor(&h3_datagram_visitor);
+  SavingConnectIpVisitor connect_ip_visitor;
+  stream_->RegisterConnectIpVisitor(&connect_ip_visitor);
+  headers_[":method"] = "CONNECT";
+  headers_[":protocol"] = "fake-capsule-protocol";
+  ProcessHeaders(/*fin=*/false, headers_);
+  // Datagram capsule.
+  std::string http_datagram_payload = {1, 2, 3, 4, 5, 6};
+  stream_->OnCapsule(Capsule::DatagramWithoutContext(http_datagram_payload));
+  EXPECT_THAT(h3_datagram_visitor.received_h3_datagrams(),
+              ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
+                  stream_->id(), http_datagram_payload}));
+  // Address assign capsule.
+  PrefixWithId ip_prefix_with_id;
+  ip_prefix_with_id.request_id = 1;
+  quiche::QuicheIpAddress ip_address;
+  ip_address.FromString("::");
+  ip_prefix_with_id.ip_prefix =
+      quiche::QuicheIpPrefix(ip_address, /*prefix_length=*/96);
+  Capsule address_assign_capsule = Capsule::AddressAssign();
+  address_assign_capsule.address_assign_capsule().assigned_addresses.push_back(
+      ip_prefix_with_id);
+  stream_->OnCapsule(address_assign_capsule);
+  EXPECT_THAT(connect_ip_visitor.received_address_assign_capsules(),
+              ElementsAre(address_assign_capsule.address_assign_capsule()));
+  // Address request capsule.
+  Capsule address_request_capsule = Capsule::AddressRequest();
+  address_request_capsule.address_request_capsule()
+      .requested_addresses.push_back(ip_prefix_with_id);
+  stream_->OnCapsule(address_request_capsule);
+  EXPECT_THAT(connect_ip_visitor.received_address_request_capsules(),
+              ElementsAre(address_request_capsule.address_request_capsule()));
+  // Route advertisement capsule.
+  Capsule route_advertisement_capsule = Capsule::RouteAdvertisement();
+  IpAddressRange ip_address_range;
+  ip_address_range.start_ip_address.FromString("192.0.2.24");
+  ip_address_range.end_ip_address.FromString("192.0.2.42");
+  ip_address_range.ip_protocol = 0;
+  route_advertisement_capsule.route_advertisement_capsule()
+      .ip_address_ranges.push_back(ip_address_range);
+  stream_->OnCapsule(route_advertisement_capsule);
+  EXPECT_THAT(
+      connect_ip_visitor.received_route_advertisement_capsules(),
+      ElementsAre(route_advertisement_capsule.route_advertisement_capsule()));
+  // Cleanup.
+  stream_->UnregisterHttp3DatagramVisitor();
+  stream_->UnregisterConnectIpVisitor();
+}
+
 TEST_P(QuicSpdyStreamTest,
        QUIC_TEST_DISABLED_IN_CHROME(HeadersAccumulatorNullptr)) {
   if (!UsesHttp3()) {
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index 7981335..9808498 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -2100,6 +2100,46 @@
   std::vector<SavedHttp3Datagram> received_h3_datagrams_;
 };
 
+// Implementation of ConnectIpVisitor which saves all received capsules.
+class SavingConnectIpVisitor : public QuicSpdyStream::ConnectIpVisitor {
+ public:
+  const std::vector<AddressAssignCapsule>& received_address_assign_capsules()
+      const {
+    return received_address_assign_capsules_;
+  }
+  const std::vector<AddressRequestCapsule>& received_address_request_capsules()
+      const {
+    return received_address_request_capsules_;
+  }
+  const std::vector<RouteAdvertisementCapsule>&
+  received_route_advertisement_capsules() const {
+    return received_route_advertisement_capsules_;
+  }
+  bool headers_written() const { return headers_written_; }
+
+  // From QuicSpdyStream::ConnectIpVisitor.
+  bool OnAddressAssignCapsule(const AddressAssignCapsule& capsule) override {
+    received_address_assign_capsules_.push_back(capsule);
+    return true;
+  }
+  bool OnAddressRequestCapsule(const AddressRequestCapsule& capsule) override {
+    received_address_request_capsules_.push_back(capsule);
+    return true;
+  }
+  bool OnRouteAdvertisementCapsule(
+      const RouteAdvertisementCapsule& capsule) override {
+    received_route_advertisement_capsules_.push_back(capsule);
+    return true;
+  }
+  void OnHeadersWritten() override { headers_written_ = true; }
+
+ private:
+  std::vector<AddressAssignCapsule> received_address_assign_capsules_;
+  std::vector<AddressRequestCapsule> received_address_request_capsules_;
+  std::vector<RouteAdvertisementCapsule> received_route_advertisement_capsules_;
+  bool headers_written_ = false;
+};
+
 inline std::string EscapeTestParamName(absl::string_view name) {
   std::string result(name);
   // Escape all characters that are not allowed by gtest ([a-zA-Z0-9_]).