diff --git a/quic/core/http/http_constants.cc b/quic/core/http/http_constants.cc
index f3ed523..2c0ec24 100644
--- a/quic/core/http/http_constants.cc
+++ b/quic/core/http/http_constants.cc
@@ -17,7 +17,8 @@
     RETURN_STRING_LITERAL(SETTINGS_QPACK_MAX_TABLE_CAPACITY);
     RETURN_STRING_LITERAL(SETTINGS_MAX_FIELD_SECTION_SIZE);
     RETURN_STRING_LITERAL(SETTINGS_QPACK_BLOCKED_STREAMS);
-    RETURN_STRING_LITERAL(SETTINGS_H3_DATAGRAM);
+    RETURN_STRING_LITERAL(SETTINGS_H3_DATAGRAM_DRAFT00);
+    RETURN_STRING_LITERAL(SETTINGS_H3_DATAGRAM_DRAFT03);
     RETURN_STRING_LITERAL(SETTINGS_WEBTRANS_DRAFT00);
   }
   return absl::StrCat("UNSUPPORTED_SETTINGS_TYPE(", identifier, ")");
diff --git a/quic/core/http/http_constants.h b/quic/core/http/http_constants.h
index c13a1a8..94328ac 100644
--- a/quic/core/http/http_constants.h
+++ b/quic/core/http/http_constants.h
@@ -38,8 +38,10 @@
   // Same value as spdy::SETTINGS_MAX_HEADER_LIST_SIZE.
   SETTINGS_MAX_FIELD_SECTION_SIZE = 0x06,
   SETTINGS_QPACK_BLOCKED_STREAMS = 0x07,
-  // draft-ietf-masque-h3-datagram.
-  SETTINGS_H3_DATAGRAM = 0x276,
+  // draft-ietf-masque-h3-datagram-00.
+  SETTINGS_H3_DATAGRAM_DRAFT00 = 0x276,
+  // draft-ietf-masque-h3-datagram-03.
+  SETTINGS_H3_DATAGRAM_DRAFT03 = 0xffd276,
   // draft-ietf-webtrans-http3-00
   SETTINGS_WEBTRANS_DRAFT00 = 0x2b603742,
 };
diff --git a/quic/core/http/http_decoder.cc b/quic/core/http/http_decoder.cc
index b20789b..c22fc32 100644
--- a/quic/core/http/http_decoder.cc
+++ b/quic/core/http/http_decoder.cc
@@ -266,6 +266,8 @@
     case static_cast<uint64_t>(HttpFrameType::ACCEPT_CH):
       continue_processing = visitor_->OnAcceptChFrameStart(header_length);
       break;
+    case static_cast<uint64_t>(HttpFrameType::CAPSULE):
+      break;
     default:
       continue_processing = visitor_->OnUnknownFrameStart(
           current_frame_type_, header_length, current_frame_length_);
@@ -335,6 +337,10 @@
       continue_processing = BufferOrParsePayload(reader);
       break;
     }
+    case static_cast<uint64_t>(HttpFrameType::CAPSULE): {
+      continue_processing = BufferOrParsePayload(reader);
+      break;
+    }
     default: {
       continue_processing = HandleUnknownFramePayload(reader);
       break;
@@ -401,6 +407,12 @@
       continue_processing = BufferOrParsePayload(reader);
       break;
     }
+    case static_cast<uint64_t>(HttpFrameType::CAPSULE): {
+      // If frame payload is not empty, FinishParsing() is skipped.
+      QUICHE_DCHECK_EQ(0u, current_frame_length_);
+      continue_processing = BufferOrParsePayload(reader);
+      break;
+    }
     default:
       continue_processing = visitor_->OnUnknownFrameEnd();
   }
@@ -537,6 +549,13 @@
       }
       return visitor_->OnAcceptChFrame(frame);
     }
+    case static_cast<uint64_t>(HttpFrameType::CAPSULE): {
+      CapsuleFrame frame;
+      if (!ParseCapsuleFrame(reader, &frame)) {
+        return false;
+      }
+      return visitor_->OnCapsuleFrame(frame);
+    }
     default:
       // Only above frame types are parsed by ParseEntirePayload().
       QUICHE_NOTREACHED();
@@ -662,6 +681,59 @@
   return true;
 }
 
