diff --git a/quiche/common/capsule.cc b/quiche/common/capsule.cc
index bb1ab7e..22b8883 100644
--- a/quiche/common/capsule.cc
+++ b/quiche/common/capsule.cc
@@ -12,6 +12,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
+#include "absl/types/variant.h"
 #include "quiche/common/platform/api/quiche_bug_tracker.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_buffer_allocator.h"
@@ -48,208 +49,48 @@
   return os;
 }
 
-Capsule::Capsule(CapsuleType capsule_type) : capsule_type_(capsule_type) {
-  switch (capsule_type) {
-    case CapsuleType::DATAGRAM:
-      static_assert(std::is_standard_layout<DatagramCapsule>::value &&
-                        std::is_trivially_destructible<DatagramCapsule>::value,
-                    "All inline capsule structs must have these properties");
-      datagram_capsule_ = DatagramCapsule();
-      break;
-    case CapsuleType::LEGACY_DATAGRAM:
-      static_assert(
-          std::is_standard_layout<LegacyDatagramCapsule>::value &&
-              std::is_trivially_destructible<LegacyDatagramCapsule>::value,
-          "All inline capsule structs must have these properties");
-      legacy_datagram_capsule_ = LegacyDatagramCapsule();
-      break;
-    case CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT:
-      static_assert(
-          std::is_standard_layout<LegacyDatagramWithoutContextCapsule>::value &&
-              std::is_trivially_destructible<
-                  LegacyDatagramWithoutContextCapsule>::value,
-          "All inline capsule structs must have these properties");
-      legacy_datagram_without_context_capsule_ =
-          LegacyDatagramWithoutContextCapsule();
-      break;
-    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
-      static_assert(
-          std::is_standard_layout<CloseWebTransportSessionCapsule>::value &&
-              std::is_trivially_destructible<
-                  CloseWebTransportSessionCapsule>::value,
-          "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::DATAGRAM:
-    case CapsuleType::LEGACY_DATAGRAM:
-    case CapsuleType::LEGACY_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::Datagram(absl::string_view http_datagram_payload) {
-  Capsule capsule(CapsuleType::DATAGRAM);
-  capsule.datagram_capsule().http_datagram_payload = http_datagram_payload;
-  return capsule;
+  return Capsule(DatagramCapsule{http_datagram_payload});
 }
 
 // static
 Capsule Capsule::LegacyDatagram(absl::string_view http_datagram_payload) {
-  Capsule capsule(CapsuleType::LEGACY_DATAGRAM);
-  capsule.legacy_datagram_capsule().http_datagram_payload =
-      http_datagram_payload;
-  return capsule;
+  return Capsule(LegacyDatagramCapsule{http_datagram_payload});
 }
 
 // static
 Capsule Capsule::LegacyDatagramWithoutContext(
     absl::string_view http_datagram_payload) {
-  Capsule capsule(CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT);
-  capsule.legacy_datagram_without_context_capsule().http_datagram_payload =
-      http_datagram_payload;
-  return capsule;
+  return Capsule(LegacyDatagramWithoutContextCapsule{http_datagram_payload});
 }
 
 // static
 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;
-  return capsule;
+  return Capsule(CloseWebTransportSessionCapsule({error_code, error_message}));
 }
 
 // static
-Capsule Capsule::AddressRequest() {
-  return Capsule(CapsuleType::ADDRESS_REQUEST);
-}
+Capsule Capsule::AddressRequest() { return Capsule(AddressRequestCapsule()); }
 
 // static
-Capsule Capsule::AddressAssign() {
-  return Capsule(CapsuleType::ADDRESS_ASSIGN);
-}
+Capsule Capsule::AddressAssign() { return Capsule(AddressAssignCapsule()); }
 
 // static
 Capsule Capsule::RouteAdvertisement() {
-  return Capsule(CapsuleType::ROUTE_ADVERTISEMENT);
+  return Capsule(RouteAdvertisementCapsule());
 }
 
 // static
 Capsule Capsule::Unknown(uint64_t capsule_type,
                          absl::string_view unknown_capsule_data) {
-  Capsule capsule(static_cast<CapsuleType>(capsule_type));
-  capsule.unknown_capsule_data() = unknown_capsule_data;
-  return capsule;
-}
-
-Capsule& Capsule::operator=(const Capsule& other) {
-  Free();
-  capsule_type_ = other.capsule_type_;
-  switch (capsule_type_) {
-    case CapsuleType::DATAGRAM:
-      datagram_capsule_ = other.datagram_capsule_;
-      break;
-    case CapsuleType::LEGACY_DATAGRAM:
-      legacy_datagram_capsule_ = other.legacy_datagram_capsule_;
-      break;
-    case CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT:
-      legacy_datagram_without_context_capsule_ =
-          other.legacy_datagram_without_context_capsule_;
-      break;
-    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
-      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;
-  }
-  return *this;
-}
-
-Capsule::Capsule(const Capsule& other) : Capsule(other.capsule_type_) {
-  *this = other;
+  return Capsule(UnknownCapsule{capsule_type, unknown_capsule_data});
 }
 
 bool Capsule::operator==(const Capsule& other) const {
-  if (capsule_type_ != other.capsule_type_) {
-    return false;
-  }
-  switch (capsule_type_) {
-    case CapsuleType::DATAGRAM:
-      return datagram_capsule_.http_datagram_payload ==
-             other.datagram_capsule_.http_datagram_payload;
-    case CapsuleType::LEGACY_DATAGRAM:
-      return legacy_datagram_capsule_.http_datagram_payload ==
-             other.legacy_datagram_capsule_.http_datagram_payload;
-    case CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT:
-      return legacy_datagram_without_context_capsule_.http_datagram_payload ==
-             other.legacy_datagram_without_context_capsule_
-                 .http_datagram_payload;
-    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
-      return close_web_transport_session_capsule_.error_code ==
-                 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_;
-  }
+  return capsule_ == other.capsule_;
 }
 
 std::string DatagramCapsule::ToString() const {
@@ -303,26 +144,14 @@
   return rv;
 }
 
+std::string UnknownCapsule::ToString() const {
+  return absl::StrCat("Unknown(", type, ") [", absl::BytesToHexString(payload),
+                      "]");
+}
+
 std::string Capsule::ToString() const {
-  switch (capsule_type_) {
-    case CapsuleType::DATAGRAM:
-      return datagram_capsule_.ToString();
-    case CapsuleType::LEGACY_DATAGRAM:
-      return legacy_datagram_capsule_.ToString();
-    case CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT:
-      return legacy_datagram_without_context_capsule_.ToString();
-    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
-      return close_web_transport_session_capsule_.ToString();
-    case CapsuleType::ADDRESS_REQUEST:
-      return address_request_capsule_->ToString();
-    case CapsuleType::ADDRESS_ASSIGN:
-      return address_assign_capsule_->ToString();
-    case CapsuleType::ROUTE_ADVERTISEMENT:
-      return route_advertisement_capsule_->ToString();
-    default:
-      return absl::StrCat(CapsuleTypeToString(capsule_type_), "[",
-                          absl::BytesToHexString(unknown_capsule_data_), "]");
-  }
+  return absl::visit([](const auto& capsule) { return capsule.ToString(); },
+                     capsule_);
 }
 
 std::ostream& operator<<(std::ostream& os, const Capsule& capsule) {
@@ -438,8 +267,9 @@
           WireSpan<WireIpAddressRange>(absl::MakeConstSpan(
               capsule.route_advertisement_capsule().ip_address_ranges)));
     default:
-      return SerializeCapsuleFields(capsule.capsule_type(), allocator,
-                                    WireBytes(capsule.unknown_capsule_data()));
+      return SerializeCapsuleFields(
+          capsule.capsule_type(), allocator,
+          WireBytes(capsule.unknown_capsule().payload));
   }
 }
 
