diff --git a/quic/core/http/capsule.cc b/quic/core/http/capsule.cc
index c811bb8..21df166 100644
--- a/quic/core/http/capsule.cc
+++ b/quic/core/http/capsule.cc
@@ -24,8 +24,12 @@
       return "REGISTER_DATAGRAM_CONTEXT";
     case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
       return "CLOSE_DATAGRAM_CONTEXT";
-    case CapsuleType::DATAGRAM:
-      return "DATAGRAM";
+    case CapsuleType::LEGACY_DATAGRAM:
+      return "LEGACY_DATAGRAM";
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      return "DATAGRAM_WITH_CONTEXT";
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+      return "DATAGRAM_WITHOUT_CONTEXT";
     case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
       return "REGISTER_DATAGRAM_NO_CONTEXT";
     case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
@@ -80,11 +84,27 @@
 
 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 capsule structs must have these properties");
-      datagram_capsule_ = DatagramCapsule();
+    case CapsuleType::LEGACY_DATAGRAM:
+      static_assert(
+          std::is_standard_layout<LegacyDatagramCapsule>::value &&
+              std::is_trivially_destructible<LegacyDatagramCapsule>::value,
+          "All capsule structs must have these properties");
+      legacy_datagram_capsule_ = LegacyDatagramCapsule();
+      break;
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      static_assert(
+          std::is_standard_layout<DatagramWithContextCapsule>::value &&
+              std::is_trivially_destructible<DatagramWithContextCapsule>::value,
+          "All capsule structs must have these properties");
+      datagram_with_context_capsule_ = DatagramWithContextCapsule();
+      break;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+      static_assert(
+          std::is_standard_layout<DatagramWithoutContextCapsule>::value &&
+              std::is_trivially_destructible<
+                  DatagramWithoutContextCapsule>::value,
+          "All capsule structs must have these properties");
+      datagram_without_context_capsule_ = DatagramWithoutContextCapsule();
       break;
     case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
       static_assert(
@@ -126,11 +146,32 @@
 }
 
 // static