+bool HttpDecoder::ParseCapsuleFrame(QuicDataReader* reader,
+                                    CapsuleFrame* frame) {
+  uint64_t capsule_type64;
+  if (!reader->ReadVarInt62(&capsule_type64)) {
+    RaiseError(QUIC_HTTP_FRAME_ERROR, "Unable to parse capsule type");
+    return false;
+  }
+  *frame = CapsuleFrame(static_cast<CapsuleType>(capsule_type64));
+  switch (frame->capsule_type) {
+    case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+      if (!reader->ReadVarInt62(
+              &frame->register_datagram_context_capsule.context_id)) {
+        RaiseError(
+            QUIC_HTTP_FRAME_ERROR,
+            "Unable to parse capsule REGISTER_DATAGRAM_CONTEXT context ID");
+        return false;
+      }
+      frame->register_datagram_context_capsule.context_extensions =
+          reader->ReadRemainingPayload();
+      break;
+    case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+      if (!reader->ReadVarInt62(
+              &frame->close_datagram_context_capsule.context_id)) {
+        RaiseError(QUIC_HTTP_FRAME_ERROR,
+                   "Unable to parse capsule CLOSE_DATAGRAM_CONTEXT context ID");
+        return false;
+      }
+      frame->close_datagram_context_capsule.context_extensions =
+          reader->ReadRemainingPayload();
+      break;
+    case CapsuleType::DATAGRAM:
+      if (datagram_context_id_present_) {
+        uint64_t context_id;
+        if (!reader->ReadVarInt62(&context_id)) {
+          RaiseError(QUIC_HTTP_FRAME_ERROR,
+                     "Unable to parse capsule DATAGRAM context ID");
+          return false;
+        }
+        frame->datagram_capsule.context_id = context_id;
+      }
+      frame->datagram_capsule.http_datagram_payload =
+          reader->ReadRemainingPayload();
+      break;
+    case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+      frame->register_datagram_no_context_capsule.context_extensions =
+          reader->ReadRemainingPayload();
+      break;
+    default:
+      frame->unknown_capsule_data = reader->ReadRemainingPayload();
+  }
+  return true;
+}
+
 QuicByteCount HttpDecoder::MaxFrameLength(uint64_t frame_type) {
   switch (frame_type) {
     case static_cast<uint64_t>(HttpFrameType::SETTINGS):
@@ -682,6 +754,9 @@
     case static_cast<uint64_t>(HttpFrameType::ACCEPT_CH):
       // This limit is arbitrary.
       return 1024 * 1024;
+    case static_cast<uint64_t>(HttpFrameType::CAPSULE):
+      // This limit is arbitrary.
+      return 1024 * 1024;
     default:
       // Other frames require no data buffering, so it's safe to have no limit.
       return std::numeric_limits<QuicByteCount>::max();
diff --git a/quic/core/http/http_decoder.h b/quic/core/http/http_decoder.h
index 7cbf205..8d96c84 100644
--- a/quic/core/http/http_decoder.h
+++ b/quic/core/http/http_decoder.h
@@ -94,6 +94,9 @@
     // Called when an ACCEPT_CH frame has been successfully parsed.
     virtual bool OnAcceptChFrame(const AcceptChFrame& frame) = 0;
 
+    // Called when a CAPSULE frame has been successfully parsed.
+    virtual bool OnCapsuleFrame(const CapsuleFrame& frame) = 0;
+
     // Called when a WEBTRANSPORT_STREAM frame type and the session ID varint
     // immediately following it has been received.  Any further parsing should
     // be done by the stream itself, and not the parser. Note that this does not
@@ -148,6 +151,10 @@
   // Returns true if input data processed so far ends on a frame boundary.
   bool AtFrameBoundary() const { return state_ == STATE_READING_FRAME_TYPE; }
 
+  void set_datagram_context_id_present(bool datagram_context_id_present) {
+    datagram_context_id_present_ = datagram_context_id_present;
+  }
+
  private:
   friend test::HttpDecoderPeer;
 
@@ -230,6 +237,9 @@
   // Parses the payload of an ACCEPT_CH frame from |reader| into |frame|.
   bool ParseAcceptChFrame(QuicDataReader* reader, AcceptChFrame* frame);
 
+  // Parses the payload of an CAPSULE frame from |reader| into |frame|.
+  bool ParseCapsuleFrame(QuicDataReader* reader, CapsuleFrame* frame);
+
   // Returns the max frame size of a given |frame_type|.
   QuicByteCount MaxFrameLength(uint64_t frame_type);
 
@@ -237,6 +247,8 @@
   Visitor* const visitor_;  // Unowned.
   // Whether WEBTRANSPORT_STREAM should be parsed.
   bool allow_web_transport_stream_;
+  // Whether HTTP Datagram Context IDs are present.
+  bool datagram_context_id_present_ = false;
   // Current state of the parsing.
   HttpDecoderState state_;
   // Type of the frame currently being parsed.
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 7fa09ba..6a8491e 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -89,6 +89,7 @@
               (QuicByteCount header_length),
               (override));
   MOCK_METHOD(bool, OnAcceptChFrame, (const AcceptChFrame& frame), (override));
+  MOCK_METHOD(bool, OnCapsuleFrame, (const CapsuleFrame& frame), (override));
   MOCK_METHOD(void,
               OnWebTransportStreamFrameType,
               (QuicByteCount header_length, WebTransportSessionId session_id),
@@ -125,6 +126,7 @@
     ON_CALL(visitor_, OnPriorityUpdateFrame(_)).WillByDefault(Return(true));
     ON_CALL(visitor_, OnAcceptChFrameStart(_)).WillByDefault(Return(true));
     ON_CALL(visitor_, OnAcceptChFrame(_)).WillByDefault(Return(true));
+    ON_CALL(visitor_, OnCapsuleFrame(_)).WillByDefault(Return(true));
     ON_CALL(visitor_, OnUnknownFrameStart(_, _, _)).WillByDefault(Return(true));
     ON_CALL(visitor_, OnUnknownFramePayload(_)).WillByDefault(Return(true));
     ON_CALL(visitor_, OnUnknownFrameEnd()).WillByDefault(Return(true));
@@ -1043,6 +1045,88 @@
   EXPECT_EQ("", decoder_.error_detail());
 }
 
+TEST_F(HttpDecoderTest, RegisterDatagramContextCapsuleFrame) {
+  std::string input = absl::HexStringToBytes(
+      "80ffcab5"    // type (CAPSULE)
+      "06"          // length
+      "00"          // capsule type (REGISTER_DATAGRAM_CONTEXT)
+      "08"          // context ID
+      "01020304");  // context extensions
+
+  CapsuleFrame frame(CapsuleType::REGISTER_DATAGRAM_CONTEXT);
+  frame.register_datagram_context_capsule.context_id = 8;
+  std::array<char, 4> context_extensions = {1, 2, 3, 4};
+  frame.register_datagram_context_capsule.context_extensions =
+      absl::string_view(context_extensions.data(), context_extensions.size());
+  EXPECT_CALL(visitor_, OnCapsuleFrame(frame));
+  EXPECT_EQ(ProcessInput(input), input.size());
+}
+
+TEST_F(HttpDecoderTest, CloseDatagramContextCapsuleFrame) {
+  std::string input = absl::HexStringToBytes(
+      "80ffcab5"    // type (CAPSULE)
+      "06"          // length
+      "01"          // capsule type (CLOSE_DATAGRAM_CONTEXT)
+      "08"          // context ID
+      "01020304");  // context extensions
+
+  CapsuleFrame frame(CapsuleType::CLOSE_DATAGRAM_CONTEXT);
+  frame.close_datagram_context_capsule.context_id = 8;
+  std::array<char, 4> context_extensions = {1, 2, 3, 4};
+  frame.close_datagram_context_capsule.context_extensions =
+      absl::string_view(context_extensions.data(), context_extensions.size());
+  EXPECT_CALL(visitor_, OnCapsuleFrame(frame));
+  EXPECT_EQ(ProcessInput(input), input.size());
+}
+
+TEST_F(HttpDecoderTest, DatagramWithoutContextCapsuleFrame) {
+  std::string input = absl::HexStringToBytes(
+      "80ffcab5"    // type (CAPSULE)
+      "05"          // length
+      "02"          // capsule type (DATAGRAM)
+      "01020304");  // context extensions
+
+  CapsuleFrame frame(CapsuleType::DATAGRAM);
+  std::array<char, 4> datagram_payload = {1, 2, 3, 4};
+  frame.datagram_capsule.http_datagram_payload =
+      absl::string_view(datagram_payload.data(), datagram_payload.size());
+  EXPECT_CALL(visitor_, OnCapsuleFrame(frame));
+  EXPECT_EQ(ProcessInput(input), input.size());
+}
+
+TEST_F(HttpDecoderTest, DatagramWithContextCapsuleFrame) {
+  decoder_.set_datagram_context_id_present(true);
+  std::string input = absl::HexStringToBytes(
+      "80ffcab5"    // type (CAPSULE)
+      "06"          // length
+      "02"          // capsule type (DATAGRAM)
+      "08"          // context ID
+      "01020304");  // context extensions
+
+  CapsuleFrame frame(CapsuleType::DATAGRAM);
+  frame.datagram_capsule.context_id = 8;
+  std::array<char, 4> datagram_payload = {1, 2, 3, 4};
+  frame.datagram_capsule.http_datagram_payload =
+      absl::string_view(datagram_payload.data(), datagram_payload.size());
+  EXPECT_CALL(visitor_, OnCapsuleFrame(frame));
+  EXPECT_EQ(ProcessInput(input), input.size());
+}
+
+TEST_F(HttpDecoderTest, RegisterDatagramNoContextCapsuleFrame) {
+  std::string input = absl::HexStringToBytes(
+      "80ffcab5"    // type (CAPSULE)
+      "05"          // length
+      "03"          // capsule type (REGISTER_DATAGRAM_NO_CONTEXT)
+      "01020304");  // context extensions
+
+  CapsuleFrame frame(CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT);
+  std::array<char, 4> context_extensions = {1, 2, 3, 4};
+  frame.register_datagram_no_context_capsule.context_extensions =
+      absl::string_view(context_extensions.data(), context_extensions.size());
+  EXPECT_CALL(visitor_, OnCapsuleFrame(frame));
+  EXPECT_EQ(ProcessInput(input), input.size());
+}
+
 TEST_F(HttpDecoderTest, WebTransportStreamDisabled) {
   InSequence s;
 
diff --git a/quic/core/http/http_encoder.cc b/quic/core/http/http_encoder.cc
index 25f6200..d9d161b 100644
--- a/quic/core/http/http_encoder.cc
+++ b/quic/core/http/http_encoder.cc
@@ -276,4 +276,143 @@
   return 0;
 }
 
+// static
+QuicByteCount HttpEncoder::SerializeCapsuleFrame(
+    const CapsuleFrame& capsule_frame, std::unique_ptr<char[]>* output) {
+  QuicByteCount capsule_type_length = QuicDataWriter::GetVarInt62Len(
+      static_cast<uint64_t>(capsule_frame.capsule_type));
+  QuicByteCount capsule_data_length;
+  switch (capsule_frame.capsule_type) {
+    case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+      capsule_data_length =
+          QuicDataWriter::GetVarInt62Len(
+              capsule_frame.register_datagram_context_capsule.context_id) +
+          capsule_frame.register_datagram_context_capsule.context_extensions
+              .length();
+      break;
+    case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+      capsule_data_length =
+          QuicDataWriter::GetVarInt62Len(
+              capsule_frame.close_datagram_context_capsule.context_id) +
+          capsule_frame.close_datagram_context_capsule.context_extensions
+              .length();
+      break;
+    case CapsuleType::DATAGRAM:
+      capsule_data_length =
+          capsule_frame.datagram_capsule.http_datagram_payload.length();
+      if (capsule_frame.datagram_capsule.context_id.has_value()) {
+        capsule_data_length += QuicDataWriter::GetVarInt62Len(
+            capsule_frame.datagram_capsule.context_id.value());
+      }
+      break;
+    case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+      capsule_data_length = capsule_frame.register_datagram_no_context_capsule
+                                .context_extensions.length();
+      break;
+    default:
+      capsule_data_length = capsule_frame.unknown_capsule_data.length();
+      break;
+  }
+  QuicByteCount frame_length_field_value =
+      capsule_type_length + capsule_data_length;
+  QuicByteCount total_frame_length =
+      QuicDataWriter::GetVarInt62Len(
+          static_cast<uint64_t>(HttpFrameType::CAPSULE)) +
+      QuicDataWriter::GetVarInt62Len(frame_length_field_value) +
+      capsule_type_length + capsule_data_length;
+  *output = std::make_unique<char[]>(total_frame_length);
+  QuicDataWriter writer(total_frame_length, output->get());
+  if (!writer.WriteVarInt62(static_cast<uint64_t>(HttpFrameType::CAPSULE))) {
+    QUIC_BUG(capsule frame type write fail)
+        << "Failed to write CAPSULE frame type";
+    return 0;
+  }
+  if (!writer.WriteVarInt62(frame_length_field_value)) {
+    QUIC_BUG(capsule frame length write fail)
+        << "Failed to write CAPSULE frame length";
+    return 0;
+  }
+  if (!writer.WriteVarInt62(
+          static_cast<uint64_t>(capsule_frame.capsule_type))) {
+    QUIC_BUG(capsule type write fail) << "Failed to write CAPSULE type";
+    return 0;
+  }
+  switch (capsule_frame.capsule_type) {
+    case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+      if (!writer.WriteVarInt62(
+              capsule_frame.register_datagram_context_capsule.context_id)) {
+        QUIC_BUG(register context capsule context ID write fail)
+            << "Failed to write REGISTER_DATAGRAM_CONTEXT CAPSULE context ID";
+        return 0;
+      }
+      if (!writer.WriteBytes(capsule_frame.register_datagram_context_capsule
+                                 .context_extensions.data(),
+                             capsule_frame.register_datagram_context_capsule
+                                 .context_extensions.length())) {
+        QUIC_BUG(register context capsule extensions write fail)
+            << "Failed to write REGISTER_DATAGRAM_CONTEXT CAPSULE extensions";
+        return 0;
+      }
+      break;
+    case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+      if (!writer.WriteVarInt62(
+              capsule_frame.close_datagram_context_capsule.context_id)) {
+        QUIC_BUG(close context capsule context ID write fail)
+            << "Failed to write CLOSE_DATAGRAM_CONTEXT CAPSULE context ID";
+        return 0;
+      }
+      if (!writer.WriteBytes(capsule_frame.close_datagram_context_capsule
+                                 .context_extensions.data(),
+                             capsule_frame.close_datagram_context_capsule
+                                 .context_extensions.length())) {
+        QUIC_BUG(close context capsule extensions write fail)
+            << "Failed to write CLOSE_DATAGRAM_CONTEXT CAPSULE extensions";
+        return 0;
+      }
+      break;
+    case CapsuleType::DATAGRAM:
+      if (capsule_frame.datagram_capsule.context_id.has_value()) {
+        if (!writer.WriteVarInt62(
+                capsule_frame.datagram_capsule.context_id.value())) {
+          QUIC_BUG(datagram capsule context ID write fail)
+              << "Failed to write DATAGRAM CAPSULE context ID";
+          return 0;
+        }
+      }
+      if (!writer.WriteBytes(
+              capsule_frame.datagram_capsule.http_datagram_payload.data(),
+              capsule_frame.datagram_capsule.http_datagram_payload.length())) {
+        QUIC_BUG(datagram capsule payload write fail)
+            << "Failed to write DATAGRAM CAPSULE payload";
+        return 0;
+      }
+      break;
+    case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+      if (!writer.WriteBytes(capsule_frame.register_datagram_no_context_capsule
+                                 .context_extensions.data(),
+                             capsule_frame.register_datagram_no_context_capsule
+                                 .context_extensions.length())) {
+        QUIC_BUG(register no context capsule extensions write fail)
+            << "Failed to write REGISTER_DATAGRAM_NO_CONTEXT CAPSULE "
+               "extensions";
+        return 0;
+      }
+      break;
+    default:
+      if (!writer.WriteBytes(capsule_frame.unknown_capsule_data.data(),
+                             capsule_frame.unknown_capsule_data.length())) {
+        QUIC_BUG(capsule data write fail) << "Failed to write CAPSULE data";
+        return 0;
+      }
+      break;
+  }
+  if (writer.remaining() != 0) {
+    QUIC_BUG(capsule write length mismatch)
+        << "CAPSULE serialization wrote " << writer.length() << " instead of "
+        << writer.capacity();
+    return 0;
+  }
+  return total_frame_length;
+}
+
 }  // namespace quic
diff --git a/quic/core/http/http_encoder.h b/quic/core/http/http_encoder.h
index 585e739..6c8ab49 100644
--- a/quic/core/http/http_encoder.h
+++ b/quic/core/http/http_encoder.h
@@ -66,6 +66,10 @@
   static QuicByteCount SerializeWebTransportStreamFrameHeader(
       WebTransportSessionId session_id,
       std::unique_ptr<char[]>* output);
+
+  // Serializes a CAPSULE frame as specified in draft-ietf-masque-h3-datagram.
+  static QuicByteCount SerializeCapsuleFrame(const CapsuleFrame& capsule_frame,
+                                             std::unique_ptr<char[]>* output);
 };
 
 }  // namespace quic
diff --git a/quic/core/http/http_encoder_test.cc b/quic/core/http/http_encoder_test.cc
index c2b0f36..144c414 100644
--- a/quic/core/http/http_encoder_test.cc
+++ b/quic/core/http/http_encoder_test.cc
@@ -5,6 +5,7 @@
 #include "quic/core/http/http_encoder.h"
 
 #include "absl/base/macros.h"
+#include "quic/core/http/http_frames.h"
 #include "quic/core/quic_simple_buffer_allocator.h"
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_test.h"
@@ -138,5 +139,62 @@
       "WEBTRANSPORT_STREAM", buffer.get(), length, output, sizeof(output));
 }
 
