diff --git a/build/source_list.bzl b/build/source_list.bzl
index 91be1a0..556b344 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -20,6 +20,7 @@
     "balsa/noop_balsa_visitor.h",
     "balsa/simple_buffer.h",
     "balsa/standard_header_map.h",
+    "common/capsule.h",
     "common/masque/connect_udp_datagram_payload.h",
     "common/platform/api/quiche_bug_tracker.h",
     "common/platform/api/quiche_client_stats.h",
@@ -219,7 +220,6 @@
     "quic/core/frames/quic_streams_blocked_frame.h",
     "quic/core/frames/quic_window_update_frame.h",
     "quic/core/handshaker_delegate_interface.h",
-    "quic/core/http/capsule.h",
     "quic/core/http/http_constants.h",
     "quic/core/http/http_decoder.h",
     "quic/core/http/http_encoder.h",
@@ -409,6 +409,7 @@
     "balsa/http_validation_policy.cc",
     "balsa/simple_buffer.cc",
     "balsa/standard_header_map.cc",
+    "common/capsule.cc",
     "common/masque/connect_udp_datagram_payload.cc",
     "common/platform/api/quiche_hostname_utils.cc",
     "common/platform/api/quiche_mutex.cc",
@@ -564,7 +565,6 @@
     "quic/core/frames/quic_stream_frame.cc",
     "quic/core/frames/quic_streams_blocked_frame.cc",
     "quic/core/frames/quic_window_update_frame.cc",
-    "quic/core/http/capsule.cc",
     "quic/core/http/http_constants.cc",
     "quic/core/http/http_decoder.cc",
     "quic/core/http/http_encoder.cc",
@@ -1025,6 +1025,7 @@
     "balsa/header_properties_test.cc",
     "balsa/simple_buffer_test.cc",
     "binary_http/binary_http_message_test.cc",
+    "common/capsule_test.cc",
     "common/masque/connect_udp_datagram_payload_test.cc",
     "common/platform/api/quiche_file_utils_test.cc",
     "common/platform/api/quiche_hostname_utils_test.cc",
@@ -1154,7 +1155,6 @@
     "quic/core/crypto/web_transport_fingerprint_proof_verifier_test.cc",
     "quic/core/deterministic_connection_id_generator_test.cc",
     "quic/core/frames/quic_frames_test.cc",
-    "quic/core/http/capsule_test.cc",
     "quic/core/http/http_decoder_test.cc",
     "quic/core/http/http_encoder_test.cc",
     "quic/core/http/http_frames_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 965802a..22a646d 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -20,6 +20,7 @@
     "src/quiche/balsa/noop_balsa_visitor.h",
     "src/quiche/balsa/simple_buffer.h",
     "src/quiche/balsa/standard_header_map.h",
+    "src/quiche/common/capsule.h",
     "src/quiche/common/masque/connect_udp_datagram_payload.h",
     "src/quiche/common/platform/api/quiche_bug_tracker.h",
     "src/quiche/common/platform/api/quiche_client_stats.h",
@@ -219,7 +220,6 @@
     "src/quiche/quic/core/frames/quic_streams_blocked_frame.h",
     "src/quiche/quic/core/frames/quic_window_update_frame.h",
     "src/quiche/quic/core/handshaker_delegate_interface.h",
-    "src/quiche/quic/core/http/capsule.h",
     "src/quiche/quic/core/http/http_constants.h",
     "src/quiche/quic/core/http/http_decoder.h",
     "src/quiche/quic/core/http/http_encoder.h",
@@ -409,6 +409,7 @@
     "src/quiche/balsa/http_validation_policy.cc",
     "src/quiche/balsa/simple_buffer.cc",
     "src/quiche/balsa/standard_header_map.cc",
+    "src/quiche/common/capsule.cc",
     "src/quiche/common/masque/connect_udp_datagram_payload.cc",
     "src/quiche/common/platform/api/quiche_hostname_utils.cc",
     "src/quiche/common/platform/api/quiche_mutex.cc",
@@ -564,7 +565,6 @@
     "src/quiche/quic/core/frames/quic_stream_frame.cc",
     "src/quiche/quic/core/frames/quic_streams_blocked_frame.cc",
     "src/quiche/quic/core/frames/quic_window_update_frame.cc",
-    "src/quiche/quic/core/http/capsule.cc",
     "src/quiche/quic/core/http/http_constants.cc",
     "src/quiche/quic/core/http/http_decoder.cc",
     "src/quiche/quic/core/http/http_encoder.cc",
@@ -1025,6 +1025,7 @@
     "src/quiche/balsa/header_properties_test.cc",
     "src/quiche/balsa/simple_buffer_test.cc",
     "src/quiche/binary_http/binary_http_message_test.cc",
+    "src/quiche/common/capsule_test.cc",
     "src/quiche/common/masque/connect_udp_datagram_payload_test.cc",
     "src/quiche/common/platform/api/quiche_file_utils_test.cc",
     "src/quiche/common/platform/api/quiche_hostname_utils_test.cc",
@@ -1154,7 +1155,6 @@
     "src/quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier_test.cc",
     "src/quiche/quic/core/deterministic_connection_id_generator_test.cc",
     "src/quiche/quic/core/frames/quic_frames_test.cc",
-    "src/quiche/quic/core/http/capsule_test.cc",
     "src/quiche/quic/core/http/http_decoder_test.cc",
     "src/quiche/quic/core/http/http_encoder_test.cc",
     "src/quiche/quic/core/http/http_frames_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index a79092f..495f110 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -19,6 +19,7 @@
     "quiche/balsa/noop_balsa_visitor.h",
     "quiche/balsa/simple_buffer.h",
     "quiche/balsa/standard_header_map.h",