@@ -462,16 +292,16 @@
   }
   absl::StrAppend(&buffered_data_, capsule_fragment);
   while (true) {
-    const size_t buffered_data_read = AttemptParseCapsule();
-    if (parsing_error_occurred_) {
-      QUICHE_DCHECK_EQ(buffered_data_read, 0u);
+    const absl::StatusOr<size_t> buffered_data_read = AttemptParseCapsule();
+    if (!buffered_data_read.ok()) {
+      ReportParseFailure(buffered_data_read.status().message());
       buffered_data_.clear();
       return false;
     }
-    if (buffered_data_read == 0) {
+    if (*buffered_data_read == 0) {
       break;
     }
-    buffered_data_.erase(0, buffered_data_read);
+    buffered_data_.erase(0, *buffered_data_read);
   }
   static constexpr size_t kMaxCapsuleBufferSize = 1024 * 1024;
   if (buffered_data_.size() > kMaxCapsuleBufferSize) {
@@ -482,7 +312,166 @@
   return true;
 }
 
-size_t CapsuleParser::AttemptParseCapsule() {
+static absl::StatusOr<Capsule> ParseCapsulePayload(QuicheDataReader& reader,
+                                                   CapsuleType type) {
+  switch (type) {
+    case CapsuleType::DATAGRAM:
+      return Capsule::Datagram(reader.ReadRemainingPayload());
+    case CapsuleType::LEGACY_DATAGRAM:
+      return Capsule::LegacyDatagram(reader.ReadRemainingPayload());
+    case CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT:
+      return Capsule::LegacyDatagramWithoutContext(
+          reader.ReadRemainingPayload());
+    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION: {
+      CloseWebTransportSessionCapsule capsule;
+      if (!reader.ReadUInt32(&capsule.error_code)) {
+        return absl::InvalidArgumentError(
+            "Unable to parse capsule CLOSE_WEBTRANSPORT_SESSION error code");
+      }
+      capsule.error_message = reader.ReadRemainingPayload();
+      return Capsule(std::move(capsule));
+    }
+    case CapsuleType::ADDRESS_REQUEST: {
+      AddressRequestCapsule capsule;
+      while (!reader.IsDoneReading()) {
+        PrefixWithId requested_address;
+        if (!reader.ReadVarInt62(&requested_address.request_id)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_REQUEST request ID");
+        }
+        uint8_t address_family;
+        if (!reader.ReadUInt8(&address_family)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_REQUEST family");
+        }
+        if (address_family != 4 && address_family != 6) {
+          return absl::InvalidArgumentError("Bad ADDRESS_REQUEST family");
+        }
+        absl::string_view ip_address_bytes;
+        if (!reader.ReadStringPiece(&ip_address_bytes,
+                                    address_family == 4
+                                        ? QuicheIpAddress::kIPv4AddressSize
+                                        : QuicheIpAddress::kIPv6AddressSize)) {
+          return absl::InvalidArgumentError(
+              "Unable to read capsule ADDRESS_REQUEST address");
+        }
+        quiche::QuicheIpAddress ip_address;
+        if (!ip_address.FromPackedString(ip_address_bytes.data(),
+                                         ip_address_bytes.size())) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_REQUEST address");
+        }
+        uint8_t ip_prefix_length;
+        if (!reader.ReadUInt8(&ip_prefix_length)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_REQUEST IP prefix length");
+        }
+        if (ip_prefix_length > QuicheIpPrefix(ip_address).prefix_length()) {
+          return absl::InvalidArgumentError("Invalid IP prefix length");
+        }
+        requested_address.ip_prefix =
+            QuicheIpPrefix(ip_address, ip_prefix_length);
+        capsule.requested_addresses.push_back(requested_address);
+      }
+      return Capsule(std::move(capsule));
+    }
+    case CapsuleType::ADDRESS_ASSIGN: {
+      AddressAssignCapsule capsule;
+      while (!reader.IsDoneReading()) {
+        PrefixWithId assigned_address;
+        if (!reader.ReadVarInt62(&assigned_address.request_id)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_ASSIGN request ID");
+        }
+        uint8_t address_family;
+        if (!reader.ReadUInt8(&address_family)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_ASSIGN family");
+        }
+        if (address_family != 4 && address_family != 6) {
+          return absl::InvalidArgumentError("Bad ADDRESS_ASSIGN family");
+        }
+        absl::string_view ip_address_bytes;
+        if (!reader.ReadStringPiece(&ip_address_bytes,
+                                    address_family == 4
+                                        ? QuicheIpAddress::kIPv4AddressSize
+                                        : QuicheIpAddress::kIPv6AddressSize)) {
+          return absl::InvalidArgumentError(
+              "Unable to read capsule ADDRESS_ASSIGN address");
+        }
+        quiche::QuicheIpAddress ip_address;
+        if (!ip_address.FromPackedString(ip_address_bytes.data(),
+                                         ip_address_bytes.size())) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_ASSIGN address");
+        }
+        uint8_t ip_prefix_length;
+        if (!reader.ReadUInt8(&ip_prefix_length)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ADDRESS_ASSIGN IP prefix length");
+        }
+        if (ip_prefix_length > QuicheIpPrefix(ip_address).prefix_length()) {
+          return absl::InvalidArgumentError("Invalid IP prefix length");
+        }
+        assigned_address.ip_prefix =
+            QuicheIpPrefix(ip_address, ip_prefix_length);
+        capsule.assigned_addresses.push_back(assigned_address);
+      }
+      return Capsule(std::move(capsule));
+    }
+    case CapsuleType::ROUTE_ADVERTISEMENT: {
+      RouteAdvertisementCapsule capsule;
+      while (!reader.IsDoneReading()) {
+        uint8_t address_family;
+        if (!reader.ReadUInt8(&address_family)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT family");
+        }
+        if (address_family != 4 && address_family != 6) {
+          return absl::InvalidArgumentError("Bad ROUTE_ADVERTISEMENT family");
+        }
+        IpAddressRange ip_address_range;
+        absl::string_view start_ip_address_bytes;
+        if (!reader.ReadStringPiece(&start_ip_address_bytes,
+                                    address_family == 4
+                                        ? QuicheIpAddress::kIPv4AddressSize
+                                        : QuicheIpAddress::kIPv6AddressSize)) {
+          return absl::InvalidArgumentError(
+              "Unable to read capsule ROUTE_ADVERTISEMENT start address");
+        }
+        if (!ip_address_range.start_ip_address.FromPackedString(
+                start_ip_address_bytes.data(), start_ip_address_bytes.size())) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT start address");
+        }
+        absl::string_view end_ip_address_bytes;
+        if (!reader.ReadStringPiece(&end_ip_address_bytes,
+                                    address_family == 4
+                                        ? QuicheIpAddress::kIPv4AddressSize
+                                        : QuicheIpAddress::kIPv6AddressSize)) {
+          return absl::InvalidArgumentError(
+              "Unable to read capsule ROUTE_ADVERTISEMENT end address");
+        }
+        if (!ip_address_range.end_ip_address.FromPackedString(
+                end_ip_address_bytes.data(), end_ip_address_bytes.size())) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT end address");
+        }
+        if (!reader.ReadUInt8(&ip_address_range.ip_protocol)) {
+          return absl::InvalidArgumentError(
+              "Unable to parse capsule ROUTE_ADVERTISEMENT IP protocol");
+        }
+        capsule.ip_address_ranges.push_back(ip_address_range);
+      }
+      return Capsule(std::move(capsule));
+    }
+    default:
+      return Capsule(UnknownCapsule{static_cast<uint64_t>(type),
+                                    reader.ReadRemainingPayload()});
+  }
+}
+
+absl::StatusOr<size_t> CapsuleParser::AttemptParseCapsule() {
   QUICHE_DCHECK(!parsing_error_occurred_);
   if (buffered_data_.empty()) {
     return 0;
@@ -501,190 +490,16 @@
     return 0;
   }
   QuicheDataReader capsule_data_reader(capsule_data);
-  Capsule capsule(static_cast<CapsuleType>(capsule_type64));
-  switch (capsule.capsule_type()) {
-    case CapsuleType::DATAGRAM:
-      capsule.datagram_capsule().http_datagram_payload =
-          capsule_data_reader.ReadRemainingPayload();
-      break;
-    case CapsuleType::LEGACY_DATAGRAM:
-      capsule.legacy_datagram_capsule().http_datagram_payload =
-          capsule_data_reader.ReadRemainingPayload();
-      break;
-    case CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT:
-      capsule.legacy_datagram_without_context_capsule().http_datagram_payload =
-          capsule_data_reader.ReadRemainingPayload();
-      break;
-    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
-      if (!capsule_data_reader.ReadUInt32(
-              &capsule.close_web_transport_session_capsule().error_code)) {
-        ReportParseFailure(
-            "Unable to parse capsule CLOSE_WEBTRANSPORT_SESSION error code");
-        return 0;
-      }
-      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
-                                       ? QuicheIpAddress::kIPv4AddressSize
-                                       : QuicheIpAddress::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
-                                       ? QuicheIpAddress::kIPv4AddressSize
-                                       : QuicheIpAddress::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 ? QuicheIpAddress::kIPv4AddressSize
-                                    : QuicheIpAddress::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 ? QuicheIpAddress::kIPv4AddressSize
-                                    : QuicheIpAddress::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();
-  }
-  if (!visitor_->OnCapsule(capsule)) {
-    ReportParseFailure("Visitor failed to process capsule");
-    return 0;
+  absl::StatusOr<Capsule> capsule = ParseCapsulePayload(
+      capsule_data_reader, static_cast<CapsuleType>(capsule_type64));
+  QUICHE_RETURN_IF_ERROR(capsule.status());
+  if (!visitor_->OnCapsule(*capsule)) {
+    return absl::AbortedError("Visitor failed to process capsule");
   }
   return capsule_fragment_reader.PreviouslyReadPayload().length();
 }
 
-void CapsuleParser::ReportParseFailure(const std::string& error_message) {
+void CapsuleParser::ReportParseFailure(absl::string_view error_message) {
   if (parsing_error_occurred_) {
     QUICHE_BUG(multiple parse errors) << "Experienced multiple parse failures";
     return;
diff --git a/quiche/common/capsule.h b/quiche/common/capsule.h
index 85292c4..52c7ef5 100644
--- a/quiche/common/capsule.h
+++ b/quiche/common/capsule.h
@@ -7,10 +7,13 @@
 
 #include <cstdint>
 #include <string>
+#include <variant>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_ip_address.h"
@@ -37,21 +40,50 @@
 
 struct QUICHE_EXPORT DatagramCapsule {
   absl::string_view http_datagram_payload;
+
   std::string ToString() const;
+  CapsuleType capsule_type() const { return CapsuleType::DATAGRAM; }
+  bool operator==(const DatagramCapsule& other) const {
+    return http_datagram_payload == other.http_datagram_payload;
+  }
 };
+
 struct QUICHE_EXPORT LegacyDatagramCapsule {
   absl::string_view http_datagram_payload;
+
   std::string ToString() const;
+  CapsuleType capsule_type() const { return CapsuleType::LEGACY_DATAGRAM; }
+  bool operator==(const LegacyDatagramCapsule& other) const {
+    return http_datagram_payload == other.http_datagram_payload;
+  }
 };
+
 struct QUICHE_EXPORT LegacyDatagramWithoutContextCapsule {
   absl::string_view http_datagram_payload;
+
   std::string ToString() const;
+  CapsuleType capsule_type() const {
+    return CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT;
+  }
+  bool operator==(const LegacyDatagramWithoutContextCapsule& other) const {
+    return http_datagram_payload == other.http_datagram_payload;
+  }
 };
+
 struct QUICHE_EXPORT CloseWebTransportSessionCapsule {
   webtransport::SessionErrorCode error_code;
   absl::string_view error_message;
+
   std::string ToString() const;
+  CapsuleType capsule_type() const {
+    return CapsuleType::CLOSE_WEBTRANSPORT_SESSION;
+  }
+  bool operator==(const CloseWebTransportSessionCapsule& other) const {
+    return error_code == other.error_code &&
+           error_message == other.error_message;
+  }
 };
+
 struct QUICHE_EXPORT PrefixWithId {
   uint64_t request_id;
   quiche::QuicheIpPrefix ip_prefix;
@@ -63,20 +95,34 @@
   uint8_t ip_protocol;
   bool operator==(const IpAddressRange& other) const;
 };
+
 struct QUICHE_EXPORT AddressAssignCapsule {
   std::vector<PrefixWithId> assigned_addresses;
   bool operator==(const AddressAssignCapsule& other) const;
   std::string ToString() const;
+  CapsuleType capsule_type() const { return CapsuleType::ADDRESS_ASSIGN; }
 };
 struct QUICHE_EXPORT AddressRequestCapsule {
   std::vector<PrefixWithId> requested_addresses;
   bool operator==(const AddressRequestCapsule& other) const;
   std::string ToString() const;
+  CapsuleType capsule_type() const { return CapsuleType::ADDRESS_REQUEST; }
 };
 struct QUICHE_EXPORT RouteAdvertisementCapsule {
   std::vector<IpAddressRange> ip_address_ranges;
   bool operator==(const RouteAdvertisementCapsule& other) const;
   std::string ToString() const;
+  CapsuleType capsule_type() const { return CapsuleType::ROUTE_ADVERTISEMENT; }
+};
+struct QUICHE_EXPORT UnknownCapsule {
+  uint64_t type;
+  absl::string_view payload;
+
+  std::string ToString() const;
+  CapsuleType capsule_type() const { return static_cast<CapsuleType>(type); }
+  bool operator==(const UnknownCapsule& other) const {
+    return type == other.type && payload == other.payload;
+  }
 };
 
 // Capsule from RFC 9297.
@@ -102,10 +148,8 @@
       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);
+  template <typename CapsuleStruct>
+  explicit Capsule(CapsuleStruct capsule) : capsule_(std::move(capsule)) {}
   bool operator==(const Capsule& other) const;
 
   // Human-readable information string for debugging purposes.
@@ -113,107 +157,68 @@
   friend QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
                                                 const Capsule& capsule);
 
-  CapsuleType capsule_type() const { return capsule_type_; }
+  CapsuleType capsule_type() const {
+    return absl::visit(
+        [](const auto& capsule) { return capsule.capsule_type(); }, capsule_);
+  }
   DatagramCapsule& datagram_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM);
-    return datagram_capsule_;
+    return absl::get<DatagramCapsule>(capsule_);
   }
   const DatagramCapsule& datagram_capsule() const {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM);