+TEST(HttpEncoderTest, SerializeRegisterDatagramContextCapsule) {
+  CapsuleFrame capsule_frame(CapsuleType::REGISTER_DATAGRAM_CONTEXT);
+  capsule_frame.register_datagram_context_capsule.context_id = 4;
+  uint8_t output[] = {0x80, 0xff, 0xca, 0xb5,  // type (CAPSULE)
+                      0x02,                    // frame length.
+                      0x00,   // capsule type (REGISTER_DATAGRAM_CONTEXT).
+                      0x04};  // context ID.
+  std::unique_ptr<char[]> buffer;
+  uint64_t length = HttpEncoder::SerializeCapsuleFrame(capsule_frame, &buffer);
+  quiche::test::CompareCharArraysWithHexError(
+      "REGISTER_DATAGRAM_CONTEXT", buffer.get(), length,
+      reinterpret_cast<char*>(output), sizeof(output));
+}
+
+TEST(HttpEncoderTest, SerializeCloseDatagramContextCapsule) {
+  CapsuleFrame capsule_frame(CapsuleType::CLOSE_DATAGRAM_CONTEXT);
+  capsule_frame.close_datagram_context_capsule.context_id = 4;
+  uint8_t output[] = {0x80, 0xff, 0xca, 0xb5,  // type (CAPSULE)
+                      0x02,                    // frame length.
+                      0x01,   // capsule type (CLOSE_DATAGRAM_CONTEXT).
+                      0x04};  // context ID.
+  std::unique_ptr<char[]> buffer;
+  uint64_t length = HttpEncoder::SerializeCapsuleFrame(capsule_frame, &buffer);
+  quiche::test::CompareCharArraysWithHexError(
+      "CLOSE_DATAGRAM_CONTEXT", buffer.get(), length,
+      reinterpret_cast<char*>(output), sizeof(output));
+}
+
+TEST(HttpEncoderTest, SerializeDatagramCapsule) {
+  uint8_t http_datagram_payload[5] = {0x21, 0x22, 0x23, 0x24, 0x25};
+  CapsuleFrame capsule_frame(CapsuleType::DATAGRAM);
+  capsule_frame.datagram_capsule.http_datagram_payload =
+      absl::string_view(reinterpret_cast<char*>(http_datagram_payload),
+                        sizeof(http_datagram_payload));
+  uint8_t output[] = {0x80, 0xff, 0xca, 0xb5,  // type (CAPSULE)
+                      0x06,                    // frame length.
+                      0x02,                    // capsule type (DATAGRAM).
+                      0x21, 0x22, 0x23, 0x24, 0x25};  // payload.
+  std::unique_ptr<char[]> buffer;
+  uint64_t length = HttpEncoder::SerializeCapsuleFrame(capsule_frame, &buffer);
+  quiche::test::CompareCharArraysWithHexError("DATAGRAM", buffer.get(), length,
+                                              reinterpret_cast<char*>(output),
+                                              sizeof(output));
+}
+
+TEST(HttpEncoderTest, SerializeRegisterDatagramNoContextCapsule) {
+  CapsuleFrame capsule_frame(CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT);
+  uint8_t output[] = {0x80, 0xff, 0xca, 0xb5,  // type (CAPSULE)
+                      0x01,                    // frame length.
+                      0x03};  // capsule type (REGISTER_DATAGRAM_NO_CONTEXT).
+  std::unique_ptr<char[]> buffer;
+  uint64_t length = HttpEncoder::SerializeCapsuleFrame(capsule_frame, &buffer);
+  quiche::test::CompareCharArraysWithHexError(
+      "REGISTER_DATAGRAM_NO_CONTEXT", buffer.get(), length,
+      reinterpret_cast<char*>(output), sizeof(output));
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/http/http_frames.h b/quic/core/http/http_frames.h
index 6a00ad7..d678062 100644
--- a/quic/core/http/http_frames.h
+++ b/quic/core/http/http_frames.h
@@ -7,6 +7,7 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <limits>
 #include <map>
 #include <ostream>
 #include <sstream>
@@ -14,6 +15,7 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "quic/core/http/http_constants.h"
 #include "quic/core/quic_types.h"
 #include "spdy/core/spdy_protocol.h"
@@ -37,6 +39,8 @@
   PRIORITY_UPDATE_REQUEST_STREAM = 0xF0700,
   // https://www.ietf.org/archive/id/draft-ietf-webtrans-http3-00.html
   WEBTRANSPORT_STREAM = 0x41,
+  // https://datatracker.ietf.org/doc/html/draft-ietf-masque-h3-datagram-03
+  CAPSULE = 0xffcab5,
 };
 
 // 7.2.1.  DATA
@@ -182,6 +186,179 @@
   }
 };
 
+enum class CapsuleType : uint64_t {
+  // Casing in this enum matches the IETF specification.
+  REGISTER_DATAGRAM_CONTEXT = 0x00,
+  CLOSE_DATAGRAM_CONTEXT = 0x01,
+  DATAGRAM = 0x02,
+  REGISTER_DATAGRAM_NO_CONTEXT = 0x03,
+};
+
+inline std::string CapsuleTypeToString(CapsuleType capsule_type) {
+  switch (capsule_type) {
+    case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+      return "REGISTER_DATAGRAM_CONTEXT";
+    case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+      return "CLOSE_DATAGRAM_CONTEXT";
+    case CapsuleType::DATAGRAM:
+      return "DATAGRAM";
+    case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+      return "REGISTER_DATAGRAM_NO_CONTEXT";
+  }
+  return absl::StrCat("Unknown(", static_cast<uint64_t>(capsule_type), ")");
+}
+
+inline std::ostream& operator<<(std::ostream& os,
+                                const CapsuleType& capsule_type) {
+  os << CapsuleTypeToString(capsule_type);
+  return os;
+}
+
+// CAPSULE HTTP frame from draft-ietf-masque-h3-datagram.
+struct QUIC_EXPORT_PRIVATE CapsuleFrame {
+  CapsuleType capsule_type;
+  union {
+    struct {
+      QuicDatagramContextId context_id;
+      absl::string_view context_extensions;
+    } register_datagram_context_capsule;
+    struct {
+      QuicDatagramContextId context_id;
+      absl::string_view context_extensions;
+    } close_datagram_context_capsule;
+    struct {
+      absl::optional<QuicDatagramContextId> context_id;
+      absl::string_view http_datagram_payload;
+    } datagram_capsule;
+    struct {
+      absl::string_view context_extensions;
+    } register_datagram_no_context_capsule;
+    absl::string_view unknown_capsule_data;
+  };
+
+  explicit CapsuleFrame(CapsuleType capsule_type) : capsule_type(capsule_type) {
+    switch (capsule_type) {
+      case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+        register_datagram_context_capsule.context_id = 0;
+        register_datagram_context_capsule.context_extensions =
+            absl::string_view();
+        break;
+      case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+        close_datagram_context_capsule.context_id = 0;
+        close_datagram_context_capsule.context_extensions = absl::string_view();
+        break;
+      case CapsuleType::DATAGRAM:
+        datagram_capsule.context_id = absl::nullopt;
+        datagram_capsule.http_datagram_payload = absl::string_view();
+        break;
+      case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+        register_datagram_no_context_capsule.context_extensions =
+            absl::string_view();
+        break;
+      default:
+        unknown_capsule_data = absl::string_view();
+        break;
+    }
+  }
+
+  CapsuleFrame()
+      : CapsuleFrame(
+            static_cast<CapsuleType>(std::numeric_limits<uint64_t>::max())) {}
+
+  CapsuleFrame& operator=(const CapsuleFrame& other) {
+    capsule_type = other.capsule_type;
+    switch (capsule_type) {
+      case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+        register_datagram_context_capsule.context_id =
+            other.register_datagram_context_capsule.context_id;
+        register_datagram_context_capsule.context_extensions =
+            other.register_datagram_context_capsule.context_extensions;
+        break;
+      case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+        close_datagram_context_capsule.context_id =
+            other.close_datagram_context_capsule.context_id;
+        close_datagram_context_capsule.context_extensions =
+            other.close_datagram_context_capsule.context_extensions;
+        break;
+      case CapsuleType::DATAGRAM:
+        datagram_capsule.context_id = other.datagram_capsule.context_id;
+        datagram_capsule.http_datagram_payload =
+            other.datagram_capsule.http_datagram_payload;
+        break;
+      case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+        register_datagram_no_context_capsule.context_extensions =
+            other.register_datagram_no_context_capsule.context_extensions;
+        break;
+      default:
+        unknown_capsule_data = other.unknown_capsule_data;
+        break;
+    }
+    return *this;
+  }
+
+  CapsuleFrame(const CapsuleFrame& other) : CapsuleFrame(other.capsule_type) {
+    *this = other;
+  }
+
+  bool operator==(const CapsuleFrame& other) const {
+    if (capsule_type != other.capsule_type) {
+      return false;
+    }
+    switch (capsule_type) {
+      case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+        return register_datagram_context_capsule.context_id ==
+                   other.register_datagram_context_capsule.context_id &&
+               register_datagram_context_capsule.context_extensions ==
+                   other.register_datagram_context_capsule.context_extensions;
+      case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+        return close_datagram_context_capsule.context_id ==
+                   other.close_datagram_context_capsule.context_id &&
+               close_datagram_context_capsule.context_extensions ==
+                   other.close_datagram_context_capsule.context_extensions;
+      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::REGISTER_DATAGRAM_NO_CONTEXT:
+        return register_datagram_no_context_capsule.context_extensions ==
+               other.register_datagram_no_context_capsule.context_extensions;
+      default:
+        return unknown_capsule_data == other.unknown_capsule_data;
+    }
+  }
+
+  std::string ToString() const {
+    std::string rv = CapsuleTypeToString(capsule_type);
+    switch (capsule_type) {
+      case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+        absl::StrAppend(&rv, "(", register_datagram_context_capsule.context_id,
+                        ")");
+        break;
+      case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+        absl::StrAppend(&rv, "(", close_datagram_context_capsule.context_id,
+                        ")");
+        break;
+      case CapsuleType::DATAGRAM:
+        if (datagram_capsule.context_id.has_value()) {
+          absl::StrAppend(&rv, "(", datagram_capsule.context_id.value(), ")");
+        }
+        break;
+      case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+        break;
+      default:
+        break;
+    }
+    return rv;
+  }
+
+  friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+      std::ostream& os, const CapsuleFrame& frame) {
+    os << frame.ToString();
+    return os;
+  }
+};
+
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_CORE_HTTP_HTTP_FRAMES_H_
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index 9c164d0..b36bc7f 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -200,6 +200,10 @@
   return true;
 }
 