+    "quiche/common/capsule.h",
     "quiche/common/masque/connect_udp_datagram_payload.h",
     "quiche/common/platform/api/quiche_bug_tracker.h",
     "quiche/common/platform/api/quiche_client_stats.h",
@@ -218,7 +219,6 @@
     "quiche/quic/core/frames/quic_streams_blocked_frame.h",
     "quiche/quic/core/frames/quic_window_update_frame.h",
     "quiche/quic/core/handshaker_delegate_interface.h",
-    "quiche/quic/core/http/capsule.h",
     "quiche/quic/core/http/http_constants.h",
     "quiche/quic/core/http/http_decoder.h",
     "quiche/quic/core/http/http_encoder.h",
@@ -408,6 +408,7 @@
     "quiche/balsa/http_validation_policy.cc",
     "quiche/balsa/simple_buffer.cc",
     "quiche/balsa/standard_header_map.cc",
+    "quiche/common/capsule.cc",
     "quiche/common/masque/connect_udp_datagram_payload.cc",
     "quiche/common/platform/api/quiche_hostname_utils.cc",
     "quiche/common/platform/api/quiche_mutex.cc",
@@ -563,7 +564,6 @@
     "quiche/quic/core/frames/quic_stream_frame.cc",
     "quiche/quic/core/frames/quic_streams_blocked_frame.cc",
     "quiche/quic/core/frames/quic_window_update_frame.cc",
-    "quiche/quic/core/http/capsule.cc",
     "quiche/quic/core/http/http_constants.cc",
     "quiche/quic/core/http/http_decoder.cc",
     "quiche/quic/core/http/http_encoder.cc",
@@ -1024,6 +1024,7 @@
     "quiche/balsa/header_properties_test.cc",
     "quiche/balsa/simple_buffer_test.cc",
     "quiche/binary_http/binary_http_message_test.cc",
+    "quiche/common/capsule_test.cc",
     "quiche/common/masque/connect_udp_datagram_payload_test.cc",
     "quiche/common/platform/api/quiche_file_utils_test.cc",
     "quiche/common/platform/api/quiche_hostname_utils_test.cc",
@@ -1153,7 +1154,6 @@
     "quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier_test.cc",
     "quiche/quic/core/deterministic_connection_id_generator_test.cc",
     "quiche/quic/core/frames/quic_frames_test.cc",
-    "quiche/quic/core/http/capsule_test.cc",
     "quiche/quic/core/http/http_decoder_test.cc",
     "quiche/quic/core/http/http_encoder_test.cc",
     "quiche/quic/core/http/http_frames_test.cc",
diff --git a/quiche/quic/core/http/capsule.cc b/quiche/common/capsule.cc
similarity index 87%
rename from quiche/quic/core/http/capsule.cc
rename to quiche/common/capsule.cc
index 6d9d5c8..0237a7f 100644
--- a/quiche/quic/core/http/capsule.cc
+++ b/quiche/common/capsule.cc
@@ -2,23 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/quic/core/http/capsule.h"
+#include "quiche/common/capsule.h"
 
 #include <type_traits>
 
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "quiche/quic/core/http/http_frames.h"
-#include "quiche/quic/core/quic_data_reader.h"
-#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_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_data_reader.h"
+#include "quiche/common/quiche_data_writer.h"
 #include "quiche/common/quiche_ip_address.h"
+#include "quiche/web_transport/web_transport.h"
 