-Capsule Capsule::Datagram(absl::optional<QuicDatagramContextId> context_id,
-                          absl::string_view http_datagram_payload) {
-  Capsule capsule(CapsuleType::DATAGRAM);
-  capsule.datagram_capsule().context_id = context_id;
-  capsule.datagram_capsule().http_datagram_payload = http_datagram_payload;
+Capsule Capsule::LegacyDatagram(
+    absl::optional<QuicDatagramContextId> context_id,
+    absl::string_view http_datagram_payload) {
+  Capsule capsule(CapsuleType::LEGACY_DATAGRAM);
+  capsule.legacy_datagram_capsule().context_id = context_id;
+  capsule.legacy_datagram_capsule().http_datagram_payload =
+      http_datagram_payload;
+  return capsule;
+}
+
+// static
+Capsule Capsule::DatagramWithContext(QuicDatagramContextId context_id,
+                                     absl::string_view http_datagram_payload) {
+  Capsule capsule(CapsuleType::DATAGRAM_WITH_CONTEXT);
+  capsule.datagram_with_context_capsule().context_id = context_id;
+  capsule.datagram_with_context_capsule().http_datagram_payload =
+      http_datagram_payload;
+  return capsule;
+}
+
+// static
+Capsule Capsule::DatagramWithoutContext(
+    absl::string_view http_datagram_payload) {
+  Capsule capsule(CapsuleType::DATAGRAM_WITHOUT_CONTEXT);
+  capsule.datagram_without_context_capsule().http_datagram_payload =
+      http_datagram_payload;
   return capsule;
 }
 
@@ -187,8 +228,15 @@
 Capsule& Capsule::operator=(const Capsule& other) {
   capsule_type_ = other.capsule_type_;
   switch (capsule_type_) {
-    case CapsuleType::DATAGRAM:
-      datagram_capsule_ = other.datagram_capsule_;
+    case CapsuleType::LEGACY_DATAGRAM:
+      legacy_datagram_capsule_ = other.legacy_datagram_capsule_;
+      break;
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      datagram_with_context_capsule_ = other.datagram_with_context_capsule_;
+      break;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+      datagram_without_context_capsule_ =
+          other.datagram_without_context_capsule_;
       break;
     case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
       register_datagram_context_capsule_ =
@@ -221,11 +269,19 @@
     return false;
   }
   switch (capsule_type_) {
-    case CapsuleType::DATAGRAM:
-      return datagram_capsule_.context_id ==
-                 other.datagram_capsule_.context_id &&
-             datagram_capsule_.http_datagram_payload ==
-                 other.datagram_capsule_.http_datagram_payload;
+    case CapsuleType::LEGACY_DATAGRAM:
+      return legacy_datagram_capsule_.context_id ==
+                 other.legacy_datagram_capsule_.context_id &&
+             legacy_datagram_capsule_.http_datagram_payload ==
+                 other.legacy_datagram_capsule_.http_datagram_payload;
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      return datagram_with_context_capsule_.context_id ==
+                 other.datagram_with_context_capsule_.context_id &&
+             datagram_with_context_capsule_.http_datagram_payload ==
+                 other.datagram_with_context_capsule_.http_datagram_payload;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+      return datagram_without_context_capsule_.http_datagram_payload ==
+             other.datagram_without_context_capsule_.http_datagram_payload;
     case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
       return register_datagram_context_capsule_.context_id ==
                  other.register_datagram_context_capsule_.context_id &&
@@ -260,13 +316,28 @@
 std::string Capsule::ToString() const {
   std::string rv = CapsuleTypeToString(capsule_type_);
   switch (capsule_type_) {
-    case CapsuleType::DATAGRAM:
-      if (datagram_capsule_.context_id.has_value()) {
-        absl::StrAppend(&rv, "(", datagram_capsule_.context_id.value(), ")");
+    case CapsuleType::LEGACY_DATAGRAM:
+      if (legacy_datagram_capsule_.context_id.has_value()) {
+        absl::StrAppend(&rv, "(", legacy_datagram_capsule_.context_id.value(),
+                        ")");
       }
+      absl::StrAppend(&rv, "[",
+                      absl::BytesToHexString(
+                          legacy_datagram_capsule_.http_datagram_payload),
+                      "]");
+      break;
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      absl::StrAppend(&rv, "(", datagram_with_context_capsule_.context_id, ")[",
+                      absl::BytesToHexString(
+                          datagram_with_context_capsule_.http_datagram_payload),
+                      "]");
+      break;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
       absl::StrAppend(
           &rv, "[",
-          absl::BytesToHexString(datagram_capsule_.http_datagram_payload), "]");
+          absl::BytesToHexString(
+              datagram_without_context_capsule_.http_datagram_payload),
+          "]");
       break;
     case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
       absl::StrAppend(
@@ -327,14 +398,25 @@
       static_cast<uint64_t>(capsule.capsule_type()));
   QuicByteCount capsule_data_length;
   switch (capsule.capsule_type()) {
-    case CapsuleType::DATAGRAM:
+    case CapsuleType::LEGACY_DATAGRAM:
       capsule_data_length =
-          capsule.datagram_capsule().http_datagram_payload.length();
-      if (capsule.datagram_capsule().context_id.has_value()) {
+          capsule.legacy_datagram_capsule().http_datagram_payload.length();
+      if (capsule.legacy_datagram_capsule().context_id.has_value()) {
         capsule_data_length += QuicDataWriter::GetVarInt62Len(
-            capsule.datagram_capsule().context_id.value());
+            capsule.legacy_datagram_capsule().context_id.value());
       }
       break;
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      capsule_data_length =
+          QuicDataWriter::GetVarInt62Len(
+              capsule.datagram_with_context_capsule().context_id) +
+          capsule.datagram_with_context_capsule()
+              .http_datagram_payload.length();
+      break;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+      capsule_data_length = capsule.datagram_without_context_capsule()
+                                .http_datagram_payload.length();
+      break;
     case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
       capsule_data_length =
           QuicDataWriter::GetVarInt62Len(
@@ -383,19 +465,41 @@
     return QuicBuffer();
   }
   switch (capsule.capsule_type()) {
-    case CapsuleType::DATAGRAM:
-      if (capsule.datagram_capsule().context_id.has_value()) {
+    case CapsuleType::LEGACY_DATAGRAM:
+      if (capsule.legacy_datagram_capsule().context_id.has_value()) {
         if (!writer.WriteVarInt62(
-                capsule.datagram_capsule().context_id.value())) {
+                capsule.legacy_datagram_capsule().context_id.value())) {
           QUIC_BUG(datagram capsule context ID write fail)
-              << "Failed to write DATAGRAM CAPSULE context ID";
+              << "Failed to write LEGACY_DATAGRAM CAPSULE context ID";
           return QuicBuffer();
         }
       }
       if (!writer.WriteStringPiece(
-              capsule.datagram_capsule().http_datagram_payload)) {
+              capsule.legacy_datagram_capsule().http_datagram_payload)) {
         QUIC_BUG(datagram capsule payload write fail)
-            << "Failed to write DATAGRAM CAPSULE payload";
+            << "Failed to write LEGACY_DATAGRAM CAPSULE payload";
+        return QuicBuffer();
+      }
+      break;
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      if (!writer.WriteVarInt62(
+              capsule.datagram_with_context_capsule().context_id)) {
+        QUIC_BUG(datagram capsule context ID write fail)
+            << "Failed to write DATAGRAM_WITH_CONTEXT CAPSULE context ID";
+        return QuicBuffer();
+      }
+      if (!writer.WriteStringPiece(
+              capsule.datagram_with_context_capsule().http_datagram_payload)) {
+        QUIC_BUG(datagram capsule payload write fail)
+            << "Failed to write DATAGRAM_WITH_CONTEXT CAPSULE payload";
+        return QuicBuffer();
+      }
+      break;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+      if (!writer.WriteStringPiece(capsule.datagram_without_context_capsule()
+                                       .http_datagram_payload)) {
+        QUIC_BUG(datagram capsule payload write fail)
+            << "Failed to write DATAGRAM_WITHOUT_CONTEXT CAPSULE payload";
         return QuicBuffer();
       }
       break;
@@ -533,16 +637,32 @@
   QuicDataReader capsule_data_reader(capsule_data);
   Capsule capsule(static_cast<CapsuleType>(capsule_type64));
   switch (capsule.capsule_type()) {
-    case CapsuleType::DATAGRAM:
+    case CapsuleType::LEGACY_DATAGRAM:
       if (datagram_context_id_present_) {
         uint64_t context_id;
         if (!capsule_data_reader.ReadVarInt62(&context_id)) {
-          ReportParseFailure("Unable to parse capsule DATAGRAM context ID");
+          ReportParseFailure(
+              "Unable to parse capsule LEGACY_DATAGRAM context ID");
           return 0;
         }
-        capsule.datagram_capsule().context_id = context_id;
+        capsule.legacy_datagram_capsule().context_id = context_id;
       }
-      capsule.datagram_capsule().http_datagram_payload =
+      capsule.legacy_datagram_capsule().http_datagram_payload =
+          capsule_data_reader.ReadRemainingPayload();
+      break;
+    case CapsuleType::DATAGRAM_WITH_CONTEXT:
+      uint64_t context_id;
+      if (!capsule_data_reader.ReadVarInt62(&context_id)) {
+        ReportParseFailure(
+            "Unable to parse capsule DATAGRAM_WITH_CONTEXT context ID");
+        return 0;
+      }
+      capsule.datagram_with_context_capsule().context_id = context_id;
+      capsule.datagram_with_context_capsule().http_datagram_payload =
+          capsule_data_reader.ReadRemainingPayload();
+      break;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT:
+      capsule.datagram_without_context_capsule().http_datagram_payload =
           capsule_data_reader.ReadRemainingPayload();
       break;
     case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
diff --git a/quic/core/http/capsule.h b/quic/core/http/capsule.h
index 5198b46..42190bb 100644
--- a/quic/core/http/capsule.h
+++ b/quic/core/http/capsule.h
@@ -20,10 +20,12 @@
 
 enum class CapsuleType : uint64_t {
   // Casing in this enum matches the IETF specification.
-  DATAGRAM = 0xff37a0,
+  LEGACY_DATAGRAM = 0xff37a0,  // draft-ietf-masque-h3-datagram-04
   REGISTER_DATAGRAM_CONTEXT = 0xff37a1,
   REGISTER_DATAGRAM_NO_CONTEXT = 0xff37a2,
   CLOSE_DATAGRAM_CONTEXT = 0xff37a3,
+  DATAGRAM_WITH_CONTEXT = 0xff37a4,
+  DATAGRAM_WITHOUT_CONTEXT = 0xff37a5,
   CLOSE_WEBTRANSPORT_SESSION = 0x2843,
 };
 
@@ -55,10 +57,17 @@
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(
     std::ostream& os, const ContextCloseCode& context_close_code);
 
-struct QUIC_EXPORT_PRIVATE DatagramCapsule {
+struct QUIC_EXPORT_PRIVATE LegacyDatagramCapsule {
   absl::optional<QuicDatagramContextId> context_id;
   absl::string_view http_datagram_payload;
 };
+struct QUIC_EXPORT_PRIVATE DatagramWithContextCapsule {
+  QuicDatagramContextId context_id;
+  absl::string_view http_datagram_payload;
+};
+struct QUIC_EXPORT_PRIVATE DatagramWithoutContextCapsule {
+  absl::string_view http_datagram_payload;
+};
 struct QUIC_EXPORT_PRIVATE RegisterDatagramContextCapsule {
   QuicDatagramContextId context_id;
   DatagramFormatType format_type;
@@ -85,9 +94,14 @@
 // or perform its own deep copy.
 class QUIC_EXPORT_PRIVATE Capsule {
  public:
-  static Capsule Datagram(
+  static Capsule LegacyDatagram(
       absl::optional<QuicDatagramContextId> context_id = absl::nullopt,
       absl::string_view http_datagram_payload = absl::string_view());
+  static Capsule DatagramWithContext(
+      QuicDatagramContextId context_id,
+      absl::string_view http_datagram_payload = absl::string_view());
+  static Capsule DatagramWithoutContext(
+      absl::string_view http_datagram_payload = absl::string_view());
   static Capsule RegisterDatagramContext(
       QuicDatagramContextId context_id, DatagramFormatType format_type,
       absl::string_view format_additional_data = absl::string_view());
@@ -116,13 +130,30 @@
                                                       const Capsule& capsule);
 
   CapsuleType capsule_type() const { return capsule_type_; }
-  DatagramCapsule& datagram_capsule() {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM);
-    return datagram_capsule_;
+  LegacyDatagramCapsule& legacy_datagram_capsule() {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::LEGACY_DATAGRAM);
+    return legacy_datagram_capsule_;
   }
-  const DatagramCapsule& datagram_capsule() const {
-    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM);
-    return datagram_capsule_;
+  const LegacyDatagramCapsule& legacy_datagram_capsule() const {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::LEGACY_DATAGRAM);
+    return legacy_datagram_capsule_;
+  }
+  DatagramWithContextCapsule& datagram_with_context_capsule() {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM_WITH_CONTEXT);
+    return datagram_with_context_capsule_;
+  }
+  const DatagramWithContextCapsule& datagram_with_context_capsule() const {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM_WITH_CONTEXT);
+    return datagram_with_context_capsule_;
+  }
+  DatagramWithoutContextCapsule& datagram_without_context_capsule() {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM_WITHOUT_CONTEXT);
+    return datagram_without_context_capsule_;
+  }
+  const DatagramWithoutContextCapsule& datagram_without_context_capsule()
+      const {
+    QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::DATAGRAM_WITHOUT_CONTEXT);
+    return datagram_without_context_capsule_;
   }
   RegisterDatagramContextCapsule& register_datagram_context_capsule() {
     QUICHE_DCHECK_EQ(capsule_type_, CapsuleType::REGISTER_DATAGRAM_CONTEXT);
@@ -160,7 +191,9 @@
     return close_web_transport_session_capsule_;
   }
   absl::string_view& unknown_capsule_data() {
-    QUICHE_DCHECK(capsule_type_ != CapsuleType::DATAGRAM &&
+    QUICHE_DCHECK(capsule_type_ != CapsuleType::LEGACY_DATAGRAM &&
+                  capsule_type_ != CapsuleType::DATAGRAM_WITH_CONTEXT &&
+                  capsule_type_ != CapsuleType::DATAGRAM_WITHOUT_CONTEXT &&
                   capsule_type_ != CapsuleType::REGISTER_DATAGRAM_CONTEXT &&
                   capsule_type_ != CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT &&
                   capsule_type_ != CapsuleType::CLOSE_DATAGRAM_CONTEXT &&
@@ -169,7 +202,9 @@
     return unknown_capsule_data_;
   }
   const absl::string_view& unknown_capsule_data() const {
-    QUICHE_DCHECK(capsule_type_ != CapsuleType::DATAGRAM &&
+    QUICHE_DCHECK(capsule_type_ != CapsuleType::LEGACY_DATAGRAM &&
+                  capsule_type_ != CapsuleType::DATAGRAM_WITH_CONTEXT &&
+                  capsule_type_ != CapsuleType::DATAGRAM_WITHOUT_CONTEXT &&
                   capsule_type_ != CapsuleType::REGISTER_DATAGRAM_CONTEXT &&
                   capsule_type_ != CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT &&
                   capsule_type_ != CapsuleType::CLOSE_DATAGRAM_CONTEXT &&
@@ -181,7 +216,9 @@
  private:
   CapsuleType capsule_type_;
   union {
-    DatagramCapsule datagram_capsule_;
+    LegacyDatagramCapsule legacy_datagram_capsule_;
+    DatagramWithContextCapsule datagram_with_context_capsule_;
+    DatagramWithoutContextCapsule datagram_without_context_capsule_;
     RegisterDatagramContextCapsule register_datagram_context_capsule_;
     RegisterDatagramNoContextCapsule register_datagram_no_context_capsule_;
     CloseDatagramContextCapsule close_datagram_context_capsule_;
diff --git a/quic/core/http/capsule_test.cc b/quic/core/http/capsule_test.cc
index 66cb3d0..2dfdef4 100644
--- a/quic/core/http/capsule_test.cc
+++ b/quic/core/http/capsule_test.cc
@@ -72,15 +72,15 @@
   CapsuleParser capsule_parser_;
 };
 
-TEST_F(CapsuleTest, DatagramCapsule) {
+TEST_F(CapsuleTest, LegacyDatagramCapsule) {
   std::string capsule_fragment = absl::HexStringToBytes(
-      "80ff37a0"          // DATAGRAM capsule type
+      "80ff37a0"          // LEGACY_DATAGRAM capsule type
       "08"                // capsule length
       "a1a2a3a4a5a6a7a8"  // HTTP Datagram payload
   );
   std::string datagram_payload = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
   Capsule expected_capsule =
-      Capsule::Datagram(/*context_id=*/absl::nullopt, datagram_payload);
+      Capsule::LegacyDatagram(/*context_id=*/absl::nullopt, datagram_payload);
   {
     EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
     ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));
@@ -89,9 +89,9 @@
   TestSerialization(expected_capsule, capsule_fragment);
 }
 
-TEST_F(CapsuleTest, DatagramCapsuleWithContext) {
+TEST_F(CapsuleTest, LegacyDatagramCapsuleWithContext) {
   std::string capsule_fragment = absl::HexStringToBytes(
-      "80ff37a0"          // DATAGRAM capsule type
+      "80ff37a0"          // LEGACY_DATAGRAM capsule type
       "09"                // capsule length
       "04"                // context ID
       "a1a2a3a4a5a6a7a8"  // HTTP Datagram payload
@@ -99,7 +99,41 @@
   capsule_parser_.set_datagram_context_id_present(true);
   std::string datagram_payload = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
   Capsule expected_capsule =
-      Capsule::Datagram(/*context_id=*/4, datagram_payload);
+      Capsule::LegacyDatagram(/*context_id=*/4, datagram_payload);
+  {
+    EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
+    ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));
+  }
+  ValidateParserIsEmpty();
+  TestSerialization(expected_capsule, capsule_fragment);
+}
+
+TEST_F(CapsuleTest, DatagramWithoutContextCapsule) {
+  std::string capsule_fragment = absl::HexStringToBytes(
+      "80ff37a5"          // DATAGRAM_WITHOUT_CONTEXT capsule type
+      "08"                // capsule length
+      "a1a2a3a4a5a6a7a8"  // HTTP Datagram payload
+  );
+  std::string datagram_payload = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
+  Capsule expected_capsule = Capsule::DatagramWithoutContext(datagram_payload);
+  {
+    EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
+    ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));
+  }
+  ValidateParserIsEmpty();
+  TestSerialization(expected_capsule, capsule_fragment);
+}
+
+TEST_F(CapsuleTest, DatagramWithContextCapsule) {
+  std::string capsule_fragment = absl::HexStringToBytes(
+      "80ff37a4"          // DATAGRAM_WITH_CONTEXT capsule type
+      "09"                // capsule length
+      "04"                // context ID
+      "a1a2a3a4a5a6a7a8"  // HTTP Datagram payload
+  );
+  std::string datagram_payload = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
+  Capsule expected_capsule =
+      Capsule::DatagramWithContext(/*context_id=*/4, datagram_payload);
   {
     EXPECT_CALL(visitor_, OnCapsule(expected_capsule));
     ASSERT_TRUE(capsule_parser_.IngestCapsuleFragment(capsule_fragment));
@@ -199,21 +233,21 @@
   TestSerialization(expected_capsule, capsule_fragment);
 }
 
-TEST_F(CapsuleTest, TwoDatagramCapsules) {
+TEST_F(CapsuleTest, TwoCapsules) {
   std::string capsule_fragment = absl::HexStringToBytes(
-      "80ff37a0"          // DATAGRAM capsule type
+      "80ff37a5"          // DATAGRAM_WITHOUT_CONTEXT capsule type
       "08"                // capsule length
       "a1a2a3a4a5a6a7a8"  // HTTP Datagram payload
-      "80ff37a0"          // DATAGRAM capsule type
+      "80ff37a5"          // DATAGRAM_WITHOUT_CONTEXT capsule type
       "08"                // capsule length
       "b1b2b3b4b5b6b7b8"  // HTTP Datagram payload
   );
   std::string datagram_payload1 = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
   std::string datagram_payload2 = absl::HexStringToBytes("b1b2b3b4b5b6b7b8");
   Capsule expected_capsule1 =
-      Capsule::Datagram(/*context_id=*/absl::nullopt, datagram_payload1);
+      Capsule::DatagramWithoutContext(datagram_payload1);
   Capsule expected_capsule2 =
-      Capsule::Datagram(/*context_id=*/absl::nullopt, datagram_payload2);
+      Capsule::DatagramWithoutContext(datagram_payload2);
   {
     InSequence s;
     EXPECT_CALL(visitor_, OnCapsule(expected_capsule1));
@@ -223,15 +257,15 @@
   ValidateParserIsEmpty();
 }
 
-TEST_F(CapsuleTest, TwoDatagramCapsulesPartialReads) {
+TEST_F(CapsuleTest, TwoCapsulesPartialReads) {
   std::string capsule_fragment1 = absl::HexStringToBytes(
-      "80ff37a0"  // first capsule DATAGRAM capsule type
+      "80ff37a5"  // first capsule DATAGRAM_WITHOUT_CONTEXT capsule type
       "08"        // frist capsule length
       "a1a2a3a4"  // first half of HTTP Datagram payload of first capsule
   );
   std::string capsule_fragment2 = absl::HexStringToBytes(
       "a5a6a7a8"  // second half of HTTP Datagram payload 1
-      "80ff37a0"  // second capsule DATAGRAM capsule type
+      "80ff37a5"  // second capsule DATAGRAM_WITHOUT_CONTEXT capsule type
   );
   std::string capsule_fragment3 = absl::HexStringToBytes(
       "08"                // second capsule length
@@ -241,9 +275,9 @@
   std::string datagram_payload1 = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
   std::string datagram_payload2 = absl::HexStringToBytes("b1b2b3b4b5b6b7b8");
   Capsule expected_capsule1 =
-      Capsule::Datagram(/*context_id=*/absl::nullopt, datagram_payload1);
+      Capsule::DatagramWithoutContext(datagram_payload1);
   Capsule expected_capsule2 =
-      Capsule::Datagram(/*context_id=*/absl::nullopt, datagram_payload2);
+      Capsule::DatagramWithoutContext(datagram_payload2);
   {
     InSequence s;
     EXPECT_CALL(visitor_, OnCapsule(expected_capsule1));
@@ -255,21 +289,21 @@
   ValidateParserIsEmpty();
 }
 
-TEST_F(CapsuleTest, TwoDatagramCapsulesOneByteAtATime) {
+TEST_F(CapsuleTest, TwoCapsulesOneByteAtATime) {
   std::string capsule_fragment = absl::HexStringToBytes(
-      "80ff37a0"          // DATAGRAM capsule type
+      "80ff37a5"          // DATAGRAM_WITHOUT_CONTEXT capsule type
       "08"                // capsule length
       "a1a2a3a4a5a6a7a8"  // HTTP Datagram payload
-      "80ff37a0"          // DATAGRAM capsule type
+      "80ff37a5"          // DATAGRAM_WITHOUT_CONTEXT capsule type
       "08"                // capsule length
       "b1b2b3b4b5b6b7b8"  // HTTP Datagram payload
   );
   std::string datagram_payload1 = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
   std::string datagram_payload2 = absl::HexStringToBytes("b1b2b3b4b5b6b7b8");
   Capsule expected_capsule1 =
-      Capsule::Datagram(/*context_id=*/absl::nullopt, datagram_payload1);
+      Capsule::DatagramWithoutContext(datagram_payload1);
   Capsule expected_capsule2 =
-      Capsule::Datagram(/*context_id=*/absl::nullopt, datagram_payload2);
+      Capsule::DatagramWithoutContext(datagram_payload2);
   for (size_t i = 0; i < capsule_fragment.size(); i++) {
     if (i < capsule_fragment.size() / 2 - 1) {
       EXPECT_CALL(visitor_, OnCapsule(_)).Times(0);
@@ -297,7 +331,7 @@
 
 TEST_F(CapsuleTest, PartialCapsuleThenError) {
   std::string capsule_fragment = absl::HexStringToBytes(
-      "80ff37a0"  // DATAGRAM capsule type
+      "80ff37a5"  // DATAGRAM_WITHOUT_CONTEXT capsule type
       "08"        // capsule length
       "a1a2a3a4"  // first half of HTTP Datagram payload
   );
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 3b073af..5f8675d 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -54,6 +54,7 @@
 #include "quic/test_tools/quic_server_peer.h"
 #include "quic/test_tools/quic_session_peer.h"
 #include "quic/test_tools/quic_spdy_session_peer.h"
+#include "quic/test_tools/quic_spdy_stream_peer.h"
 #include "quic/test_tools/quic_stream_id_manager_peer.h"
 #include "quic/test_tools/quic_stream_peer.h"
 #include "quic/test_tools/quic_stream_sequencer_peer.h"
@@ -229,6 +230,7 @@
     client->UseClientConnectionIdLength(override_client_connection_id_length_);
     client->client()->set_connection_debug_visitor(connection_debug_visitor_);
     client->client()->set_enable_web_transport(enable_web_transport_);
+    client->client()->set_use_datagram_contexts(use_datagram_contexts_);
     client->Connect();
     return client;
   }
@@ -368,6 +370,9 @@
     if (enable_web_transport_) {
       memory_cache_backend_.set_enable_webtransport(true);
     }
+    if (use_datagram_contexts_) {
+      memory_cache_backend_.set_use_datagram_contexts(true);
+    }
 
     QuicTagVector copt;
     server_config_.SetConnectionOptionsToSend(copt);
@@ -689,8 +694,9 @@
     return WaitForFooResponseAndCheckIt(client_.get());
   }
 
-  WebTransportHttp3* CreateWebTransportSession(const std::string& path,
-                                               bool wait_for_server_response) {
+  WebTransportHttp3* CreateWebTransportSession(
+      const std::string& path, bool wait_for_server_response,
+      QuicSpdyStream** connect_stream_out = nullptr) {
     // Wait until we receive the settings from the server indicating
     // WebTransport support.
     client_->WaitUntil(
@@ -722,6 +728,9 @@
                          [stream]() { return stream->headers_decompressed(); });
       EXPECT_TRUE(session->ready());
     }
+    if (connect_stream_out != nullptr) {
+      *connect_stream_out = stream;
+    }
     return session;
   }
 
@@ -829,6 +838,7 @@
   int override_client_connection_id_length_ = -1;
   uint8_t expected_server_connection_id_length_;
   bool enable_web_transport_ = false;
+  bool use_datagram_contexts_ = false;
   std::vector<std::string> received_webtransport_unidirectional_streams_;
 };
 
@@ -6347,11 +6357,7 @@
 
   SimpleBufferAllocator allocator;
   for (int i = 0; i < 10; i++) {
-    absl::string_view datagram = "test";
-    auto buffer = MakeUniqueBuffer(&allocator, datagram.size());
-    memcpy(buffer.get(), datagram.data(), datagram.size());
-    QuicMemSlice slice(std::move(buffer), datagram.size());
-    session->SendOrQueueDatagram(std::move(slice));
+    session->SendOrQueueDatagram(MemSliceFromString("test"));
   }
 
   int received = 0;
@@ -6362,6 +6368,37 @@
   EXPECT_GT(received, 0);
 }
 
+TEST_P(EndToEndTest, WebTransportDatagramsWithContexts) {
+  enable_web_transport_ = true;
+  use_datagram_contexts_ = true;
+  SetPacketLossPercentage(30);
+  ASSERT_TRUE(Initialize());
+
+  if (!version_.UsesHttp3()) {
+    return;
+  }
+
+  QuicSpdyStream* connect_stream = nullptr;
+  WebTransportHttp3* session = CreateWebTransportSession(
+      "/echo", /*wait_for_server_response=*/true, &connect_stream);
+  ASSERT_TRUE(session != nullptr);
+  ASSERT_TRUE(connect_stream != nullptr);
+  NiceMock<MockClientVisitor>& visitor = SetupWebTransportVisitor(session);
+
+  SimpleBufferAllocator allocator;
+  for (int i = 0; i < 10; i++) {
+    session->SendOrQueueDatagram(MemSliceFromString("test"));
+  }
+
+  int received = 0;
+  EXPECT_CALL(visitor, OnDatagramReceived(_)).WillRepeatedly([&received]() {
+    received++;
+  });
+  client_->WaitUntil(5000, [&received]() { return received > 0; });
+  EXPECT_GT(received, 0);
+  EXPECT_TRUE(QuicSpdyStreamPeer::use_datagram_contexts(connect_stream));
+}
+
 TEST_P(EndToEndTest, WebTransportSessionClose) {
   enable_web_transport_ = true;
   ASSERT_TRUE(Initialize());
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 929e369..af54b06 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -875,6 +875,8 @@
 
 bool QuicSpdySession::ShouldNegotiateWebTransport() { return false; }
 
+bool QuicSpdySession::ShouldNegotiateDatagramContexts() { return false; }
+
 bool QuicSpdySession::WillNegotiateWebTransport() {
   return LocalHttpDatagramSupport() != HttpDatagramSupport::kNone &&
          version().UsesHttp3() && ShouldNegotiateWebTransport();
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index b84f5a1..9f95075 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -467,6 +467,10 @@
 
   QuicSpdyStream* GetOrCreateSpdyDataStream(const QuicStreamId stream_id);
 
+  // Indicates whether we will try to negotiate datagram contexts on newly
+  // created WebTransport sessions over HTTP/3.
+  virtual bool ShouldNegotiateDatagramContexts();
+
  protected:
   // Override CreateIncomingStream(), CreateOutgoingBidirectionalStream() and
   // CreateOutgoingUnidirectionalStream() with QuicSpdyStream return type to
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 284a180..55265de 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -248,6 +248,13 @@
 
 QuicSpdyStream::~QuicSpdyStream() {}
 
+bool QuicSpdyStream::ShouldUseDatagramContexts() const {
+  return spdy_session_->SupportsH3Datagram() &&
+         spdy_session_->http_datagram_support() !=
+             HttpDatagramSupport::kDraft00 &&
+         use_datagram_contexts_;
+}
+
 size_t QuicSpdyStream::WriteHeaders(
     SpdyHeaderBlock header_block, bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
@@ -275,6 +282,12 @@
 
   MaybeProcessSentWebTransportHeaders(header_block);
 
+  if (ShouldUseDatagramContexts()) {
+    // RegisterHttp3DatagramRegistrationVisitor caller wishes to use contexts,
+    // inform the peer.
+    header_block["sec-use-datagram-contexts"] = "?1";
+  }
+
   size_t bytes_written =
       WriteHeadersImpl(std::move(header_block), fin, std::move(ack_listener));
   if (!VersionUsesHttp3(transport_version()) && fin) {
@@ -621,6 +634,19 @@
   if (!GetQuicReloadableFlag(quic_verify_request_headers) ||
       !header_too_large) {
     MaybeProcessReceivedWebTransportHeaders();
+    if (ShouldUseDatagramContexts()) {
+      bool peer_wishes_to_use_datagram_contexts = false;
+      for (const auto& header : header_list_) {
+        if (header.first == "sec-use-datagram-contexts" &&
+            header.second == "?1") {
+          peer_wishes_to_use_datagram_contexts = true;
+          break;
+        }
+      }
+      if (!peer_wishes_to_use_datagram_contexts) {
+        use_datagram_contexts_ = false;
+      }
+    }
   }
 
   if (VersionUsesHttp3(transport_version())) {
@@ -1255,8 +1281,9 @@
     RegisterHttp3DatagramFlowId(*flow_id);
   }
 
-  web_transport_ =
-      std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
+  web_transport_ = std::make_unique<WebTransportHttp3>(
+      spdy_session_, this, id(),
+      spdy_session_->ShouldNegotiateDatagramContexts());
 
   if (spdy_session_->http_datagram_support() != HttpDatagramSupport::kDraft00) {
     return;
@@ -1293,8 +1320,9 @@
     headers["datagram-flow-id"] = absl::StrCat(id());
   }
 
-  web_transport_ =
-      std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
+  web_transport_ = std::make_unique<WebTransportHttp3>(
+      spdy_session_, this, id(),
+      spdy_session_->ShouldNegotiateDatagramContexts());
 }
 
 void QuicSpdyStream::OnCanWriteNewData() {
@@ -1394,11 +1422,28 @@
     return false;
   }
   switch (capsule.capsule_type()) {
-    case CapsuleType::DATAGRAM: {
-      HandleReceivedDatagram(capsule.datagram_capsule().context_id,
-                             capsule.datagram_capsule().http_datagram_payload);
+    case CapsuleType::LEGACY_DATAGRAM: {
+      HandleReceivedDatagram(
+          capsule.legacy_datagram_capsule().context_id,
+          capsule.legacy_datagram_capsule().http_datagram_payload);
     } break;
-    case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+    case CapsuleType::DATAGRAM_WITH_CONTEXT: {
+      HandleReceivedDatagram(
+          capsule.datagram_with_context_capsule().context_id,
+          capsule.datagram_with_context_capsule().http_datagram_payload);
+    } break;
+    case CapsuleType::DATAGRAM_WITHOUT_CONTEXT: {
+      absl::optional<QuicDatagramContextId> context_id;
+      if (use_datagram_contexts_) {
+        // draft-ietf-masque-h3-datagram-05 encodes context ID 0 using
+        // DATAGRAM_WITHOUT_CONTEXT.
+        context_id = 0;
+      }
+      HandleReceivedDatagram(
+          context_id,
+          capsule.datagram_without_context_capsule().http_datagram_payload);
+    } break;
+    case CapsuleType::REGISTER_DATAGRAM_CONTEXT: {
       if (datagram_registration_visitor_ == nullptr) {
         QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << capsule
                          << " without any registration visitor";
@@ -1408,20 +1453,26 @@
           id(), capsule.register_datagram_context_capsule().context_id,
           capsule.register_datagram_context_capsule().format_type,
           capsule.register_datagram_context_capsule().format_additional_data);
-      break;
-    case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+    } break;
+    case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT: {
       if (datagram_registration_visitor_ == nullptr) {
         QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << capsule
                          << " without any registration visitor";
         return false;
       }
+      absl::optional<QuicDatagramContextId> context_id;
+      if (use_datagram_contexts_) {
+        // draft-ietf-masque-h3-datagram-05 encodes context ID 0 using
+        // REGISTER_DATAGRAM_NO_CONTEXT.
+        context_id = 0;
+      }
       datagram_registration_visitor_->OnContextReceived(
-          id(), /*context_id=*/absl::nullopt,
+          id(), context_id,
           capsule.register_datagram_no_context_capsule().format_type,
           capsule.register_datagram_no_context_capsule()
               .format_additional_data);
-      break;
-    case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+    } break;
+    case CapsuleType::CLOSE_DATAGRAM_CONTEXT: {
       if (datagram_registration_visitor_ == nullptr) {
         QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << capsule
                          << " without any registration visitor";
@@ -1431,8 +1482,8 @@
           id(), capsule.close_datagram_context_capsule().context_id,
           capsule.close_datagram_context_capsule().close_code,
           capsule.close_datagram_context_capsule().close_details);
-      break;
-    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
+    } break;
+    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION: {
       if (web_transport_ == nullptr) {
         QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << capsule
                          << " for a non-WebTransport stream.";
@@ -1441,7 +1492,7 @@
       web_transport_->OnCloseReceived(
           capsule.close_web_transport_session_capsule().error_code,
           capsule.close_web_transport_session_capsule().error_message);
-      break;
+    } break;
   }
   return true;
 }
@@ -1485,7 +1536,7 @@
 }
 
 void QuicSpdyStream::RegisterHttp3DatagramRegistrationVisitor(
-    Http3DatagramRegistrationVisitor* visitor) {
+    Http3DatagramRegistrationVisitor* visitor, bool use_datagram_contexts) {
   if (visitor == nullptr) {
     QUIC_BUG(null datagram registration visitor)
         << ENDPOINT << "Null datagram registration visitor for" << id();
@@ -1496,7 +1547,10 @@
         << ENDPOINT << "Double datagram registration visitor for" << id();
     return;
   }
-  QUIC_DLOG(INFO) << ENDPOINT << "Registering datagram stream ID " << id();
+  use_datagram_contexts_ = use_datagram_contexts;
+  QUIC_DLOG(INFO) << ENDPOINT << "Registering datagram stream ID " << id()
+                  << " with" << (use_datagram_contexts_ ? "" : "out")
+                  << " contexts";
   datagram_registration_visitor_ = visitor;
   QUICHE_DCHECK(!capsule_parser_);
   capsule_parser_.reset(new CapsuleParser(this));
@@ -1589,8 +1643,15 @@
         QuicConnection::ScopedPacketFlusher flusher(
             spdy_session_->connection());
         WriteGreaseCapsule();
-        WriteCapsule(Capsule::RegisterDatagramContext(
-            context_id.value(), format_type, format_additional_data));
+        if (context_id.value() != 0) {
+          WriteCapsule(Capsule::RegisterDatagramContext(
+              context_id.value(), format_type, format_additional_data));
+        } else {
+          // draft-ietf-masque-h3-datagram-05 encodes context ID 0 using
+          // REGISTER_DATAGRAM_NO_CONTEXT.
+          WriteCapsule(Capsule::RegisterDatagramNoContext(
+              format_type, format_additional_data));
+        }
         WriteGreaseCapsule();
       }
     } else if (is_client) {
@@ -1676,9 +1737,13 @@
 }
 
 void QuicSpdyStream::OnDatagramReceived(QuicDataReader* reader) {
+  if (!headers_decompressed_) {
+    QUIC_DLOG(INFO) << "Dropping datagram received before headers on stream ID "
+                    << id();
+    return;
+  }
   absl::optional<QuicDatagramContextId> context_id;
-  const bool context_id_present = !datagram_context_visitors_.empty();
-  if (context_id_present) {
+  if (use_datagram_contexts_) {
     QuicDatagramContextId parsed_context_id;
     if (!reader->ReadVarInt62(&parsed_context_id)) {
       QUIC_DLOG(ERROR) << "Failed to parse context ID in received HTTP/3 "
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index cd9d99b..8ec56d5 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -296,7 +296,8 @@
   // UnregisterHttp3DatagramRegistrationVisitor. |visitor| must be valid until a
   // corresponding call to UnregisterHttp3DatagramRegistrationVisitor.
   void RegisterHttp3DatagramRegistrationVisitor(
-      Http3DatagramRegistrationVisitor* visitor);
+      Http3DatagramRegistrationVisitor* visitor,
+      bool use_datagram_contexts = false);
 
   // Unregisters for HTTP/3 datagram context registrations. Must not be called
   // unless previously registered.
@@ -427,6 +428,9 @@
   void HandleReceivedDatagram(absl::optional<QuicDatagramContextId> context_id,
                               absl::string_view payload);
 
+  // Whether datagram contexts should be used on this stream.
+  bool ShouldUseDatagramContexts() const;
+
   QuicSpdySession* spdy_session_;
 
   bool on_body_available_called_because_sequencer_is_closed_;
@@ -505,6 +509,7 @@
   QuicDatagramContextId datagram_next_available_context_id_;
   absl::flat_hash_map<QuicDatagramContextId, Http3DatagramVisitor*>
       datagram_context_visitors_;
+  bool use_datagram_contexts_ = false;
 };
 
 }  // namespace quic
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index b5905e7..50dc9ea 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -3208,6 +3208,10 @@
   session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft00And04);
   QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
                                               HttpDatagramSupport::kDraft00);
+  headers_[":method"] = "CONNECT";
+  headers_[":protocol"] = "webtransport";
+  headers_["datagram-flow-id"] = absl::StrCat(stream_->id());
+  ProcessHeaders(false, headers_);
   session_->RegisterHttp3DatagramFlowId(stream_->id(), stream_->id());
   ::testing::NiceMock<MockHttp3DatagramRegistrationVisitor>
       h3_datagram_registration_visitor;
@@ -3259,6 +3263,9 @@
   session_->set_local_http_datagram_support(HttpDatagramSupport::kDraft04);
   QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
                                               HttpDatagramSupport::kDraft04);
+  headers_[":method"] = "CONNECT";
+  headers_[":protocol"] = "webtransport";
+  ProcessHeaders(false, headers_);
   ::testing::NiceMock<MockHttp3DatagramRegistrationVisitor>
       h3_datagram_registration_visitor;
   SavingHttp3DatagramVisitor h3_datagram_visitor;
@@ -3326,7 +3333,11 @@
     datagram[i] = i;
   }
   stream_->RegisterHttp3DatagramRegistrationVisitor(
-      &h3_datagram_registration_visitor);
+      &h3_datagram_registration_visitor, /*use_datagram_contexts=*/true);
+  headers_[":method"] = "CONNECT";
+  headers_[":protocol"] = "webtransport";
+  headers_["sec-use-datagram-contexts"] = "?1";
+  ProcessHeaders(false, headers_);
 
   // Expect us to send a REGISTER_DATAGRAM_CONTEXT capsule.
   EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _))
diff --git a/quic/core/http/web_transport_http3.cc b/quic/core/http/web_transport_http3.cc
index a54d210..128c44e 100644
--- a/quic/core/http/web_transport_http3.cc
+++ b/quic/core/http/web_transport_http3.cc
@@ -42,7 +42,8 @@
 
 WebTransportHttp3::WebTransportHttp3(QuicSpdySession* session,
                                      QuicSpdyStream* connect_stream,
-                                     WebTransportSessionId id)
+                                     WebTransportSessionId id,
+                                     bool attempt_to_use_datagram_contexts)
     : session_(session),
       connect_stream_(connect_stream),
       id_(id),
@@ -50,10 +51,14 @@
   QUICHE_DCHECK(session_->SupportsWebTransport());
   QUICHE_DCHECK(IsValidWebTransportSessionId(id, session_->version()));
   QUICHE_DCHECK_EQ(connect_stream_->id(), id);
-  connect_stream_->RegisterHttp3DatagramRegistrationVisitor(this);
+  connect_stream_->RegisterHttp3DatagramRegistrationVisitor(
+      this, attempt_to_use_datagram_contexts);
   if (session_->perspective() == Perspective::IS_CLIENT) {
     context_is_known_ = true;
     context_currently_registered_ = true;
+    if (attempt_to_use_datagram_contexts) {
+      context_id_ = connect_stream_->GetNextDatagramContextId();
+    }
   }
 }
 
diff --git a/quic/core/http/web_transport_http3.h b/quic/core/http/web_transport_http3.h
index 7a72931..cd446c1 100644
--- a/quic/core/http/web_transport_http3.h
+++ b/quic/core/http/web_transport_http3.h
@@ -34,7 +34,8 @@
       public QuicSpdyStream::Http3DatagramVisitor {
  public:
   WebTransportHttp3(QuicSpdySession* session, QuicSpdyStream* connect_stream,
-                    WebTransportSessionId id);
+                    WebTransportSessionId id,
+                    bool attempt_to_use_datagram_contexts);
 
   void HeadersReceived(const spdy::SpdyHeaderBlock& headers);
   void SetVisitor(std::unique_ptr<WebTransportVisitor> visitor) {
@@ -109,7 +110,7 @@
   bool ready_ = false;
   // Whether we know which |context_id_| to use. On the client this is always
   // true, and on the server it becomes true when we receive a context
-  // registeration capsule.
+  // registration capsule.
   bool context_is_known_ = false;
   // Whether |context_id_| is currently registered with |connect_stream_|.
   bool context_currently_registered_ = false;
diff --git a/quic/test_tools/quic_spdy_stream_peer.cc b/quic/test_tools/quic_spdy_stream_peer.cc
index 896a5b0..6db9a4a 100644
--- a/quic/test_tools/quic_spdy_stream_peer.cc
+++ b/quic/test_tools/quic_spdy_stream_peer.cc
@@ -23,5 +23,10 @@
   return stream->unacked_frame_headers_offsets_;
 }
 
+// static
+bool QuicSpdyStreamPeer::use_datagram_contexts(QuicSpdyStream* stream) {
+  return stream->use_datagram_contexts_;
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/quic_spdy_stream_peer.h b/quic/test_tools/quic_spdy_stream_peer.h
index 0f04338..8a50426 100644
--- a/quic/test_tools/quic_spdy_stream_peer.h
+++ b/quic/test_tools/quic_spdy_stream_peer.h
@@ -23,6 +23,7 @@
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
   static const QuicIntervalSet<QuicStreamOffset>& unacked_frame_headers_offsets(
       QuicSpdyStream* stream);
+  static bool use_datagram_contexts(QuicSpdyStream* stream);
 };
 
 }  // namespace test
diff --git a/quic/test_tools/quic_test_backend.h b/quic/test_tools/quic_test_backend.h
index 6aa175e..b0c0ce2 100644
--- a/quic/test_tools/quic_test_backend.h
+++ b/quic/test_tools/quic_test_backend.h
@@ -26,6 +26,12 @@
     enable_webtransport_ = enable_webtransport;
   }
 
+  bool UsesDatagramContexts() override { return use_datagram_contexts_; }
+
+  void set_use_datagram_contexts(bool use_datagram_contexts) {
+    use_datagram_contexts_ = use_datagram_contexts;
+  }
+
   bool SupportsExtendedConnect() override { return enable_extended_connect_; }
 
   void set_enable_extended_connect(bool enable_extended_connect) {
@@ -34,6 +40,7 @@
 
  private:
   bool enable_webtransport_ = false;
+  bool use_datagram_contexts_ = false;
   bool enable_extended_connect_ = true;
 };
 
diff --git a/quic/tools/quic_client.cc b/quic/tools/quic_client.cc
index e659b4a..cfc435e 100644
--- a/quic/tools/quic_client.cc
+++ b/quic/tools/quic_client.cc
@@ -164,7 +164,8 @@
     QuicConnection* connection) {
   return std::make_unique<QuicSimpleClientSession>(
       *config(), supported_versions, connection, server_id(), crypto_config(),
-      push_promise_index(), drop_response_body(), enable_web_transport());
+      push_promise_index(), drop_response_body(), enable_web_transport(),
+      use_datagram_contexts());
 }
 
 QuicClientEpollNetworkHelper* QuicClient::epoll_network_helper() {
diff --git a/quic/tools/quic_simple_client_session.cc b/quic/tools/quic_simple_client_session.cc
index 47c521b..2e70919 100644
--- a/quic/tools/quic_simple_client_session.cc
+++ b/quic/tools/quic_simple_client_session.cc
@@ -9,39 +9,27 @@
 namespace quic {
 
 QuicSimpleClientSession::QuicSimpleClientSession(
-    const QuicConfig& config,
-    const ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection,
-    const QuicServerId& server_id,
+    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
+    QuicConnection* connection, const QuicServerId& server_id,
     QuicCryptoClientConfig* crypto_config,
-    QuicClientPushPromiseIndex* push_promise_index,
-    bool drop_response_body)
-    : QuicSimpleClientSession(config,
-                              supported_versions,
-                              connection,
-                              server_id,
-                              crypto_config,
-                              push_promise_index,
+    QuicClientPushPromiseIndex* push_promise_index, bool drop_response_body)
+    : QuicSimpleClientSession(config, supported_versions, connection, server_id,
+                              crypto_config, push_promise_index,
                               drop_response_body,
-                              /*enable_web_transport=*/false) {}
+                              /*enable_web_transport=*/false,
+                              /*use_datagram_contexts=*/false) {}
 
 QuicSimpleClientSession::QuicSimpleClientSession(
-    const QuicConfig& config,
-    const ParsedQuicVersionVector& supported_versions,
-    QuicConnection* connection,
-    const QuicServerId& server_id,
+    const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
+    QuicConnection* connection, const QuicServerId& server_id,
     QuicCryptoClientConfig* crypto_config,
-    QuicClientPushPromiseIndex* push_promise_index,
-    bool drop_response_body,
-    bool enable_web_transport)
-    : QuicSpdyClientSession(config,
-                            supported_versions,
-                            connection,
-                            server_id,
-                            crypto_config,
-                            push_promise_index),
+    QuicClientPushPromiseIndex* push_promise_index, bool drop_response_body,
+    bool enable_web_transport, bool use_datagram_contexts)
+    : QuicSpdyClientSession(config, supported_versions, connection, server_id,
+                            crypto_config, push_promise_index),
       drop_response_body_(drop_response_body),
-      enable_web_transport_(enable_web_transport) {}
+      enable_web_transport_(enable_web_transport),
+      use_datagram_contexts_(use_datagram_contexts) {}
 
 std::unique_ptr<QuicSpdyClientStream>
 QuicSimpleClientSession::CreateClientStream() {
@@ -54,6 +42,10 @@
   return enable_web_transport_;
 }
 
+bool QuicSimpleClientSession::ShouldNegotiateDatagramContexts() {
+  return use_datagram_contexts_;
+}
+
 HttpDatagramSupport QuicSimpleClientSession::LocalHttpDatagramSupport() {
   return enable_web_transport_ ? HttpDatagramSupport::kDraft04
                                : HttpDatagramSupport::kNone;
diff --git a/quic/tools/quic_simple_client_session.h b/quic/tools/quic_simple_client_session.h
index 1a6e694..6371448 100644
--- a/quic/tools/quic_simple_client_session.h
+++ b/quic/tools/quic_simple_client_session.h
@@ -25,16 +25,18 @@
                           const QuicServerId& server_id,
                           QuicCryptoClientConfig* crypto_config,
                           QuicClientPushPromiseIndex* push_promise_index,
-                          bool drop_response_body,
-                          bool enable_web_transport);
+                          bool drop_response_body, bool enable_web_transport,
+                          bool use_datagram_contexts);
 
   std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override;
   bool ShouldNegotiateWebTransport() override;
+  bool ShouldNegotiateDatagramContexts() override;
   HttpDatagramSupport LocalHttpDatagramSupport() override;
 
  private:
   const bool drop_response_body_;
   const bool enable_web_transport_;
+  const bool use_datagram_contexts_;
 };
 
 }  // namespace quic
diff --git a/quic/tools/quic_simple_server_backend.h b/quic/tools/quic_simple_server_backend.h
index 67aeac9..25204ac 100644
--- a/quic/tools/quic_simple_server_backend.h
+++ b/quic/tools/quic_simple_server_backend.h
@@ -67,6 +67,7 @@
     return response;
   }
   virtual bool SupportsWebTransport() { return false; }