+bool QuicReceiveControlStream::OnCapsuleFrame(const CapsuleFrame& /*frame*/) {
+  return ValidateFrameType(HttpFrameType::CAPSULE);
+}
+
 void QuicReceiveControlStream::OnWebTransportStreamFrameType(
     QuicByteCount /*header_length*/,
     WebTransportSessionId /*session_id*/) {
@@ -237,7 +241,8 @@
       (spdy_session()->perspective() == Perspective::IS_CLIENT &&
        frame_type == HttpFrameType::MAX_PUSH_ID) ||
       (spdy_session()->perspective() == Perspective::IS_SERVER &&
-       frame_type == HttpFrameType::ACCEPT_CH)) {
+       frame_type == HttpFrameType::ACCEPT_CH) ||
+      frame_type == HttpFrameType::CAPSULE) {
     stream_delegate()->OnStreamError(
         QUIC_HTTP_FRAME_UNEXPECTED_ON_CONTROL_STREAM,
         absl::StrCat("Invalid frame type ", static_cast<int>(frame_type),
diff --git a/quic/core/http/quic_receive_control_stream.h b/quic/core/http/quic_receive_control_stream.h
index 3c61d3c..3390df0 100644
--- a/quic/core/http/quic_receive_control_stream.h
+++ b/quic/core/http/quic_receive_control_stream.h
@@ -51,6 +51,7 @@
   bool OnPriorityUpdateFrame(const PriorityUpdateFrame& frame) override;
   bool OnAcceptChFrameStart(QuicByteCount header_length) override;
   bool OnAcceptChFrame(const AcceptChFrame& frame) override;
+  bool OnCapsuleFrame(const CapsuleFrame& frame) override;
   void OnWebTransportStreamFrameType(QuicByteCount header_length,
                                      WebTransportSessionId session_id) override;
   bool OnUnknownFrameStart(uint64_t frame_type,
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index 3066cb3..7823b0f 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -135,22 +135,24 @@
       "61");  //  payload "a"
   if (QuicSpdySessionPeer::ShouldNegotiateHttp3Datagram(&session_)) {
     expected_write_data = absl::HexStringToBytes(
-        "00"    // stream type: control stream
-        "04"    // frame type: SETTINGS frame
-        "0e"    // frame length
-        "01"    // SETTINGS_QPACK_MAX_TABLE_CAPACITY
-        "40ff"  // 255
-        "06"    // SETTINGS_MAX_HEADER_LIST_SIZE
-        "4400"  // 1024
-        "07"    // SETTINGS_QPACK_BLOCKED_STREAMS
-        "10"    // 16
-        "4040"  // 0x40 as the reserved settings id
-        "14"    // 20
-        "4276"  // SETTINGS_H3_DATAGRAM
-        "01"    // 1
-        "4040"  // 0x40 as the reserved frame type
-        "01"    // 1 byte frame length
-        "61");  //  payload "a"
+        "00"         // stream type: control stream
+        "04"         // frame type: SETTINGS frame
+        "0e"         // frame length
+        "01"         // SETTINGS_QPACK_MAX_TABLE_CAPACITY
+        "40ff"       // 255
+        "06"         // SETTINGS_MAX_HEADER_LIST_SIZE
+        "4400"       // 1024
+        "07"         // SETTINGS_QPACK_BLOCKED_STREAMS
+        "10"         // 16
+        "4040"       // 0x40 as the reserved settings id
+        "14"         // 20
+        "4276"       // SETTINGS_H3_DATAGRAM_DRAFT00
+        "01"         // 1
+        "800ffd276"  // SETTINGS_H3_DATAGRAM_DRAFT03
+        "01"         // 1
+        "4040"       // 0x40 as the reserved frame type
+        "01"         // 1 byte frame length
+        "61");       //  payload "a"
   }
 
   auto buffer = std::make_unique<char[]>(expected_write_data.size());
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index dc773ae..f01da54 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -135,6 +135,10 @@
     session_->OnAcceptChFrameReceivedViaAlps(frame);
     return true;
   }
+  bool OnCapsuleFrame(const CapsuleFrame& /*frame*/) override {
+    error_detail_ = "CAPSULE frame forbidden";
+    return false;
+  }
   void OnWebTransportStreamFrameType(
       QuicByteCount /*header_length*/,
       WebTransportSessionId /*session_id*/) override {
@@ -521,7 +525,8 @@
   settings_.values[SETTINGS_MAX_FIELD_SECTION_SIZE] =
       max_inbound_header_list_size_;
   if (ShouldNegotiateHttp3Datagram() && version().UsesHttp3()) {
-    settings_.values[SETTINGS_H3_DATAGRAM] = 1;
+    settings_.values[SETTINGS_H3_DATAGRAM_DRAFT00] = 1;
+    settings_.values[SETTINGS_H3_DATAGRAM_DRAFT03] = 1;
   }
   if (WillNegotiateWebTransport()) {
     settings_.values[SETTINGS_WEBTRANS_DRAFT00] = 1;
@@ -1126,24 +1131,59 @@
             absl::StrCat("received HTTP/2 specific setting in HTTP/3 session: ",
                          id));
         return false;
-      case SETTINGS_H3_DATAGRAM: {
+      case SETTINGS_H3_DATAGRAM_DRAFT00: {
         if (!ShouldNegotiateHttp3Datagram()) {
           break;
         }
-        QUIC_DVLOG(1) << ENDPOINT << "SETTINGS_H3_DATAGRAM received with value "
+        QUIC_DVLOG(1) << ENDPOINT
+                      << "SETTINGS_H3_DATAGRAM_DRAFT00 received with value "
                       << value;
         if (!version().UsesHttp3()) {
           break;
         }
         if (value != 0 && value != 1) {
           std::string error_details = absl::StrCat(
-              "received SETTINGS_H3_DATAGRAM with invalid value ", value);
-          QUIC_PEER_BUG(quic_peer_bug_10360_7) << ENDPOINT << error_details;
+              "received SETTINGS_H3_DATAGRAM_DRAFT00 with invalid value ",
+              value);
+          QUIC_PEER_BUG(bad SETTINGS_H3_DATAGRAM_DRAFT00)
+              << ENDPOINT << error_details;
           CloseConnectionWithDetails(QUIC_HTTP_RECEIVE_SPDY_SETTING,
                                      error_details);
           return false;
         }
-        h3_datagram_supported_ = !!value;
+        if (value && http_datagram_support_ != HttpDatagramSupport::kDraft03) {
+          // If both draft-00 and draft-03 are supported, use draft-03.
+          http_datagram_support_ = HttpDatagramSupport::kDraft00;
+#if 0
+          // DO_NOT_SUBMIT hack around Ericsson bug (they're sending 00 instead of 03):
+          http_datagram_support_ = HttpDatagramSupport::kDraft03;
+#endif  // 0
+        }
+        break;
+      }
+      case SETTINGS_H3_DATAGRAM_DRAFT03: {
+        if (!ShouldNegotiateHttp3Datagram()) {
+          break;
+        }
+        QUIC_DVLOG(1) << ENDPOINT
+                      << "SETTINGS_H3_DATAGRAM_DRAFT03 received with value "
+                      << value;
+        if (!version().UsesHttp3()) {
+          break;
+        }
+        if (value != 0 && value != 1) {
+          std::string error_details = absl::StrCat(
+              "received SETTINGS_H3_DATAGRAM_DRAFT03 with invalid value ",
+              value);
+          QUIC_PEER_BUG(bad SETTINGS_H3_DATAGRAM_DRAFT03)
+              << ENDPOINT << error_details;
+          CloseConnectionWithDetails(QUIC_HTTP_RECEIVE_SPDY_SETTING,
+                                     error_details);
+          return false;
+        }
+        if (value) {
+          http_datagram_support_ = HttpDatagramSupport::kDraft03;
+        }
         break;
       }
       case SETTINGS_WEBTRANS_DRAFT00:
@@ -1616,15 +1656,24 @@
     QuicDatagramStreamId stream_id,
     absl::optional<QuicDatagramContextId> context_id,
     absl::string_view payload) {
+  if (!SupportsH3Datagram()) {
+    QUIC_BUG(send http datagram too early)
+        << "Refusing to send HTTP Datagram before SETTINGS received";
+    return MESSAGE_STATUS_INTERNAL_ERROR;
+  }
+  uint64_t stream_id_to_write = stream_id;
+  if (http_datagram_support_ != HttpDatagramSupport::kDraft00) {
+    stream_id_to_write /= kHttpDatagramStreamIdDivisor;
+  }
   size_t slice_length =
-      QuicDataWriter::GetVarInt62Len(stream_id) + payload.length();
+      QuicDataWriter::GetVarInt62Len(stream_id_to_write) + payload.length();
   if (context_id.has_value()) {
     slice_length += QuicDataWriter::GetVarInt62Len(context_id.value());
   }
   QuicBuffer buffer(connection()->helper()->GetStreamSendBufferAllocator(),
                     slice_length);
   QuicDataWriter writer(slice_length, buffer.data());
-  if (!writer.WriteVarInt62(stream_id)) {
+  if (!writer.WriteVarInt62(stream_id_to_write)) {
     QUIC_BUG(h3 datagram stream ID write fail)
         << "Failed to write HTTP/3 datagram stream ID";
     return MESSAGE_STATUS_INTERNAL_ERROR;
@@ -1665,8 +1714,8 @@
 
 void QuicSpdySession::OnMessageReceived(absl::string_view message) {
   QuicSession::OnMessageReceived(message);
-  if (!h3_datagram_supported_) {
-    QUIC_DLOG(ERROR) << "Ignoring unexpected received HTTP/3 datagram";
+  if (!SupportsH3Datagram()) {
+    QUIC_DLOG(INFO) << "Ignoring unexpected received HTTP/3 datagram";
     return;
   }
   QuicDataReader reader(message);
@@ -1675,7 +1724,11 @@
     QUIC_DLOG(ERROR) << "Failed to parse stream ID in received HTTP/3 datagram";
     return;
   }
-  if (perspective() == Perspective::IS_SERVER) {
+  if (http_datagram_support_ != HttpDatagramSupport::kDraft00) {
+    stream_id64 *= kHttpDatagramStreamIdDivisor;
+  }
+  if (perspective() == Perspective::IS_SERVER &&
+      http_datagram_support_ == HttpDatagramSupport::kDraft00) {
     auto it = h3_datagram_flow_id_to_stream_id_map_.find(stream_id64);
     if (it == h3_datagram_flow_id_to_stream_id_map_.end()) {
       QUIC_DLOG(INFO) << "Received unknown HTTP/3 datagram flow ID "
@@ -1705,10 +1758,14 @@
 }
 
 bool QuicSpdySession::SupportsWebTransport() {
-  return WillNegotiateWebTransport() && h3_datagram_supported_ &&
+  return WillNegotiateWebTransport() && SupportsH3Datagram() &&
          peer_supports_webtransport_;
 }
 
+bool QuicSpdySession::SupportsH3Datagram() const {
+  return http_datagram_support_ != HttpDatagramSupport::kNone;
+}
+
 WebTransportHttp3* QuicSpdySession::GetWebTransportSession(
     WebTransportSessionId id) {
   if (!SupportsWebTransport()) {
@@ -1840,6 +1897,25 @@
   return false;
 }
 
+std::string HttpDatagramSupportToString(
+    HttpDatagramSupport http_datagram_support) {
+  switch (http_datagram_support) {
+    case HttpDatagramSupport::kNone:
+      return "None";
+    case HttpDatagramSupport::kDraft00:
+      return "Draft00";
+    case HttpDatagramSupport::kDraft03:
+      return "Draft03";
+  }
+  return absl::StrCat("Unknown(", static_cast<int>(http_datagram_support), ")");
+}
+
+std::ostream& operator<<(std::ostream& os,
+                         const HttpDatagramSupport& http_datagram_support) {
+  os << HttpDatagramSupportToString(http_datagram_support);
+  return os;
+}
+
 #undef ENDPOINT  // undef for jumbo builds
 
 }  // namespace quic
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 8085dd8..c471903 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_CORE_HTTP_QUIC_SPDY_SESSION_H_
 
 #include <cstddef>
+#include <cstdint>
 #include <list>
 #include <memory>
 #include <string>
@@ -119,6 +120,19 @@
   virtual void OnSettingsFrameResumed(const SettingsFrame& /*frame*/) {}
 };
 
+// Whether draft-ietf-masque-h3-datagram is supported on this session and if so
+// which draft is currently in use.
+enum class HttpDatagramSupport : uint8_t {
+  kNone = 0,  // HTTP Datagrams are not supported for this session.
+  kDraft00 = 1,
+  kDraft03 = 2,
+};
+
+QUIC_EXPORT_PRIVATE std::string HttpDatagramSupportToString(
+    HttpDatagramSupport http_datagram_support);
+QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+    std::ostream& os, const HttpDatagramSupport& http_datagram_support);
+
 // A QUIC session for HTTP.
 class QUIC_EXPORT_PRIVATE QuicSpdySession
     : public QuicSession,
@@ -374,9 +388,11 @@
   // extension.
   virtual void OnAcceptChFrameReceivedViaAlps(const AcceptChFrame& /*frame*/);
 
-  // Whether HTTP/3 datagrams are supported on this session, based on received
-  // SETTINGS.
-  bool h3_datagram_supported() const { return h3_datagram_supported_; }
+  // Whether HTTP datagrams are supported on this session and which draft is in
+  // use, based on received SETTINGS.
+  HttpDatagramSupport http_datagram_support() const {
+    return http_datagram_support_;
+  }
 
   // This must not be used except by QuicSpdyStream::SendHttp3Datagram.
   MessageStatus SendHttp3Datagram(
@@ -400,7 +416,7 @@
   bool SupportsWebTransport();
 
   // Indicates whether both the peer and us support HTTP/3 Datagrams.
-  bool SupportsH3Datagram() { return h3_datagram_supported_; }
+  bool SupportsH3Datagram() const;
 
   // Indicates whether the HTTP/3 session will indicate WebTransport support to
   // the peer.
@@ -654,8 +670,9 @@
   // frame has been sent yet.
   absl::optional<uint64_t> last_sent_http3_goaway_id_;
 
-  // Whether both this endpoint and our peer support HTTP/3 datagrams.
-  bool h3_datagram_supported_ = false;
+  // Whether both this endpoint and our peer support HTTP datagrams and which
+  // draft is in use for this session.
+  HttpDatagramSupport http_datagram_support_ = HttpDatagramSupport::kNone;
 
   // Whether the peer has indicated WebTransport support.
   bool peer_supports_webtransport_ = false;
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index c42b8ff..371a8c3 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -549,7 +549,7 @@
 
   void ReceiveWebTransportSettings() {
     SettingsFrame settings;
-    settings.values[SETTINGS_H3_DATAGRAM] = 1;
+    settings.values[SETTINGS_H3_DATAGRAM_DRAFT03] = 1;
     settings.values[SETTINGS_WEBTRANS_DRAFT00] = 1;
     std::string data =
         std::string(1, kControlStream) + EncodeSettings(settings);
@@ -573,8 +573,14 @@
     headers.OnHeaderBlockStart();
     headers.OnHeader(":method", "CONNECT");
     headers.OnHeader(":protocol", "webtransport");
-    headers.OnHeader("datagram-flow-id", absl::StrCat(session_id));
+    if (session_.http_datagram_support() == HttpDatagramSupport::kDraft00) {
+      headers.OnHeader("datagram-flow-id", absl::StrCat(session_id));
+    }
     stream->OnStreamHeaderList(/*fin=*/true, 0, headers);
+    if (session_.http_datagram_support() == HttpDatagramSupport::kDraft03) {
+      stream->OnCapsuleFrame(
+          CapsuleFrame(CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT));
+    }
     WebTransportHttp3* web_transport =
         session_.GetWebTransportSession(session_id);
     ASSERT_TRUE(web_transport != nullptr);
@@ -3404,16 +3410,17 @@
   EXPECT_EQ("multiple SETTINGS frames", error.value());
 }
 
-TEST_P(QuicSpdySessionTestClient, H3DatagramSetting) {
+TEST_P(QuicSpdySessionTestClient, HttpDatagramSettingDraft00) {
   if (!version().UsesHttp3()) {
     return;
   }
   session_.set_should_negotiate_h3_datagram(true);
   // HTTP/3 datagrams aren't supported before SETTINGS are received.
-  EXPECT_FALSE(session_.h3_datagram_supported());
+  EXPECT_FALSE(session_.SupportsH3Datagram());
+  EXPECT_EQ(session_.http_datagram_support(), HttpDatagramSupport::kNone);
   // Receive SETTINGS.
   SettingsFrame settings;
-  settings.values[SETTINGS_H3_DATAGRAM] = 1;
+  settings.values[SETTINGS_H3_DATAGRAM_DRAFT00] = 1;
   std::string data = std::string(1, kControlStream) + EncodeSettings(settings);
   QuicStreamId stream_id =
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 3);
@@ -3424,7 +3431,59 @@
   EXPECT_CALL(debug_visitor, OnSettingsFrameReceived(settings));
   session_.OnStreamFrame(frame);
   // HTTP/3 datagrams are now supported.
-  EXPECT_TRUE(session_.h3_datagram_supported());
+  EXPECT_TRUE(session_.SupportsH3Datagram());
+  EXPECT_EQ(session_.http_datagram_support(), HttpDatagramSupport::kDraft00);
+}
+
+TEST_P(QuicSpdySessionTestClient, HttpDatagramSettingDraft03) {
+  if (!version().UsesHttp3()) {
+    return;
+  }
+  session_.set_should_negotiate_h3_datagram(true);
+  // HTTP/3 datagrams aren't supported before SETTINGS are received.
+  EXPECT_FALSE(session_.SupportsH3Datagram());
+  EXPECT_EQ(session_.http_datagram_support(), HttpDatagramSupport::kNone);
+  // Receive SETTINGS.
+  SettingsFrame settings;
+  settings.values[SETTINGS_H3_DATAGRAM_DRAFT03] = 1;
+  std::string data = std::string(1, kControlStream) + EncodeSettings(settings);
+  QuicStreamId stream_id =
+      GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 3);
+  QuicStreamFrame frame(stream_id, /*fin=*/false, /*offset=*/0, data);
+  StrictMock<MockHttp3DebugVisitor> debug_visitor;
+  session_.set_debug_visitor(&debug_visitor);
+  EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(stream_id));
+  EXPECT_CALL(debug_visitor, OnSettingsFrameReceived(settings));
+  session_.OnStreamFrame(frame);
+  // HTTP/3 datagrams are now supported.
+  EXPECT_TRUE(session_.SupportsH3Datagram());
+  EXPECT_EQ(session_.http_datagram_support(), HttpDatagramSupport::kDraft03);
+}
+
+TEST_P(QuicSpdySessionTestClient, HttpDatagramSettingDraft00And03) {
+  if (!version().UsesHttp3()) {
+    return;
+  }
+  session_.set_should_negotiate_h3_datagram(true);
+  // HTTP/3 datagrams aren't supported before SETTINGS are received.
+  EXPECT_FALSE(session_.SupportsH3Datagram());
+  EXPECT_EQ(session_.http_datagram_support(), HttpDatagramSupport::kNone);
+  // Receive SETTINGS.
+  SettingsFrame settings;
+  settings.values[SETTINGS_H3_DATAGRAM_DRAFT00] = 1;
+  settings.values[SETTINGS_H3_DATAGRAM_DRAFT03] = 1;
+  std::string data = std::string(1, kControlStream) + EncodeSettings(settings);
+  QuicStreamId stream_id =
+      GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 3);
+  QuicStreamFrame frame(stream_id, /*fin=*/false, /*offset=*/0, data);
+  StrictMock<MockHttp3DebugVisitor> debug_visitor;
+  session_.set_debug_visitor(&debug_visitor);
+  EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(stream_id));
+  EXPECT_CALL(debug_visitor, OnSettingsFrameReceived(settings));
+  session_.OnStreamFrame(frame);
+  // HTTP/3 datagrams are now supported.
+  EXPECT_TRUE(session_.SupportsH3Datagram());
+  EXPECT_EQ(session_.http_datagram_support(), HttpDatagramSupport::kDraft03);
 }
 
 TEST_P(QuicSpdySessionTestClient, WebTransportSetting) {
@@ -3444,7 +3503,7 @@
   CompleteHandshake();
 
   SettingsFrame server_settings;
-  server_settings.values[SETTINGS_H3_DATAGRAM] = 1;
+  server_settings.values[SETTINGS_H3_DATAGRAM_DRAFT03] = 1;
   server_settings.values[SETTINGS_WEBTRANS_DRAFT00] = 1;
   std::string data =
       std::string(1, kControlStream) + EncodeSettings(server_settings);
@@ -3474,7 +3533,7 @@
   CompleteHandshake();
 
   SettingsFrame server_settings;
-  server_settings.values[SETTINGS_H3_DATAGRAM] = 1;
+  server_settings.values[SETTINGS_H3_DATAGRAM_DRAFT03] = 1;
   server_settings.values[SETTINGS_WEBTRANS_DRAFT00] = 0;
   std::string data =
       std::string(1, kControlStream) + EncodeSettings(server_settings);
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index bc23474..810994e 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -15,6 +15,7 @@
 #include "absl/strings/string_view.h"
 #include "quic/core/http/http_constants.h"
 #include "quic/core/http/http_decoder.h"
+#include "quic/core/http/http_frames.h"
 #include "quic/core/http/quic_spdy_session.h"
 #include "quic/core/http/spdy_utils.h"
 #include "quic/core/http/web_transport_http3.h"
@@ -128,6 +129,10 @@
     return false;
   }
 
+  bool OnCapsuleFrame(const CapsuleFrame& frame) override {
+    return stream_->OnCapsuleFrame(frame);
+  }
+
   void OnWebTransportStreamFrameType(
       QuicByteCount header_length,
       WebTransportSessionId session_id) override {
@@ -287,6 +292,13 @@
     SetFinSent();
     CloseWriteSide();
   }
+
+  if (session()->perspective() == Perspective::IS_CLIENT && web_transport_) {
+    RegisterHttp3DatagramContextId(web_transport_->context_id(),
+                                   Http3DatagramContextExtensions(),
+                                   web_transport_.get());
+  }
+
   return bytes_written;
 }
 
@@ -1206,6 +1218,13 @@
       protocol = header_value;
     }
     if (header_name == "datagram-flow-id") {
+      if (spdy_session_->http_datagram_support() !=
+          HttpDatagramSupport::kDraft00) {
+        QUIC_DLOG(ERROR) << ENDPOINT
+                         << "Rejecting WebTransport due to unexpected "
+                            "Datagram-Flow-Id header";
+        return;
+      }
       if (flow_id.has_value() || header_value.empty()) {
         return;
       }
@@ -1217,16 +1236,26 @@
     }
   }
 