-namespace quic {
+namespace quiche {
 
 std::string CapsuleTypeToString(CapsuleType capsule_type) {
   switch (capsule_type) {
@@ -142,8 +140,9 @@
 }
 
 // static
-Capsule Capsule::CloseWebTransportSession(WebTransportSessionError error_code,
-                                          absl::string_view error_message) {
+Capsule Capsule::CloseWebTransportSession(
+    webtransport::SessionErrorCode error_code,
+    absl::string_view error_message) {
   Capsule capsule(CapsuleType::CLOSE_WEBTRANSPORT_SESSION);
   capsule.close_web_transport_session_capsule().error_code = error_code;
   capsule.close_web_transport_session_capsule().error_message = error_message;
@@ -332,9 +331,9 @@
 
 quiche::QuicheBuffer SerializeCapsule(
     const Capsule& capsule, quiche::QuicheBufferAllocator* allocator) {
-  QuicByteCount capsule_type_length = QuicDataWriter::GetVarInt62Len(
+  size_t capsule_type_length = QuicheDataWriter::GetVarInt62Len(
       static_cast<uint64_t>(capsule.capsule_type()));
-  QuicByteCount capsule_data_length;
+  size_t capsule_data_length;
   switch (capsule.capsule_type()) {
     case CapsuleType::DATAGRAM:
       capsule_data_length =
@@ -350,7 +349,7 @@
       break;
     case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
       capsule_data_length =
-          sizeof(WebTransportSessionError) +
+          sizeof(webtransport::SessionErrorCode) +
           capsule.close_web_transport_session_capsule().error_message.size();
       break;
     case CapsuleType::ADDRESS_REQUEST:
@@ -358,10 +357,10 @@
       for (auto requested_address :
            capsule.address_request_capsule().requested_addresses) {
         capsule_data_length +=
-            QuicDataWriter::GetVarInt62Len(requested_address.request_id) + 1 +
+            QuicheDataWriter::GetVarInt62Len(requested_address.request_id) + 1 +
             (requested_address.ip_prefix.address().IsIPv4()
-                 ? QuicIpAddress::kIPv4AddressSize
-                 : QuicIpAddress::kIPv6AddressSize) +
+                 ? QuicheIpAddress::kIPv4AddressSize
+                 : QuicheIpAddress::kIPv6AddressSize) +
             1;
       }
       break;
@@ -370,10 +369,10 @@
       for (auto assigned_address :
            capsule.address_assign_capsule().assigned_addresses) {
         capsule_data_length +=
-            QuicDataWriter::GetVarInt62Len(assigned_address.request_id) + 1 +
+            QuicheDataWriter::GetVarInt62Len(assigned_address.request_id) + 1 +
             (assigned_address.ip_prefix.address().IsIPv4()
-                 ? QuicIpAddress::kIPv4AddressSize
-                 : QuicIpAddress::kIPv6AddressSize) +
+                 ? QuicheIpAddress::kIPv4AddressSize
+                 : QuicheIpAddress::kIPv6AddressSize) +
             1;
       }
       break;
@@ -383,8 +382,8 @@
            capsule.route_advertisement_capsule().ip_address_ranges) {
         capsule_data_length += 1 +
                                (ip_address_range.start_ip_address.IsIPv4()
-                                    ? QuicIpAddress::kIPv4AddressSize
-                                    : QuicIpAddress::kIPv6AddressSize) *
+                                    ? QuicheIpAddress::kIPv4AddressSize
+                                    : QuicheIpAddress::kIPv6AddressSize) *
                                    2 +
                                1;
       }
@@ -393,25 +392,25 @@
       capsule_data_length = capsule.unknown_capsule_data().length();
       break;
   }
-  QuicByteCount capsule_length_length =
-      QuicDataWriter::GetVarInt62Len(capsule_data_length);
-  QuicByteCount total_capsule_length =
+  size_t capsule_length_length =
+      QuicheDataWriter::GetVarInt62Len(capsule_data_length);
+  size_t total_capsule_length =
       capsule_type_length + capsule_length_length + capsule_data_length;
   quiche::QuicheBuffer buffer(allocator, total_capsule_length);
-  QuicDataWriter writer(buffer.size(), buffer.data());
+  QuicheDataWriter writer(buffer.size(), buffer.data());
   if (!writer.WriteVarInt62(static_cast<uint64_t>(capsule.capsule_type()))) {
-    QUIC_BUG(capsule type write fail) << "Failed to write CAPSULE type";
+    QUICHE_BUG(capsule type write fail) << "Failed to write CAPSULE type";
     return {};
   }
   if (!writer.WriteVarInt62(capsule_data_length)) {
-    QUIC_BUG(capsule length write fail) << "Failed to write CAPSULE length";
+    QUICHE_BUG(capsule length write fail) << "Failed to write CAPSULE length";
     return {};
   }
   switch (capsule.capsule_type()) {
     case CapsuleType::DATAGRAM:
       if (!writer.WriteStringPiece(
               capsule.datagram_capsule().http_datagram_payload)) {
-        QUIC_BUG(datagram capsule payload write fail)
+        QUICHE_BUG(datagram capsule payload write fail)
             << "Failed to write DATAGRAM CAPSULE payload";
         return {};
       }
@@ -419,7 +418,7 @@
     case CapsuleType::LEGACY_DATAGRAM:
       if (!writer.WriteStringPiece(
               capsule.legacy_datagram_capsule().http_datagram_payload)) {
-        QUIC_BUG(datagram legacy capsule payload write fail)
+        QUICHE_BUG(datagram legacy capsule payload write fail)
             << "Failed to write LEGACY_DATAGRAM CAPSULE payload";
         return {};
       }
@@ -428,7 +427,7 @@
       if (!writer.WriteStringPiece(
               capsule.legacy_datagram_without_context_capsule()
                   .http_datagram_payload)) {
-        QUIC_BUG(datagram legacy without context capsule payload write fail)
+        QUICHE_BUG(datagram legacy without context capsule payload write fail)
             << "Failed to write LEGACY_DATAGRAM_WITHOUT_CONTEXT CAPSULE "
                "payload";
         return {};
@@ -437,13 +436,13 @@
     case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
       if (!writer.WriteUInt32(
               capsule.close_web_transport_session_capsule().error_code)) {
-        QUIC_BUG(close webtransport session capsule error code write fail)
+        QUICHE_BUG(close webtransport session capsule error code write fail)
             << "Failed to write CLOSE_WEBTRANSPORT_SESSION error code";
         return {};
       }
       if (!writer.WriteStringPiece(
               capsule.close_web_transport_session_capsule().error_message)) {
-        QUIC_BUG(close webtransport session capsule error message write fail)
+        QUICHE_BUG(close webtransport session capsule error message write fail)
             << "Failed to write CLOSE_WEBTRANSPORT_SESSION error message";
         return {};
       }
@@ -452,24 +451,24 @@
       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)
+          QUICHE_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)
+          QUICHE_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)
+          QUICHE_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)
+          QUICHE_BUG(address request capsule prefix length write fail)
               << "Failed to write ADDRESS_REQUEST prefix length";
           return {};
         }
@@ -479,24 +478,24 @@
       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)
+          QUICHE_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)
+          QUICHE_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)
+          QUICHE_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)
+          QUICHE_BUG(address request capsule prefix length write fail)
               << "Failed to write ADDRESS_ASSIGN prefix length";
           return {};
         }
@@ -507,24 +506,24 @@
            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)
+          QUICHE_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)
+          QUICHE_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)
+          QUICHE_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)
+          QUICHE_BUG(route advertisement capsule IP protocol write fail)
               << "Failed to write ROUTE_ADVERTISEMENT IP protocol";
           return {};
         }