-    return datagram_capsule_;
+    return absl::get<DatagramCapsule>(capsule_);
   }
   LegacyDatagramCapsule& legacy_datagram_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::LEGACY_DATAGRAM);
-    return legacy_datagram_capsule_;
+    return absl::get<LegacyDatagramCapsule>(capsule_);
   }
   const LegacyDatagramCapsule& legacy_datagram_capsule() const {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::LEGACY_DATAGRAM);
-    return legacy_datagram_capsule_;
+    return absl::get<LegacyDatagramCapsule>(capsule_);
   }
   LegacyDatagramWithoutContextCapsule&
   legacy_datagram_without_context_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_,
-                     CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT);
-    return legacy_datagram_without_context_capsule_;
+    return absl::get<LegacyDatagramWithoutContextCapsule>(capsule_);
   }
   const LegacyDatagramWithoutContextCapsule&
   legacy_datagram_without_context_capsule() const {
-    QUICHE_DCHECK_EQ(capsule_type_,
-                     CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT);
-    return legacy_datagram_without_context_capsule_;
+    return absl::get<LegacyDatagramWithoutContextCapsule>(capsule_);
   }
   CloseWebTransportSessionCapsule& close_web_transport_session_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::CLOSE_WEBTRANSPORT_SESSION);
-    return close_web_transport_session_capsule_;
+    return absl::get<CloseWebTransportSessionCapsule>(capsule_);
   }
   const CloseWebTransportSessionCapsule& close_web_transport_session_capsule()
       const {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::CLOSE_WEBTRANSPORT_SESSION);