-  if (method != "CONNECT" || protocol != "webtransport" ||
-      !flow_id.has_value()) {
+  if (method != "CONNECT" || protocol != "webtransport") {
     return;
   }
 
-  RegisterHttp3DatagramFlowId(*flow_id);
+  if (spdy_session_->http_datagram_support() == HttpDatagramSupport::kDraft00) {
+    if (!flow_id.has_value()) {
+      QUIC_DLOG(ERROR)
+          << ENDPOINT
+          << "Rejecting WebTransport due to missing Datagram-Flow-Id header";
+      return;
+    }
+    RegisterHttp3DatagramFlowId(*flow_id);
+  }
 
   web_transport_ =
       std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
 
+  if (spdy_session_->http_datagram_support() != HttpDatagramSupport::kDraft00) {
+    return;
+  }
   // If we're in draft-ietf-masque-h3-datagram-00 mode, pretend we also received
   // a REGISTER_DATAGRAM_NO_CONTEXT capsule with no extensions.
   // TODO(b/181256914) remove this when we remove support for
@@ -1255,14 +1284,12 @@
     return;
   }
 
-  QuicDatagramStreamId stream_id = id();
-  headers["datagram-flow-id"] = absl::StrCat(stream_id);
+  if (spdy_session_->http_datagram_support() == HttpDatagramSupport::kDraft00) {
+    headers["datagram-flow-id"] = absl::StrCat(id());
+  }
 
   web_transport_ =
       std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