@@ -532,13 +531,13 @@
       break;
     default:
       if (!writer.WriteStringPiece(capsule.unknown_capsule_data())) {
-        QUIC_BUG(capsule data write fail) << "Failed to write CAPSULE data";
+        QUICHE_BUG(capsule data write fail) << "Failed to write CAPSULE data";
         return {};
       }
       break;
   }
   if (writer.remaining() != 0) {
-    QUIC_BUG(capsule write length mismatch)
+    QUICHE_BUG(capsule write length mismatch)
         << "CAPSULE serialization wrote " << writer.length() << " instead of "
         << writer.capacity();
     return {};
@@ -577,19 +576,20 @@
   if (buffered_data_.empty()) {
     return 0;
   }
-  QuicDataReader capsule_fragment_reader(buffered_data_);
+  QuicheDataReader capsule_fragment_reader(buffered_data_);
   uint64_t capsule_type64;
   if (!capsule_fragment_reader.ReadVarInt62(&capsule_type64)) {
-    QUIC_DVLOG(2) << "Partial read: not enough data to read capsule type";
+    QUICHE_DVLOG(2) << "Partial read: not enough data to read capsule type";
     return 0;
   }
   absl::string_view capsule_data;
   if (!capsule_fragment_reader.ReadStringPieceVarInt62(&capsule_data)) {
-    QUIC_DVLOG(2) << "Partial read: not enough data to read capsule length or "
-                     "full capsule data";
+    QUICHE_DVLOG(2)
+        << "Partial read: not enough data to read capsule length or "
+           "full capsule data";
     return 0;
   }
-  QuicDataReader capsule_data_reader(capsule_data);
+  QuicheDataReader capsule_data_reader(capsule_data);
   Capsule capsule(static_cast<CapsuleType>(capsule_type64));
   switch (capsule.capsule_type()) {
     case CapsuleType::DATAGRAM:
@@ -634,8 +634,8 @@
         absl::string_view ip_address_bytes;
         if (!capsule_data_reader.ReadStringPiece(
                 &ip_address_bytes, address_family == 4
-                                       ? QuicIpAddress::kIPv4AddressSize
-                                       : QuicIpAddress::kIPv6AddressSize)) {
+                                       ? QuicheIpAddress::kIPv4AddressSize
+                                       : QuicheIpAddress::kIPv6AddressSize)) {
           ReportParseFailure("Unable to read capsule ADDRESS_REQUEST address");
           return 0;
         }
@@ -682,8 +682,8 @@
         absl::string_view ip_address_bytes;
         if (!capsule_data_reader.ReadStringPiece(
                 &ip_address_bytes, address_family == 4
-                                       ? QuicIpAddress::kIPv4AddressSize
-                                       : QuicIpAddress::kIPv6AddressSize)) {
+                                       ? QuicheIpAddress::kIPv4AddressSize
+                                       : QuicheIpAddress::kIPv6AddressSize)) {
           ReportParseFailure("Unable to read capsule ADDRESS_ASSIGN address");
           return 0;
         }
@@ -726,8 +726,8 @@
         absl::string_view start_ip_address_bytes;
         if (!capsule_data_reader.ReadStringPiece(
                 &start_ip_address_bytes,
-                address_family == 4 ? QuicIpAddress::kIPv4AddressSize
-                                    : QuicIpAddress::kIPv6AddressSize)) {
+                address_family == 4 ? QuicheIpAddress::kIPv4AddressSize
+                                    : QuicheIpAddress::kIPv6AddressSize)) {
           ReportParseFailure(
               "Unable to read capsule ROUTE_ADVERTISEMENT start address");
           return 0;
@@ -740,9 +740,9 @@
         }
         absl::string_view end_ip_address_bytes;
         if (!capsule_data_reader.ReadStringPiece(
-                &end_ip_address_bytes, address_family == 4
-                                           ? QuicIpAddress::kIPv4AddressSize
-                                           : QuicIpAddress::kIPv6AddressSize)) {
+                &end_ip_address_bytes,
+                address_family == 4 ? QuicheIpAddress::kIPv4AddressSize
+                                    : QuicheIpAddress::kIPv6AddressSize)) {
           ReportParseFailure(
               "Unable to read capsule ROUTE_ADVERTISEMENT end address");
           return 0;
@@ -775,7 +775,7 @@
 
 void CapsuleParser::ReportParseFailure(const std::string& error_message) {
   if (parsing_error_occurred_) {
-    QUIC_BUG(multiple parse errors) << "Experienced multiple parse failures";
+    QUICHE_BUG(multiple parse errors) << "Experienced multiple parse failures";
     return;
   }
   parsing_error_occurred_ = true;
@@ -815,4 +815,4 @@
   return ip_address_ranges == other.ip_address_ranges;
 }
 
-}  // namespace quic
+}  // namespace quiche
diff --git a/quiche/quic/core/http/capsule.h b/quiche/common/capsule.h
similarity index 86%
rename from quiche/quic/core/http/capsule.h
rename to quiche/common/capsule.h
index 198f667..85292c4 100644
--- a/quiche/quic/core/http/capsule.h
+++ b/quiche/common/capsule.h
@@ -2,23 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef QUICHE_QUIC_CORE_HTTP_CAPSULE_H_
-#define QUICHE_QUIC_CORE_HTTP_CAPSULE_H_
+#ifndef QUICHE_COMMON_CAPSULE_H_
+#define QUICHE_COMMON_CAPSULE_H_
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
-#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "quiche/quic/core/quic_data_reader.h"
-#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"
+#include "quiche/web_transport/web_transport.h"
 