-    return close_web_transport_session_capsule_;
+    return absl::get<CloseWebTransportSessionCapsule>(capsule_);
   }
   AddressRequestCapsule& address_request_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_REQUEST);
-    return *address_request_capsule_;
+    return absl::get<AddressRequestCapsule>(capsule_);
   }
   const AddressRequestCapsule& address_request_capsule() const {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_REQUEST);
-    return *address_request_capsule_;
+    return absl::get<AddressRequestCapsule>(capsule_);
   }
   AddressAssignCapsule& address_assign_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_ASSIGN);
-    return *address_assign_capsule_;
+    return absl::get<AddressAssignCapsule>(capsule_);
   }
   const AddressAssignCapsule& address_assign_capsule() const {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ADDRESS_ASSIGN);
-    return *address_assign_capsule_;
+    return absl::get<AddressAssignCapsule>(capsule_);
   }
   RouteAdvertisementCapsule& route_advertisement_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ROUTE_ADVERTISEMENT);
-    return *route_advertisement_capsule_;
+    return absl::get<RouteAdvertisementCapsule>(capsule_);
   }
   const RouteAdvertisementCapsule& route_advertisement_capsule() const {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::ROUTE_ADVERTISEMENT);
-    return *route_advertisement_capsule_;
+    return absl::get<RouteAdvertisementCapsule>(capsule_);
   }