-  RegisterHttp3DatagramContextId(web_transport_->context_id(),
-                                 Http3DatagramContextExtensions(),
-                                 web_transport_.get());
 }
 
 void QuicSpdyStream::OnCanWriteNewData() {
@@ -1323,6 +1350,79 @@
     : session_id(session_id),
       adapter(stream->spdy_session_, stream, stream->sequencer()) {}
 
+bool QuicSpdyStream::OnCapsuleFrame(const CapsuleFrame& frame) {
+  QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id() << " received capsule "
+                  << frame;
+  if (!headers_decompressed_) {
+    QUIC_PEER_BUG(capsule before headers)
+        << ENDPOINT << "Stream " << id() << " received capsule " << frame
+        << " before headers";
+    return false;
+  }
+  switch (frame.capsule_type) {
+    case CapsuleType::REGISTER_DATAGRAM_CONTEXT:
+      if (datagram_registration_visitor_ == nullptr) {
+        QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << frame
+                         << " without any registration visitor";
+        return false;
+      }
+      datagram_registration_visitor_->OnContextReceived(
+          id(), frame.register_datagram_context_capsule.context_id,
+          Http3DatagramContextExtensions());
+      break;
+    case CapsuleType::CLOSE_DATAGRAM_CONTEXT:
+      if (datagram_registration_visitor_ == nullptr) {
+        QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << frame
+                         << " without any registration visitor";
+        return false;
+      }
+      datagram_registration_visitor_->OnContextClosed(
+          id(), frame.close_datagram_context_capsule.context_id,
+          Http3DatagramContextExtensions());
+      break;
+    case CapsuleType::DATAGRAM: {
+      Http3DatagramVisitor* visitor = nullptr;
+      if (frame.datagram_capsule.context_id.has_value()) {
+        auto it = datagram_context_visitors_.find(
+            frame.datagram_capsule.context_id.value());
+        if (it != datagram_context_visitors_.end()) {
+          visitor = it->second;
+        }
+      } else {
+        visitor = datagram_no_context_visitor_;
+      }
+      if (visitor == nullptr) {
+        QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << frame
+                         << " without any registration visitor";
+        return true;
+      }
+      visitor->OnHttp3Datagram(id(), frame.datagram_capsule.context_id,
+                               frame.datagram_capsule.http_datagram_payload);
+    } break;
+    case CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT:
+      if (datagram_registration_visitor_ == nullptr) {
+        QUIC_DLOG(ERROR) << ENDPOINT << "Received capsule " << frame
+                         << " without any registration visitor";
+        return false;
+      }
+      datagram_registration_visitor_->OnContextReceived(
+          id(), /*context_id=*/absl::nullopt, Http3DatagramContextExtensions());
+      break;
+  }
+  return true;
+}
+
+void QuicSpdyStream::WriteCapsuleFrame(const CapsuleFrame& frame) {
+  QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id() << " sending capsule "
+                  << frame;
+  std::unique_ptr<char[]> buffer;
+  QuicByteCount frame_length =
+      HttpEncoder::SerializeCapsuleFrame(frame, &buffer);
+  QUICHE_DCHECK_GT(frame_length, 0u);
+  WriteOrBufferData(absl::string_view(buffer.get(), frame_length),
+                    /*fin=*/false, /*ack_listener=*/nullptr);
+}
+
 MessageStatus QuicSpdyStream::SendHttp3Datagram(
     absl::optional<QuicDatagramContextId> context_id,
     absl::string_view payload) {
@@ -1368,19 +1468,22 @@
   if (visitor == nullptr) {
     QUIC_BUG(null datagram visitor)
         << ENDPOINT << "Null datagram visitor for stream ID " << id()
-        << " context ID " << (context_id.has_value() ? context_id.value() : 0);
+        << " context ID "
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none");
     return;
   }
   if (datagram_registration_visitor_ == nullptr) {
     QUIC_BUG(context registration without registration visitor)
         << ENDPOINT << "Cannot register context ID "
-        << (context_id.has_value() ? context_id.value() : 0)
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none")
         << " without registration visitor for stream ID " << id();
     return;
   }
   QUIC_DLOG(INFO) << ENDPOINT << "Registering datagram context ID "
-                  << (context_id.has_value() ? context_id.value() : 0)
+                  << (context_id.has_value() ? absl::StrCat(context_id.value())
+                                             : "none")
                   << " with stream ID " << id();
+
   if (context_id.has_value()) {
     if (datagram_no_context_visitor_ != nullptr) {
       QUIC_BUG(h3 datagram context ID mix1)
@@ -1392,28 +1495,45 @@
     }
     auto insertion_result =
         datagram_context_visitors_.insert({context_id.value(), visitor});
-    QUIC_BUG_IF(h3 datagram double context registration,
-                !insertion_result.second)
-        << ENDPOINT << "Attempted to doubly register HTTP/3 stream ID " << id()
-        << " context ID " << context_id.value();
-    return;
+    if (!insertion_result.second) {
+      QUIC_BUG(h3 datagram double context registration)
+          << ENDPOINT << "Attempted to doubly register HTTP/3 stream ID "
+          << id() << " context ID " << context_id.value();
+      return;
+    }
+  } else {
+    // Registration without a context ID.
+    if (!datagram_context_visitors_.empty()) {
+      QUIC_BUG(h3 datagram context ID mix2)
+          << ENDPOINT
+          << "Attempted to mix registrations with and without context IDs "
+             "for stream ID "
+          << id();
+      return;
+    }
+    if (datagram_no_context_visitor_ != nullptr) {
+      QUIC_BUG(h3 datagram double no context registration)
+          << ENDPOINT << "Attempted to doubly register HTTP/3 stream ID "
+          << id() << " with no context ID";
+      return;
+    }
+    datagram_no_context_visitor_ = visitor;
   }
-  // Registration without a context ID.
-  if (!datagram_context_visitors_.empty()) {
-    QUIC_BUG(h3 datagram context ID mix2)
-        << ENDPOINT
-        << "Attempted to mix registrations with and without context IDs "
-           "for stream ID "
-        << id();
-    return;
+  if (spdy_session_->http_datagram_support() == HttpDatagramSupport::kDraft03) {
+    const bool is_client = session()->perspective() == Perspective::IS_CLIENT;
+    if (context_id.has_value()) {
+      const bool is_client_context = context_id.value() % 2 == 0;
+      if (is_client == is_client_context) {
+        CapsuleFrame capsule_frame(CapsuleType::REGISTER_DATAGRAM_CONTEXT);
+        capsule_frame.register_datagram_context_capsule.context_id =
+            context_id.value();
+        WriteCapsuleFrame(capsule_frame);
+      }
+    } else if (is_client) {
+      WriteCapsuleFrame(
+          CapsuleFrame(CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT));
+    }
   }
-  if (datagram_no_context_visitor_ != nullptr) {
-    QUIC_BUG(h3 datagram double no context registration)
-        << ENDPOINT << "Attempted to doubly register HTTP/3 stream ID " << id()
-        << " with no context ID";
-    return;
-  }
-  datagram_no_context_visitor_ = visitor;
 }
 
 void QuicSpdyStream::UnregisterHttp3DatagramContextId(
@@ -1421,26 +1541,34 @@
   if (datagram_registration_visitor_ == nullptr) {
     QUIC_BUG(context unregistration without registration visitor)
         << ENDPOINT << "Cannot unregister context ID "
-        << (context_id.has_value() ? context_id.value() : 0)
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none")
         << " without registration visitor for stream ID " << id();
     return;
   }
   QUIC_DLOG(INFO) << ENDPOINT << "Unregistering datagram context ID "
-                  << (context_id.has_value() ? context_id.value() : 0)
+                  << (context_id.has_value() ? absl::StrCat(context_id.value())
+                                             : "none")
                   << " with stream ID " << id();
   if (context_id.has_value()) {
     size_t num_erased = datagram_context_visitors_.erase(context_id.value());
     QUIC_BUG_IF(h3 datagram unregister unknown context, num_erased != 1)
         << "Attempted to unregister unknown HTTP/3 context ID "
         << context_id.value() << " on stream ID " << id();
-    return;
+  } else {
+    // Unregistration without a context ID.
+    QUIC_BUG_IF(h3 datagram unknown context unregistration,
+                datagram_no_context_visitor_ == nullptr)
+        << "Attempted to unregister unknown no context on HTTP/3 stream ID "
+        << id();
+    datagram_no_context_visitor_ = nullptr;
   }
-  // Unregistration without a context ID.
-  QUIC_BUG_IF(h3 datagram unknown context unregistration,
-              datagram_no_context_visitor_ == nullptr)
-      << "Attempted to unregister unknown no context on HTTP/3 stream ID "
-      << id();
-  datagram_no_context_visitor_ = nullptr;
+  if (spdy_session_->http_datagram_support() == HttpDatagramSupport::kDraft03 &&
+      context_id.has_value()) {
+    CapsuleFrame capsule_frame(CapsuleType::CLOSE_DATAGRAM_CONTEXT);
+    capsule_frame.close_datagram_context_capsule.context_id =
+        context_id.value();
+    WriteCapsuleFrame(capsule_frame);
+  }
 }
 
 void QuicSpdyStream::MoveHttp3DatagramContextIdRegistration(
@@ -1449,12 +1577,13 @@
   if (datagram_registration_visitor_ == nullptr) {
     QUIC_BUG(context move without registration visitor)
         << ENDPOINT << "Cannot move context ID "
-        << (context_id.has_value() ? context_id.value() : 0)
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none")
         << " without registration visitor for stream ID " << id();
     return;
   }
   QUIC_DLOG(INFO) << ENDPOINT << "Moving datagram context ID "
-                  << (context_id.has_value() ? context_id.value() : 0)
+                  << (context_id.has_value() ? absl::StrCat(context_id.value())
+                                             : "none")
                   << " with stream ID " << id();
   if (context_id.has_value()) {
     QUIC_BUG_IF(h3 datagram move unknown context,
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 4df1196..d9a784d 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -21,6 +21,7 @@
 #include "absl/types/span.h"
 #include "quic/core/http/http_decoder.h"
 #include "quic/core/http/http_encoder.h"
+#include "quic/core/http/http_frames.h"
 #include "quic/core/http/quic_header_list.h"
 #include "quic/core/http/quic_spdy_stream_body_manager.h"
 #include "quic/core/qpack/qpack_decoded_headers_accumulator.h"
@@ -253,6 +254,8 @@
   // rejected due to buffer being full.  |write_size| must be non-zero.
   bool CanWriteNewBodyData(QuicByteCount write_size) const;
 
+  bool OnCapsuleFrame(const CapsuleFrame& frame);
+
   // Sends an HTTP/3 datagram. The stream and context IDs are not part of
   // |payload|.
   MessageStatus SendHttp3Datagram(
@@ -410,6 +413,8 @@
   ABSL_MUST_USE_RESULT bool WriteDataFrameHeader(QuicByteCount data_length,
                                                  bool force_write);
 
+  void WriteCapsuleFrame(const CapsuleFrame& frame);
+
   QuicSpdySession* spdy_session_;
 
   bool on_body_available_called_because_sequencer_is_closed_;
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index c19dc3c..50e4905 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -16,6 +16,7 @@
 #include "absl/strings/string_view.h"
 #include "quic/core/crypto/null_encrypter.h"
 #include "quic/core/http/http_encoder.h"
+#include "quic/core/http/quic_spdy_session.h"
 #include "quic/core/http/spdy_utils.h"
 #include "quic/core/http/web_transport_http3.h"
 #include "quic/core/quic_connection.h"
@@ -3017,7 +3018,7 @@
   }
 }
 
-TEST_P(QuicSpdyStreamTest, ProcessOutgoingWebTransportHeaders) {
+TEST_P(QuicSpdyStreamTest, ProcessOutgoingWebTransportHeadersDatagramDraft00) {
   if (!UsesHttp3()) {
     return;
   }
@@ -3025,7 +3026,9 @@
   InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
   session_->set_should_negotiate_h3_datagram(true);
   session_->EnableWebTransport();
-  QuicSpdySessionPeer::EnableWebTransport(*session_);
+  QuicSpdySessionPeer::EnableWebTransport(session_.get());
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft00);
 
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _))
@@ -3040,7 +3043,31 @@
   EXPECT_EQ(stream_->id(), stream_->web_transport()->id());
 }
 
-TEST_P(QuicSpdyStreamTest, ProcessIncomingWebTransportHeaders) {
+TEST_P(QuicSpdyStreamTest, ProcessOutgoingWebTransportHeadersDatagramDraft03) {
+  if (!UsesHttp3()) {
+    return;
+  }
+
+  InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
+  session_->set_should_negotiate_h3_datagram(true);
+  session_->EnableWebTransport();
+  QuicSpdySessionPeer::EnableWebTransport(session_.get());
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft03);
+
+  EXPECT_CALL(*stream_, WriteHeadersMock(false));
+  EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _))
+      .Times(AnyNumber());
+
+  spdy::SpdyHeaderBlock headers;
+  headers[":method"] = "CONNECT";
+  headers[":protocol"] = "webtransport";
+  stream_->WriteHeaders(std::move(headers), /*fin=*/false, nullptr);
+  ASSERT_TRUE(stream_->web_transport() != nullptr);
+  EXPECT_EQ(stream_->id(), stream_->web_transport()->id());
+}
+
+TEST_P(QuicSpdyStreamTest, ProcessIncomingWebTransportHeadersDraft03) {
   if (!UsesHttp3()) {
     return;
   }
@@ -3048,7 +3075,36 @@
   Initialize(kShouldProcessData);
   session_->set_should_negotiate_h3_datagram(true);
   session_->EnableWebTransport();
-  QuicSpdySessionPeer::EnableWebTransport(*session_);
+  QuicSpdySessionPeer::EnableWebTransport(session_.get());
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft03);
+
+  headers_[":method"] = "CONNECT";
+  headers_[":protocol"] = "webtransport";
+
+  stream_->OnStreamHeadersPriority(
+      spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  ProcessHeaders(false, headers_);
+  CapsuleFrame capsule_frame(CapsuleType::REGISTER_DATAGRAM_NO_CONTEXT);
+  stream_->OnCapsuleFrame(capsule_frame);
+  EXPECT_EQ("", stream_->data());
+  EXPECT_FALSE(stream_->header_list().empty());
+  EXPECT_FALSE(stream_->IsDoneReading());
+  ASSERT_TRUE(stream_->web_transport() != nullptr);
+  EXPECT_EQ(stream_->id(), stream_->web_transport()->id());
+}
+
+TEST_P(QuicSpdyStreamTest, ProcessIncomingWebTransportHeadersDraft00) {
+  if (!UsesHttp3()) {
+    return;
+  }
+
+  Initialize(kShouldProcessData);
+  session_->set_should_negotiate_h3_datagram(true);
+  session_->EnableWebTransport();
+  QuicSpdySessionPeer::EnableWebTransport(session_.get());
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft00);
 
   headers_[":method"] = "CONNECT";
   headers_[":protocol"] = "webtransport";