+  virtual bool UsesDatagramContexts() { return false; }
   virtual bool SupportsExtendedConnect() { return true; }
 };
 
diff --git a/quic/tools/quic_simple_server_session.h b/quic/tools/quic_simple_server_session.h
index 9746f26..393a2d8 100644
--- a/quic/tools/quic_simple_server_session.h
+++ b/quic/tools/quic_simple_server_session.h
@@ -70,6 +70,10 @@
 
   void OnCanCreateNewOutgoingStream(bool unidirectional) override;
 
+  bool ShouldNegotiateDatagramContexts() override {
+    return quic_simple_server_backend_->UsesDatagramContexts();
+  }
+
  protected:
   // QuicSession methods:
   QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override;
diff --git a/quic/tools/quic_spdy_client_base.h b/quic/tools/quic_spdy_client_base.h
index c49d0ed..3e41725 100644
--- a/quic/tools/quic_spdy_client_base.h
+++ b/quic/tools/quic_spdy_client_base.h
@@ -144,6 +144,11 @@
   }
   bool enable_web_transport() const { return enable_web_transport_; }
 
+  void set_use_datagram_contexts(bool use_datagram_contexts) {
+    use_datagram_contexts_ = use_datagram_contexts;
+  }
+  bool use_datagram_contexts() const { return use_datagram_contexts_; }
+
   // QuicClientBase methods.
   bool goaway_received() const override;
   bool EarlyDataAccepted() override;
@@ -227,6 +232,7 @@
 
   bool drop_response_body_ = false;
   bool enable_web_transport_ = false;
+  bool use_datagram_contexts_ = false;
   // If not zero, used to set client's max inbound header size before session
   // initialize.
   size_t max_inbound_header_list_size_ = 0;