-  absl::string_view& unknown_capsule_data() {
-    QUICHE_DCHECK(capsule_type_ != CapsuleType::DATAGRAM &&
-                  capsule_type_ != CapsuleType::LEGACY_DATAGRAM &&
-                  capsule_type_ !=
-                      CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT &&
-                  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_;
+  UnknownCapsule& unknown_capsule() {
+    return absl::get<UnknownCapsule>(capsule_);
   }
-  const absl::string_view& unknown_capsule_data() const {
-    QUICHE_DCHECK(capsule_type_ != CapsuleType::DATAGRAM &&
-                  capsule_type_ != CapsuleType::LEGACY_DATAGRAM &&
-                  capsule_type_ !=
-                      CapsuleType::LEGACY_DATAGRAM_WITHOUT_CONTEXT &&
-                  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 UnknownCapsule& unknown_capsule() const {
+    return absl::get<UnknownCapsule>(capsule_);
   }
 
  private:
-  void Free();
-  CapsuleType capsule_type_;
-  union {
-    DatagramCapsule datagram_capsule_;
-    LegacyDatagramCapsule legacy_datagram_capsule_;
-    LegacyDatagramWithoutContextCapsule
-        legacy_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_;
-  };
+  absl::variant<DatagramCapsule, LegacyDatagramCapsule,
+                LegacyDatagramWithoutContextCapsule,
+                CloseWebTransportSessionCapsule, AddressRequestCapsule,
+                AddressAssignCapsule, RouteAdvertisementCapsule, UnknownCapsule>
+      capsule_;
 };
 
 namespace test {
@@ -235,7 +240,7 @@
     // MUST make a deep copy before this returns.
     virtual bool OnCapsule(const Capsule& capsule) = 0;
 
-    virtual void OnCapsuleParseFailure(const std::string& error_message) = 0;
+    virtual void OnCapsuleParseFailure(absl::string_view error_message) = 0;
   };
 
   // |visitor| must be non-null, and must outlive CapsuleParser.
@@ -252,10 +257,10 @@
 
  private:
   // Attempts to parse a single capsule from |buffered_data_|. If a full capsule
-  // is not available, returns 0. If a parsing error occurs, returns 0.
+  // is not available, returns 0. If a parsing error occurs, returns an error.
   // Otherwise, returns the number of bytes in the parsed capsule.
-  size_t AttemptParseCapsule();
-  void ReportParseFailure(const std::string& error_message);
+  absl::StatusOr<size_t> AttemptParseCapsule();
+  void ReportParseFailure(absl::string_view error_message);
 
   // Whether a parsing error has occurred.
   bool parsing_error_occurred_ = false;
diff --git a/quiche/common/capsule_test.cc b/quiche/common/capsule_test.cc
index 23d7533..dde2ea7 100644
--- a/quiche/common/capsule_test.cc
+++ b/quiche/common/capsule_test.cc
@@ -39,7 +39,7 @@
   }
   ~MockCapsuleParserVisitor() override = default;
   MOCK_METHOD(bool, OnCapsule, (const Capsule& capsule), (override));
-  MOCK_METHOD(void, OnCapsuleParseFailure, (const std::string& error_message),
+  MOCK_METHOD(void, OnCapsuleParseFailure, (absl::string_view error_message),
               (override));
 };
 
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index 90e5341..fae3ce8 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -1393,7 +1393,7 @@
   return true;
 }
 
-void QuicSpdyStream::OnCapsuleParseFailure(const std::string& error_message) {
+void QuicSpdyStream::OnCapsuleParseFailure(absl::string_view error_message) {
   QUIC_DLOG(ERROR) << ENDPOINT << "Capsule parse failure: " << error_message;
   Reset(QUIC_BAD_APPLICATION_PAYLOAD);
 }
diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h
index 887facb..e59afd5 100644
--- a/quiche/quic/core/http/quic_spdy_stream.h
+++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -257,7 +257,7 @@
 
   // From CapsuleParser::Visitor.
   bool OnCapsule(const quiche::Capsule& capsule) override;
-  void OnCapsuleParseFailure(const std::string& error_message) override;
+  void OnCapsuleParseFailure(absl::string_view error_message) override;
 
   // Sends an HTTP/3 datagram. The stream ID is not part of |payload|. Virtual
   // to allow mocking in tests.