@@ -3075,7 +3131,9 @@
   Initialize(kShouldProcessData);
   session_->set_should_negotiate_h3_datagram(true);
   session_->EnableWebTransport();
-  QuicSpdySessionPeer::EnableWebTransport(*session_);
+  QuicSpdySessionPeer::EnableWebTransport(session_.get());
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft00);
 
   headers_[":method"] = "CONNECT";
   headers_[":protocol"] = "webtransport";
@@ -3119,13 +3177,14 @@
   stream_->UnregisterHttp3DatagramRegistrationVisitor();
 }
 
-TEST_P(QuicSpdyStreamTest, H3DatagramRegistrationWithoutContext) {
+TEST_P(QuicSpdyStreamTest, HttpDatagramRegistrationWithoutContextDraft00) {
   if (!UsesHttp3()) {
     return;
   }
-  Initialize(kShouldProcessData);
+  InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
   session_->set_should_negotiate_h3_datagram(true);
-  QuicSpdySessionPeer::SetH3DatagramSupported(session_.get(), true);
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft00);
   session_->RegisterHttp3DatagramFlowId(stream_->id(), stream_->id());
   ::testing::NiceMock<MockHttp3DatagramRegistrationVisitor>
       h3_datagram_registration_visitor;
@@ -3168,23 +3227,39 @@
   session_->UnregisterHttp3DatagramFlowId(stream_->id());
 }
 
-TEST_P(QuicSpdyStreamTest, H3DatagramRegistrationWithContext) {
+TEST_P(QuicSpdyStreamTest, H3DatagramRegistrationWithoutContextDraft03) {
   if (!UsesHttp3()) {
     return;
   }
-  Initialize(kShouldProcessData);
+  InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
   session_->set_should_negotiate_h3_datagram(true);
-  QuicSpdySessionPeer::SetH3DatagramSupported(session_.get(), true);
-  session_->RegisterHttp3DatagramFlowId(stream_->id(), stream_->id());
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft03);
   ::testing::NiceMock<MockHttp3DatagramRegistrationVisitor>
       h3_datagram_registration_visitor;
   SavingHttp3DatagramVisitor h3_datagram_visitor;
-  absl::optional<QuicDatagramContextId> context_id = 42;
+  absl::optional<QuicDatagramContextId> context_id;
   Http3DatagramContextExtensions extensions;
+  ASSERT_EQ(QuicDataWriter::GetVarInt62Len(stream_->id()), 1);
+  std::array<char, 256> datagram;
+  datagram[0] = stream_->id();
+  for (size_t i = 1; i < datagram.size(); i++) {
+    datagram[i] = i;
+  }
   stream_->RegisterHttp3DatagramRegistrationVisitor(
       &h3_datagram_registration_visitor);
+
+  // Expect us to send a REGISTER_DATAGRAM_NO_CONTEXT capsule.
+  EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _));
+
   stream_->RegisterHttp3DatagramContextId(context_id, extensions,
                                           &h3_datagram_visitor);
+  session_->OnMessageReceived(
+      absl::string_view(datagram.data(), datagram.size()));
+  EXPECT_THAT(h3_datagram_visitor.received_h3_datagrams(),
+              ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
+                  stream_->id(), context_id,
+                  std::string(&datagram[1], datagram.size() - 1)}));
   // Test move.
   ::testing::NiceMock<MockHttp3DatagramRegistrationVisitor>
       h3_datagram_registration_visitor2;
@@ -3192,9 +3267,72 @@
   SavingHttp3DatagramVisitor h3_datagram_visitor2;
   stream_->MoveHttp3DatagramContextIdRegistration(context_id,
                                                   &h3_datagram_visitor2);
+  EXPECT_TRUE(h3_datagram_visitor2.received_h3_datagrams().empty());
+  session_->OnMessageReceived(
+      absl::string_view(datagram.data(), datagram.size()));
+  EXPECT_THAT(h3_datagram_visitor2.received_h3_datagrams(),
+              ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
+                  stream_->id(), context_id,
+                  std::string(&datagram[1], datagram.size() - 1)}));
   // Cleanup.
   stream_->UnregisterHttp3DatagramContextId(context_id);
   stream_->UnregisterHttp3DatagramRegistrationVisitor();
+}
+
+TEST_P(QuicSpdyStreamTest, HttpDatagramRegistrationWithContext) {
+  if (!UsesHttp3()) {
+    return;
+  }
+  InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
+  session_->set_should_negotiate_h3_datagram(true);
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft03);
+  ::testing::NiceMock<MockHttp3DatagramRegistrationVisitor>
+      h3_datagram_registration_visitor;
+  SavingHttp3DatagramVisitor h3_datagram_visitor;
+  absl::optional<QuicDatagramContextId> context_id = 42;
+  Http3DatagramContextExtensions extensions;
+  ASSERT_EQ(QuicDataWriter::GetVarInt62Len(stream_->id()), 1);
+  std::array<char, 256> datagram;
+  datagram[0] = stream_->id();
+  datagram[1] = context_id.value();
+  for (size_t i = 2; i < datagram.size(); i++) {
+    datagram[i] = i;
+  }
+  stream_->RegisterHttp3DatagramRegistrationVisitor(
+      &h3_datagram_registration_visitor);
+
+  // Expect us to send a REGISTER_DATAGRAM_CONTEXT capsule.
+  EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _));
+
+  stream_->RegisterHttp3DatagramContextId(context_id, extensions,
+                                          &h3_datagram_visitor);
+  session_->OnMessageReceived(
+      absl::string_view(datagram.data(), datagram.size()));
+  EXPECT_THAT(h3_datagram_visitor.received_h3_datagrams(),
+              ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
+                  stream_->id(), context_id,
+                  std::string(&datagram[2], datagram.size() - 2)}));
+  // Test move.
+  ::testing::NiceMock<MockHttp3DatagramRegistrationVisitor>
+      h3_datagram_registration_visitor2;
+  stream_->MoveHttp3DatagramRegistration(&h3_datagram_registration_visitor2);
+  SavingHttp3DatagramVisitor h3_datagram_visitor2;
+  stream_->MoveHttp3DatagramContextIdRegistration(context_id,
+                                                  &h3_datagram_visitor2);
+  EXPECT_TRUE(h3_datagram_visitor2.received_h3_datagrams().empty());
+  session_->OnMessageReceived(
+      absl::string_view(datagram.data(), datagram.size()));
+  EXPECT_THAT(h3_datagram_visitor2.received_h3_datagrams(),
+              ElementsAre(SavingHttp3DatagramVisitor::SavedHttp3Datagram{
+                  stream_->id(), context_id,
+                  std::string(&datagram[2], datagram.size() - 2)}));
+  // Cleanup.
+
+  // Expect us to send a CLOSE_DATAGRAM_CONTEXT capsule.
+  EXPECT_CALL(*session_, WritevData(stream_->id(), _, _, _, _, _));
+  stream_->UnregisterHttp3DatagramContextId(context_id);
+  stream_->UnregisterHttp3DatagramRegistrationVisitor();
   session_->UnregisterHttp3DatagramFlowId(stream_->id());
 }
 
@@ -3204,7 +3342,8 @@
   }
   Initialize(kShouldProcessData);
   session_->set_should_negotiate_h3_datagram(true);
-  QuicSpdySessionPeer::SetH3DatagramSupported(session_.get(), true);
+  QuicSpdySessionPeer::SetHttpDatagramSupport(session_.get(),
+                                              HttpDatagramSupport::kDraft03);
   absl::optional<QuicDatagramContextId> context_id;
   std::string h3_datagram_payload = {1, 2, 3, 4, 5, 6};
   EXPECT_CALL(*connection_, SendMessage(1, _, false))
diff --git a/quic/core/quic_constants.h b/quic/core/quic_constants.h
index 162de89..97f7567 100644
--- a/quic/core/quic_constants.h
+++ b/quic/core/quic_constants.h
@@ -301,6 +301,10 @@
   kDatagramContextIdIncrement = 2,
 };
 
+enum : uint64_t {
+  kHttpDatagramStreamIdDivisor = 4,
+};
+
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_CORE_QUIC_CONSTANTS_H_
diff --git a/quic/masque/masque_client_session.cc b/quic/masque/masque_client_session.cc
index 0d86569..f3c70e2 100644
--- a/quic/masque/masque_client_session.cc
+++ b/quic/masque/masque_client_session.cc
@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 #include "quic/masque/masque_client_session.h"
+
 #include "absl/algorithm/container.h"
+#include "absl/strings/str_cat.h"
 #include "quic/core/http/spdy_utils.h"
 #include "quic/core/quic_data_reader.h"
 #include "quic/core/quic_utils.h"
@@ -101,7 +103,9 @@
   headers[":scheme"] = "masque";
   headers[":path"] = "/";
   headers[":authority"] = target_server_address.ToString();
-  SpdyUtils::AddDatagramFlowIdHeader(&headers, stream->id());
+  if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
+    SpdyUtils::AddDatagramFlowIdHeader(&headers, stream->id());
+  }
   size_t bytes_sent =
       stream->SendRequest(std::move(headers), /*body=*/"", /*fin=*/false);
   if (bytes_sent == 0) {
@@ -142,8 +146,8 @@
                 << " compressed with stream ID " << connect_udp->stream()->id()
                 << " context ID "
                 << (connect_udp->context_id().has_value()
-                        ? connect_udp->context_id().value()
-                        : 0)
+                        ? absl::StrCat(connect_udp->context_id().value())
+                        : "none")
                 << " and got message status "
                 << MessageStatusToString(message_status);
 }
@@ -182,8 +186,8 @@
       QUIC_DLOG(INFO) << "Removing state for stream ID " << it->stream()->id()
                       << " context ID "
                       << (it->context_id().has_value()
-                              ? it->context_id().value()
-                              : 0);
+                              ? absl::StrCat(it->context_id().value())
+                              : "none");
       auto* stream = it->stream();
       it = connect_udp_client_states_.erase(it);
       if (!stream->write_side_closed()) {
@@ -224,8 +228,8 @@
       QUIC_DLOG(INFO) << "Stream " << stream_id
                       << " was closed, removing state for context ID "
                       << (it->context_id().has_value()
-                              ? it->context_id().value()
-                              : 0);
+                              ? absl::StrCat(it->context_id().value())
+                              : "none");
       auto* encapsulated_client_session = it->encapsulated_client_session();
       it = connect_udp_client_states_.erase(it);
       encapsulated_client_session->CloseConnection(
@@ -241,6 +245,7 @@
 }
 
 bool MasqueClientSession::OnSettingsFrame(const SettingsFrame& frame) {
+  QUIC_DLOG(INFO) << "Received SETTINGS: " << frame;
   if (!QuicSpdyClientSession::OnSettingsFrame(frame)) {
     QUIC_DLOG(ERROR) << "Failed to parse received settings";
     return false;
@@ -249,6 +254,7 @@
     QUIC_DLOG(ERROR) << "Refusing to use MASQUE without HTTP/3 Datagrams";
     return false;
   }
+  QUIC_DLOG(INFO) << "Using HTTP Datagram: " << http_datagram_support();
   owner_->OnSettingsReceived();
   return true;
 }