-namespace quic {
+namespace quiche {
 
 enum class CapsuleType : uint64_t {
   // Casing in this enum matches the IETF specifications.
@@ -33,49 +31,49 @@
   ROUTE_ADVERTISEMENT = 0x1ECA6A02,
 };
 
-QUIC_EXPORT_PRIVATE std::string CapsuleTypeToString(CapsuleType capsule_type);
-QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
-                                             const CapsuleType& capsule_type);
+QUICHE_EXPORT std::string CapsuleTypeToString(CapsuleType capsule_type);
+QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+                                       const CapsuleType& capsule_type);
 
-struct QUIC_EXPORT_PRIVATE DatagramCapsule {
+struct QUICHE_EXPORT DatagramCapsule {
   absl::string_view http_datagram_payload;
   std::string ToString() const;
 };
-struct QUIC_EXPORT_PRIVATE LegacyDatagramCapsule {
+struct QUICHE_EXPORT LegacyDatagramCapsule {
   absl::string_view http_datagram_payload;
   std::string ToString() const;
 };
-struct QUIC_EXPORT_PRIVATE LegacyDatagramWithoutContextCapsule {
+struct QUICHE_EXPORT LegacyDatagramWithoutContextCapsule {
   absl::string_view http_datagram_payload;
   std::string ToString() const;
 };
-struct QUIC_EXPORT_PRIVATE CloseWebTransportSessionCapsule {
-  WebTransportSessionError error_code;
+struct QUICHE_EXPORT CloseWebTransportSessionCapsule {
+  webtransport::SessionErrorCode error_code;
   absl::string_view error_message;
   std::string ToString() const;
 };
-struct QUIC_EXPORT_PRIVATE PrefixWithId {
+struct QUICHE_EXPORT PrefixWithId {
   uint64_t request_id;
   quiche::QuicheIpPrefix ip_prefix;
   bool operator==(const PrefixWithId& other) const;
 };
-struct QUIC_EXPORT_PRIVATE IpAddressRange {
+struct QUICHE_EXPORT 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 {
+struct QUICHE_EXPORT AddressAssignCapsule {
   std::vector<PrefixWithId> assigned_addresses;
   bool operator==(const AddressAssignCapsule& other) const;
   std::string ToString() const;
 };
-struct QUIC_EXPORT_PRIVATE AddressRequestCapsule {
+struct QUICHE_EXPORT AddressRequestCapsule {
   std::vector<PrefixWithId> requested_addresses;
   bool operator==(const AddressRequestCapsule& other) const;
   std::string ToString() const;
 };
-struct QUIC_EXPORT_PRIVATE RouteAdvertisementCapsule {
+struct QUICHE_EXPORT RouteAdvertisementCapsule {
   std::vector<IpAddressRange> ip_address_ranges;
   bool operator==(const RouteAdvertisementCapsule& other) const;
   std::string ToString() const;
@@ -86,7 +84,7 @@
 // points to. Strings saved into a capsule must outlive the capsule object. Any
 // code that sees a capsule in a callback needs to either process it immediately
 // or perform its own deep copy.
-class QUIC_EXPORT_PRIVATE Capsule {
+class QUICHE_EXPORT Capsule {
  public:
   static Capsule Datagram(
       absl::string_view http_datagram_payload = absl::string_view());
@@ -95,7 +93,7 @@
   static Capsule LegacyDatagramWithoutContext(
       absl::string_view http_datagram_payload = absl::string_view());
   static Capsule CloseWebTransportSession(
-      WebTransportSessionError error_code = 0,
+      webtransport::SessionErrorCode error_code = 0,
       absl::string_view error_message = "");
   static Capsule AddressRequest();
   static Capsule AddressAssign();
@@ -112,8 +110,8 @@
 
   // Human-readable information string for debugging purposes.
   std::string ToString() const;
-  friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
-                                                      const Capsule& capsule);
+  friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
+                                                const Capsule& capsule);
 
   CapsuleType capsule_type() const { return capsule_type_; }
   DatagramCapsule& datagram_capsule() {
@@ -222,9 +220,9 @@
 class CapsuleParserPeer;
 }  // namespace test
 
-class QUIC_EXPORT_PRIVATE CapsuleParser {
+class QUICHE_EXPORT CapsuleParser {
  public:
-  class QUIC_EXPORT_PRIVATE Visitor {
+  class QUICHE_EXPORT Visitor {
    public:
     virtual ~Visitor() {}
 
@@ -268,9 +266,9 @@
 };
 
 // Serializes |capsule| into a newly allocated buffer.
-QUIC_EXPORT_PRIVATE quiche::QuicheBuffer SerializeCapsule(
+QUICHE_EXPORT quiche::QuicheBuffer SerializeCapsule(
     const Capsule& capsule, quiche::QuicheBufferAllocator* allocator);
 
-}  // namespace quic
+}  // namespace quiche
 
-#endif  // QUICHE_QUIC_CORE_HTTP_CAPSULE_H_
+#endif  // QUICHE_COMMON_CAPSULE_H_
diff --git a/quiche/quic/core/http/capsule_test.cc b/quiche/common/capsule_test.cc
similarity index 97%
rename from quiche/quic/core/http/capsule_test.cc
rename to quiche/common/capsule_test.cc
index 95869c6..23d7533 100644
--- a/quiche/quic/core/http/capsule_test.cc
+++ b/quiche/common/capsule_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "quiche/quic/core/http/capsule.h"
+#include "quiche/common/capsule.h"
 
 #include <cstddef>
 #include <deque>
@@ -11,16 +11,16 @@
 
 #include "absl/strings/escaping.h"
 #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/platform/api/quiche_test.h"
 #include "quiche/common/quiche_ip_address.h"
+#include "quiche/common/simple_buffer_allocator.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Return;
 
-namespace quic {
+namespace quiche {
 namespace test {
 
 class CapsuleParserPeer {
@@ -43,7 +43,7 @@
               (override));
 };
 
-class CapsuleTest : public QuicTest {
+class CapsuleTest : public QuicheTest {
  public:
   CapsuleTest() : capsule_parser_(&visitor_) {}
 
@@ -57,7 +57,7 @@
   void TestSerialization(const Capsule& capsule,
                          const std::string& expected_bytes) {
     quiche::QuicheBuffer serialized_capsule =
-        SerializeCapsule(capsule, quiche::SimpleBufferAllocator::Get());
+        SerializeCapsule(capsule, SimpleBufferAllocator::Get());
     quiche::test::CompareCharArraysWithHexError(
         "Serialized capsule", serialized_capsule.data(),
         serialized_capsule.size(), expected_bytes.data(),
@@ -389,4 +389,4 @@
 
 }  // namespace
 }  // namespace test
-}  // namespace quic
+}  // namespace quiche
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index 839e330..90e5341 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -14,7 +14,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "quiche/http2/http2_constants.h"
-#include "quiche/quic/core/http/capsule.h"
 #include "quiche/quic/core/http/http_constants.h"
 #include "quiche/quic/core/http/http_decoder.h"
 #include "quiche/quic/core/http/http_frames.h"
@@ -32,11 +31,14 @@
 #include "quiche/quic/platform/api/quic_flag_utils.h"
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/capsule.h"
 #include "quiche/common/quiche_mem_slice_storage.h"
 #include "quiche/common/quiche_text_utils.h"
 #include "quiche/spdy/core/spdy_protocol.h"
 
-using spdy::Http2HeaderBlock;
+using ::quiche::Capsule;
+using ::quiche::CapsuleType;
+using ::spdy::Http2HeaderBlock;
 
 namespace quic {
 
@@ -1444,7 +1446,7 @@
   }
   datagram_visitor_ = visitor;
   QUICHE_DCHECK(!capsule_parser_);
-  capsule_parser_ = std::make_unique<CapsuleParser>(this);
+  capsule_parser_ = std::make_unique<quiche::CapsuleParser>(this);
 }
 
 void QuicSpdyStream::UnregisterHttp3DatagramVisitor() {
diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h
index 450e154..887facb 100644
--- a/quiche/quic/core/http/quic_spdy_stream.h
+++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -19,7 +19,6 @@
 #include "absl/base/attributes.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
-#include "quiche/quic/core/http/capsule.h"
 #include "quiche/quic/core/http/http_decoder.h"
 #include "quiche/quic/core/http/http_encoder.h"
 #include "quiche/quic/core/http/quic_header_list.h"
@@ -36,6 +35,7 @@
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
+#include "quiche/common/capsule.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
 #include "quiche/spdy/core/http2_header_block.h"
 #include "quiche/spdy/core/spdy_framer.h"
@@ -53,7 +53,7 @@
 // A QUIC stream that can send and receive HTTP2 (SPDY) headers.
 class QUIC_EXPORT_PRIVATE QuicSpdyStream
     : public QuicStream,
-      public CapsuleParser::Visitor,
+      public quiche::CapsuleParser::Visitor,
       public QpackDecodedHeadersAccumulator::Visitor {
  public:
   // Visitor receives callbacks from the stream.
@@ -256,7 +256,7 @@
   bool CanWriteNewBodyData(QuicByteCount write_size) const;
 
   // From CapsuleParser::Visitor.
-  bool OnCapsule(const Capsule& capsule) override;
+  bool OnCapsule(const quiche::Capsule& capsule) override;
   void OnCapsuleParseFailure(const std::string& error_message) override;
 
   // Sends an HTTP/3 datagram. The stream ID is not part of |payload|. Virtual
@@ -290,11 +290,11 @@
     virtual ~ConnectIpVisitor() {}
 
     virtual bool OnAddressAssignCapsule(
-        const AddressAssignCapsule& capsule) = 0;
+        const quiche::AddressAssignCapsule& capsule) = 0;
     virtual bool OnAddressRequestCapsule(
-        const AddressRequestCapsule& capsule) = 0;
+        const quiche::AddressRequestCapsule& capsule) = 0;
     virtual bool OnRouteAdvertisementCapsule(
-        const RouteAdvertisementCapsule& capsule) = 0;
+        const quiche::RouteAdvertisementCapsule& capsule) = 0;
     virtual void OnHeadersWritten() = 0;
   };
 
@@ -318,7 +318,7 @@
   QuicByteCount GetMaxDatagramSize() const;
 
   // Writes |capsule| onto the DATA stream.
-  void WriteCapsule(const Capsule& capsule, bool fin = false);
+  void WriteCapsule(const quiche::Capsule& capsule, bool fin = false);
 
   void WriteGreaseCapsule();
 
@@ -452,7 +452,7 @@
   // the sequencer each time new stream data is processed.
   QuicSpdyStreamBodyManager body_manager_;
 
-  std::unique_ptr<CapsuleParser> capsule_parser_;
+  std::unique_ptr<quiche::CapsuleParser> capsule_parser_;
 
   // Sequencer offset keeping track of how much data HttpDecoder has processed.
   // Initial value is zero for fresh streams, or sequencer()->NumBytesConsumed()
diff --git a/quiche/quic/core/http/quic_spdy_stream_test.cc b/quiche/quic/core/http/quic_spdy_stream_test.cc
index 1ab50a0..dc15654 100644
--- a/quiche/quic/core/http/quic_spdy_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_stream_test.cc
@@ -15,7 +15,6 @@
 #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"
@@ -37,10 +36,13 @@
 #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/capsule.h"
 #include "quiche/common/quiche_ip_address.h"
 #include "quiche/common/quiche_mem_slice_storage.h"
 #include "quiche/common/simple_buffer_allocator.h"
 
+using quiche::Capsule;
+using quiche::IpAddressRange;
 using spdy::Http2HeaderBlock;
 using spdy::kV3HighestPriority;
 using spdy::kV3LowestPriority;
@@ -3195,7 +3197,7 @@
               ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
                   stream_->id(), http_datagram_payload}));
   // Address assign capsule.
-  PrefixWithId ip_prefix_with_id;
+  quiche::PrefixWithId ip_prefix_with_id;
   ip_prefix_with_id.request_id = 1;
   quiche::QuicheIpAddress ip_address;
   ip_address.FromString("::");
diff --git a/quiche/quic/core/http/web_transport_http3.cc b/quiche/quic/core/http/web_transport_http3.cc
index d74071d..91372d5 100644
--- a/quiche/quic/core/http/web_transport_http3.cc
+++ b/quiche/quic/core/http/web_transport_http3.cc
@@ -9,7 +9,6 @@
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
-#include "quiche/quic/core/http/capsule.h"
 #include "quiche/quic/core/http/quic_spdy_session.h"
 #include "quiche/quic/core/http/quic_spdy_stream.h"
 #include "quiche/quic/core/quic_data_reader.h"
@@ -20,6 +19,7 @@
 #include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/core/quic_versions.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
+#include "quiche/common/capsule.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/web_transport/web_transport.h"
 
@@ -108,7 +108,7 @@
   QuicConnection::ScopedPacketFlusher flusher(
       connect_stream_->spdy_session()->connection());
   connect_stream_->WriteCapsule(
-      Capsule::CloseWebTransportSession(error_code, error_message),
+      quiche::Capsule::CloseWebTransportSession(error_code, error_message),
       /*fin=*/true);
 }
 
diff --git a/quiche/quic/masque/masque_client_bin.cc b/quiche/quic/masque/masque_client_bin.cc
index 7383680..76f984c 100644
--- a/quiche/quic/masque/masque_client_bin.cc
+++ b/quiche/quic/masque/masque_client_bin.cc
@@ -49,6 +49,10 @@
 
 namespace {
 
+using ::quiche::AddressAssignCapsule;
+using ::quiche::AddressRequestCapsule;
+using ::quiche::RouteAdvertisementCapsule;
+
 class MasqueTunSession : public MasqueClientSession::EncapsulatedIpSession,
                          public QuicSocketEventListener {
  public:
diff --git a/quiche/quic/masque/masque_client_session.cc b/quiche/quic/masque/masque_client_session.cc
index e9d6d8b..5367d9e 100644
--- a/quiche/quic/masque/masque_client_session.cc
+++ b/quiche/quic/masque/masque_client_session.cc
@@ -26,6 +26,11 @@
 namespace quic {
 
 namespace {
+
+using ::quiche::AddressAssignCapsule;
+using ::quiche::AddressRequestCapsule;
+using ::quiche::RouteAdvertisementCapsule;
+
 constexpr uint64_t kConnectIpPayloadContextId = 0;
 }
 
diff --git a/quiche/quic/masque/masque_client_session.h b/quiche/quic/masque/masque_client_session.h
index 2b48e49..43703b4 100644
--- a/quiche/quic/masque/masque_client_session.h
+++ b/quiche/quic/masque/masque_client_session.h
@@ -66,11 +66,11 @@
     virtual void CloseIpSession(const std::string& details) = 0;
 
     virtual bool OnAddressAssignCapsule(
-        const AddressAssignCapsule& capsule) = 0;
+        const quiche::AddressAssignCapsule& capsule) = 0;
     virtual bool OnAddressRequestCapsule(
-        const AddressRequestCapsule& capsule) = 0;
+        const quiche::AddressRequestCapsule& capsule) = 0;
     virtual bool OnRouteAdvertisementCapsule(
-        const RouteAdvertisementCapsule& capsule) = 0;
+        const quiche::RouteAdvertisementCapsule& capsule) = 0;
   };
 
   // Takes ownership of |connection|, but not of |crypto_config| or
@@ -186,10 +186,12 @@
                          absl::string_view payload) override;
 
     // From QuicSpdyStream::ConnectIpVisitor.
-    bool OnAddressAssignCapsule(const AddressAssignCapsule& capsule) override;
-    bool OnAddressRequestCapsule(const AddressRequestCapsule& capsule) override;
+    bool OnAddressAssignCapsule(
+        const quiche::AddressAssignCapsule& capsule) override;
+    bool OnAddressRequestCapsule(
+        const quiche::AddressRequestCapsule& capsule) override;
     bool OnRouteAdvertisementCapsule(
-        const RouteAdvertisementCapsule& capsule) override;
+        const quiche::RouteAdvertisementCapsule& capsule) override;
     void OnHeadersWritten() override;
 
    private:
diff --git a/quiche/quic/masque/masque_encapsulated_client_session.cc b/quiche/quic/masque/masque_encapsulated_client_session.cc
index a4d83f6..d9e77ba 100644
--- a/quiche/quic/masque/masque_encapsulated_client_session.cc
+++ b/quiche/quic/masque/masque_encapsulated_client_session.cc
@@ -10,6 +10,10 @@
 
 namespace quic {
 
+using ::quiche::AddressAssignCapsule;
+using ::quiche::AddressRequestCapsule;
+using ::quiche::RouteAdvertisementCapsule;
+
 MasqueEncapsulatedClientSession::MasqueEncapsulatedClientSession(
     const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
     QuicConnection* connection, const QuicServerId& server_id,
diff --git a/quiche/quic/masque/masque_encapsulated_client_session.h b/quiche/quic/masque/masque_encapsulated_client_session.h
index d50e9b8..323c16d 100644
--- a/quiche/quic/masque/masque_encapsulated_client_session.h
+++ b/quiche/quic/masque/masque_encapsulated_client_session.h
@@ -51,10 +51,12 @@
   // From MasqueClientSession::EncapsulatedIpSession.
   void ProcessIpPacket(absl::string_view packet) override;
   void CloseIpSession(const std::string& details) override;
-  bool OnAddressAssignCapsule(const AddressAssignCapsule& capsule) override;
-  bool OnAddressRequestCapsule(const AddressRequestCapsule& capsule) override;
+  bool OnAddressAssignCapsule(
+      const quiche::AddressAssignCapsule& capsule) override;
+  bool OnAddressRequestCapsule(
+      const quiche::AddressRequestCapsule& capsule) override;
   bool OnRouteAdvertisementCapsule(
-      const RouteAdvertisementCapsule& capsule) override;
+      const quiche::RouteAdvertisementCapsule& capsule) override;
 
   // From QuicSession.
   void OnConnectionClosed(const QuicConnectionCloseFrame& frame,
diff --git a/quiche/quic/masque/masque_server_session.cc b/quiche/quic/masque/masque_server_session.cc
index 2feb48d..493b9f6 100644
--- a/quiche/quic/masque/masque_server_session.cc
+++ b/quiche/quic/masque/masque_server_session.cc
@@ -26,12 +26,21 @@
 #include "quiche/quic/masque/masque_utils.h"
 #include "quiche/quic/platform/api/quic_ip_address.h"
 #include "quiche/quic/tools/quic_url.h"
+#include "quiche/common/capsule.h"
 #include "quiche/common/platform/api/quiche_url_utils.h"
 #include "quiche/common/quiche_ip_address.h"
 
 namespace quic {
 
 namespace {
+
+using ::quiche::AddressAssignCapsule;
+using ::quiche::AddressRequestCapsule;
+using ::quiche::Capsule;
+using ::quiche::IpAddressRange;
+using ::quiche::PrefixWithId;
+using ::quiche::RouteAdvertisementCapsule;
+
 // RAII wrapper for QuicUdpSocketFd.
 class FdWrapper {
  public:
diff --git a/quiche/quic/masque/masque_server_session.h b/quiche/quic/masque/masque_server_session.h
index 77fdc73..082616d 100644
--- a/quiche/quic/masque/masque_server_session.h
+++ b/quiche/quic/masque/masque_server_session.h
@@ -117,10 +117,12 @@
                          absl::string_view payload) override;
 
     // From QuicSpdyStream::ConnectIpVisitor.
-    bool OnAddressAssignCapsule(const AddressAssignCapsule& capsule) override;
-    bool OnAddressRequestCapsule(const AddressRequestCapsule& capsule) override;
+    bool OnAddressAssignCapsule(
+        const quiche::AddressAssignCapsule& capsule) override;
+    bool OnAddressRequestCapsule(
+        const quiche::AddressRequestCapsule& capsule) override;
     bool OnRouteAdvertisementCapsule(
-        const RouteAdvertisementCapsule& capsule) override;
+        const quiche::RouteAdvertisementCapsule& capsule) override;
     void OnHeadersWritten() override;
 
    private:
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index 8609d5f..32a16c1 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -2099,40 +2099,43 @@
 // Implementation of ConnectIpVisitor which saves all received capsules.
 class SavingConnectIpVisitor : public QuicSpdyStream::ConnectIpVisitor {
  public:
-  const std::vector<AddressAssignCapsule>& received_address_assign_capsules()
-      const {
+  const std::vector<quiche::AddressAssignCapsule>&
+  received_address_assign_capsules() const {
     return received_address_assign_capsules_;
   }
-  const std::vector<AddressRequestCapsule>& received_address_request_capsules()
-      const {
+  const std::vector<quiche::AddressRequestCapsule>&
+  received_address_request_capsules() const {
     return received_address_request_capsules_;
   }
-  const std::vector<RouteAdvertisementCapsule>&
+  const std::vector<quiche::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 {
+  bool OnAddressAssignCapsule(
+      const quiche::AddressAssignCapsule& capsule) override {
     received_address_assign_capsules_.push_back(capsule);
     return true;
   }
-  bool OnAddressRequestCapsule(const AddressRequestCapsule& capsule) override {
+  bool OnAddressRequestCapsule(
+      const quiche::AddressRequestCapsule& capsule) override {
     received_address_request_capsules_.push_back(capsule);
     return true;
   }
   bool OnRouteAdvertisementCapsule(
-      const RouteAdvertisementCapsule& capsule) override {
+      const quiche::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_;
+  std::vector<quiche::AddressAssignCapsule> received_address_assign_capsules_;
+  std::vector<quiche::AddressRequestCapsule> received_address_request_capsules_;
+  std::vector<quiche::RouteAdvertisementCapsule>
+      received_route_advertisement_capsules_;
   bool headers_written_ = false;
 };