@@ -308,7 +314,8 @@
   QUIC_DVLOG(1) << "Sent " << payload.size()
                 << " bytes to connection for stream ID " << stream_id
                 << " context ID "
-                << (context_id.has_value() ? context_id.value() : 0);
+                << (context_id.has_value() ? absl::StrCat(context_id.value())
+                                           : "none");
 }
 
 void MasqueClientSession::ConnectUdpClientState::OnContextReceived(
@@ -321,11 +328,13 @@
     return;
   }
   if (context_id != context_id_) {
-    QUIC_DLOG(INFO) << "Ignoring unexpected context ID "
-                    << (context_id.has_value() ? context_id.value() : 0)
-                    << " instead of "
-                    << (context_id_.has_value() ? context_id_.value() : 0)
-                    << " on stream ID " << stream_->id();
+    QUIC_DLOG(INFO)
+        << "Ignoring unexpected context ID "
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none")
+        << " instead of "
+        << (context_id_.has_value() ? absl::StrCat(context_id_.value())
+                                    : "none")
+        << " on stream ID " << stream_->id();
     return;
   }
   // Do nothing since the client registers first and we currently ignore
@@ -342,11 +351,13 @@
     return;
   }
   if (context_id != context_id_) {
-    QUIC_DLOG(INFO) << "Ignoring unexpected close of context ID "
-                    << (context_id.has_value() ? context_id.value() : 0)
-                    << " instead of "
-                    << (context_id_.has_value() ? context_id_.value() : 0)
-                    << " on stream ID " << stream_->id();
+    QUIC_DLOG(INFO)
+        << "Ignoring unexpected close of context ID "
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none")
+        << " instead of "
+        << (context_id_.has_value() ? absl::StrCat(context_id_.value())
+                                    : "none")
+        << " on stream ID " << stream_->id();
     return;
   }
   QUIC_DLOG(INFO) << "Received datagram context close on stream ID "
diff --git a/quic/masque/masque_server_session.cc b/quic/masque/masque_server_session.cc
index effc17f..a38ae9d 100644
--- a/quic/masque/masque_server_session.cc
+++ b/quic/masque/masque_server_session.cc
@@ -202,13 +202,15 @@
       QUIC_DLOG(ERROR) << "MASQUE request with bad method \"" << method << "\"";
       return CreateBackendErrorResponse("400", "Bad method");
     }
-    absl::optional<QuicDatagramStreamId> flow_id =
-        SpdyUtils::ParseDatagramFlowIdHeader(request_headers);
-    if (!flow_id.has_value()) {
-      QUIC_DLOG(ERROR)
-          << "MASQUE request with bad or missing DatagramFlowId header";
-      return CreateBackendErrorResponse("400",
-                                        "Bad or missing DatagramFlowId header");
+    absl::optional<QuicDatagramStreamId> flow_id;
+    if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
+      flow_id = SpdyUtils::ParseDatagramFlowIdHeader(request_headers);
+      if (!flow_id.has_value()) {
+        QUIC_DLOG(ERROR)
+            << "MASQUE request with bad or missing DatagramFlowId header";
+        return CreateBackendErrorResponse(
+            "400", "Bad or missing DatagramFlowId header");
+      }
     }
     QuicUrl url(absl::StrCat("https://", authority));
     if (!url.IsValid() || url.PathParamsQuery() != "/") {
@@ -235,7 +237,9 @@
         info_list, freeaddrinfo);
     QuicSocketAddress target_server_address(info_list->ai_addr,
                                             info_list->ai_addrlen);
-    QUIC_DLOG(INFO) << "Got CONNECT_UDP request flow_id=" << *flow_id
+    QUIC_DLOG(INFO) << "Got CONNECT_UDP request on stream ID "
+                    << request_handler->stream_id() << " flow_id="
+                    << (flow_id.has_value() ? absl::StrCat(*flow_id) : "none")
                     << " target_server_address=\"" << target_server_address
                     << "\"";
 
@@ -264,20 +268,26 @@
           << request_handler->stream_id();
       return CreateBackendErrorResponse("500", "Bad stream type");
     }
-    stream->RegisterHttp3DatagramFlowId(*flow_id);
+    if (flow_id.has_value()) {
+      stream->RegisterHttp3DatagramFlowId(*flow_id);
+    }
     connect_udp_server_states_.push_back(
         ConnectUdpServerState(stream, context_id, target_server_address,
                               fd_wrapper.extract_fd(), this));
 
-    // TODO(b/181256914) remove this when we drop support for
-    // draft-ietf-masque-h3-datagram-00 in favor of later drafts.
-    Http3DatagramContextExtensions extensions;
-    stream->RegisterHttp3DatagramContextId(context_id, extensions,
-                                           &connect_udp_server_states_.back());
+    if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
+      // TODO(b/181256914) remove this when we drop support for
+      // draft-ietf-masque-h3-datagram-00 in favor of later drafts.
+      Http3DatagramContextExtensions extensions;
+      stream->RegisterHttp3DatagramContextId(
+          context_id, extensions, &connect_udp_server_states_.back());
+    }
 
     spdy::Http2HeaderBlock response_headers;
     response_headers[":status"] = "200";
-    SpdyUtils::AddDatagramFlowIdHeader(&response_headers, *flow_id);
+    if (flow_id.has_value()) {
+      SpdyUtils::AddDatagramFlowIdHeader(&response_headers, *flow_id);
+    }
     auto response = std::make_unique<QuicBackendResponse>();
     response->set_response_type(QuicBackendResponse::INCOMPLETE_RESPONSE);
     response->set_headers(std::move(response_headers));
@@ -424,6 +434,19 @@
   return std::string("MasqueServerSession-") + connection_id().ToString();
 }
 
+bool MasqueServerSession::OnSettingsFrame(const SettingsFrame& frame) {
+  QUIC_DLOG(INFO) << "Received SETTINGS: " << frame;
+  if (!QuicSimpleServerSession::OnSettingsFrame(frame)) {
+    return false;
+  }
+  if (!SupportsH3Datagram()) {
+    QUIC_DLOG(ERROR) << "Refusing to use MASQUE without HTTP Datagrams";
+    return false;
+  }
+  QUIC_DLOG(INFO) << "Using HTTP Datagram: " << http_datagram_support();
+  return true;
+}
+
 MasqueServerSession::ConnectUdpServerState::ConnectUdpServerState(
     QuicSpdyStream* stream, absl::optional<QuicDatagramContextId> context_id,
     const QuicSocketAddress& target_server_address, QuicUdpSocketFd fd,
@@ -440,10 +463,10 @@
 
 MasqueServerSession::ConnectUdpServerState::~ConnectUdpServerState() {
   if (stream() != nullptr) {
-    stream()->UnregisterHttp3DatagramRegistrationVisitor();
     if (context_registered_) {
       stream()->UnregisterHttp3DatagramContextId(context_id());
     }
+    stream()->UnregisterHttp3DatagramRegistrationVisitor();
   }
   if (fd_ == kQuicInvalidSocketFd) {
     return;
@@ -515,17 +538,20 @@
     context_id_ = context_id;
   }
   if (context_id != context_id_) {
-    QUIC_DLOG(INFO) << "Ignoring unexpected context ID "
-                    << (context_id.has_value() ? context_id.value() : 0)
-                    << " instead of "
-                    << (context_id_.has_value() ? context_id_.value() : 0)
-                    << " on stream ID " << stream()->id();
+    QUIC_DLOG(INFO)
+        << "Ignoring unexpected context ID "
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none")
+        << " instead of "
+        << (context_id_.has_value() ? absl::StrCat(context_id_.value())
+                                    : "none")
+        << " on stream ID " << stream()->id();
     return;
   }
   if (context_registered_) {
     QUIC_BUG(MASQUE server double datagram context registration)
         << "Try to re-register stream ID " << stream_id << " context ID "
-        << (context_id_.has_value() ? context_id_.value() : 0);
+        << (context_id_.has_value() ? absl::StrCat(context_id_.value())
+                                    : "none");
     return;
   }
   context_registered_ = true;
@@ -543,11 +569,13 @@
     return;
   }
   if (context_id != context_id_) {
-    QUIC_DLOG(INFO) << "Ignoring unexpected close of context ID "
-                    << (context_id.has_value() ? context_id.value() : 0)
-                    << " instead of "
-                    << (context_id_.has_value() ? context_id_.value() : 0)
-                    << " on stream ID " << stream()->id();
+    QUIC_DLOG(INFO)
+        << "Ignoring unexpected close of context ID "
+        << (context_id.has_value() ? absl::StrCat(context_id.value()) : "none")
+        << " instead of "
+        << (context_id_.has_value() ? absl::StrCat(context_id_.value())
+                                    : "none")
+        << " on stream ID " << stream()->id();
     return;
   }
   QUIC_DLOG(INFO) << "Received datagram context close on stream ID "
diff --git a/quic/masque/masque_server_session.h b/quic/masque/masque_server_session.h
index 1bec14c..5729655 100644
--- a/quic/masque/masque_server_session.h
+++ b/quic/masque/masque_server_session.h
@@ -136,6 +136,8 @@
     bool context_registered_ = false;
   };
 
+  // From QuicSpdySession.
+  bool OnSettingsFrame(const SettingsFrame& frame) override;
   bool ShouldNegotiateHttp3Datagram() override { return true; }
 
   MasqueServerBackend* masque_server_backend_;  // Unowned.
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index a27f073..d0fd669 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -100,9 +100,9 @@
 }
 
 // static
-void QuicSpdySessionPeer::SetH3DatagramSupported(QuicSpdySession* session,
-                                                 bool h3_datagram_supported) {
-  session->h3_datagram_supported_ = h3_datagram_supported;
+void QuicSpdySessionPeer::SetHttpDatagramSupport(
+    QuicSpdySession* session, HttpDatagramSupport http_datagram_support) {
+  session->http_datagram_support_ = http_datagram_support;
 }
 
 // static
@@ -112,10 +112,10 @@
 }
 
 // static
-void QuicSpdySessionPeer::EnableWebTransport(QuicSpdySession& session) {
-  QUICHE_DCHECK(session.WillNegotiateWebTransport());
-  session.h3_datagram_supported_ = true;
-  session.peer_supports_webtransport_ = true;
+void QuicSpdySessionPeer::EnableWebTransport(QuicSpdySession* session) {
+  QUICHE_DCHECK(session->WillNegotiateWebTransport());
+  SetHttpDatagramSupport(session, HttpDatagramSupport::kDraft03);
+  session->peer_supports_webtransport_ = true;
 }
 
 }  // namespace test
diff --git a/quic/test_tools/quic_spdy_session_peer.h b/quic/test_tools/quic_spdy_session_peer.h
index 0d06c4d..2aa204b 100644
--- a/quic/test_tools/quic_spdy_session_peer.h
+++ b/quic/test_tools/quic_spdy_session_peer.h
@@ -7,6 +7,7 @@
 
 #include "quic/core/http/quic_receive_control_stream.h"
 #include "quic/core/http/quic_send_control_stream.h"
+#include "quic/core/http/quic_spdy_session.h"
 #include "quic/core/qpack/qpack_receive_stream.h"
 #include "quic/core/qpack/qpack_send_stream.h"
 #include "quic/core/quic_packets.h"
@@ -16,7 +17,6 @@
 namespace quic {
 
 class QuicHeadersStream;
-class QuicSpdySession;
 
 namespace test {
 
@@ -50,10 +50,10 @@
       QuicSpdySession* session);
   static QpackReceiveStream* GetQpackEncoderReceiveStream(
       QuicSpdySession* session);
-  static void SetH3DatagramSupported(QuicSpdySession* session,
-                                     bool h3_datagram_supported);
+  static void SetHttpDatagramSupport(QuicSpdySession* session,
+                                     HttpDatagramSupport http_datagram_support);
   static bool ShouldNegotiateHttp3Datagram(QuicSpdySession* session);
-  static void EnableWebTransport(QuicSpdySession& session);
+  static void EnableWebTransport(QuicSpdySession* session);
 };
 
 }  // namespace test