diff --git a/build/source_list.bzl b/build/source_list.bzl
index 0ba5220..e7806bf 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -392,6 +392,7 @@
     "spdy/core/spdy_protocol.h",
     "spdy/core/zero_copy_output_buffer.h",
     "web_transport/complete_buffer_visitor.h",
+    "web_transport/encapsulated/encapsulated_web_transport.h",
     "web_transport/web_transport.h",
 ]
 quiche_core_srcs = [
@@ -680,6 +681,7 @@
     "spdy/core/spdy_prefixed_buffer_reader.cc",
     "spdy/core/spdy_protocol.cc",
     "web_transport/complete_buffer_visitor.cc",
+    "web_transport/encapsulated/encapsulated_web_transport.cc",
 ]
 quiche_tool_support_hdrs = [
     "common/platform/api/quiche_command_line_flags.h",
@@ -742,6 +744,7 @@
     "common/platform/api/quiche_test.h",
     "common/platform/api/quiche_test_loopback.h",
     "common/platform/api/quiche_test_output.h",
+    "common/test_tools/mock_streams.h",
     "common/test_tools/quiche_test_utils.h",
     "http2/adapter/mock_http2_visitor.h",
     "http2/adapter/recording_http2_visitor.h",
@@ -1072,6 +1075,7 @@
     "common/simple_buffer_allocator_test.cc",
     "common/structured_headers_generated_test.cc",
     "common/structured_headers_test.cc",
+    "common/test_tools/mock_streams_test.cc",
     "common/test_tools/quiche_test_utils_test.cc",
     "common/wire_serialization_test.cc",
     "http2/adapter/event_forwarder_test.cc",
@@ -1302,6 +1306,7 @@
     "spdy/core/spdy_pinnable_buffer_piece_test.cc",
     "spdy/core/spdy_prefixed_buffer_reader_test.cc",
     "spdy/core/spdy_protocol_test.cc",
+    "web_transport/encapsulated/encapsulated_web_transport_test.cc",
 ]
 io_tests_hdrs = [
 ]
diff --git a/build/source_list.gni b/build/source_list.gni
index 69e5f27..da2d729 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -392,6 +392,7 @@
     "src/quiche/spdy/core/spdy_protocol.h",
     "src/quiche/spdy/core/zero_copy_output_buffer.h",
     "src/quiche/web_transport/complete_buffer_visitor.h",
+    "src/quiche/web_transport/encapsulated/encapsulated_web_transport.h",
     "src/quiche/web_transport/web_transport.h",
 ]
 quiche_core_srcs = [
@@ -680,6 +681,7 @@
     "src/quiche/spdy/core/spdy_prefixed_buffer_reader.cc",
     "src/quiche/spdy/core/spdy_protocol.cc",
     "src/quiche/web_transport/complete_buffer_visitor.cc",
+    "src/quiche/web_transport/encapsulated/encapsulated_web_transport.cc",
 ]
 quiche_tool_support_hdrs = [
     "src/quiche/common/platform/api/quiche_command_line_flags.h",
@@ -742,6 +744,7 @@
     "src/quiche/common/platform/api/quiche_test.h",
     "src/quiche/common/platform/api/quiche_test_loopback.h",
     "src/quiche/common/platform/api/quiche_test_output.h",
+    "src/quiche/common/test_tools/mock_streams.h",
     "src/quiche/common/test_tools/quiche_test_utils.h",
     "src/quiche/http2/adapter/mock_http2_visitor.h",
     "src/quiche/http2/adapter/recording_http2_visitor.h",
@@ -1073,6 +1076,7 @@
     "src/quiche/common/simple_buffer_allocator_test.cc",
     "src/quiche/common/structured_headers_generated_test.cc",
     "src/quiche/common/structured_headers_test.cc",
+    "src/quiche/common/test_tools/mock_streams_test.cc",
     "src/quiche/common/test_tools/quiche_test_utils_test.cc",
     "src/quiche/common/wire_serialization_test.cc",
     "src/quiche/http2/adapter/event_forwarder_test.cc",
@@ -1303,6 +1307,7 @@
     "src/quiche/spdy/core/spdy_pinnable_buffer_piece_test.cc",
     "src/quiche/spdy/core/spdy_prefixed_buffer_reader_test.cc",
     "src/quiche/spdy/core/spdy_protocol_test.cc",
+    "src/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc",
 ]
 io_tests_hdrs = [
 
diff --git a/build/source_list.json b/build/source_list.json
index 165f594..42f3fbb 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -391,6 +391,7 @@
     "quiche/spdy/core/spdy_protocol.h",
     "quiche/spdy/core/zero_copy_output_buffer.h",
     "quiche/web_transport/complete_buffer_visitor.h",
+    "quiche/web_transport/encapsulated/encapsulated_web_transport.h",
     "quiche/web_transport/web_transport.h"
   ],
   "quiche_core_srcs": [
@@ -678,7 +679,8 @@
     "quiche/spdy/core/spdy_pinnable_buffer_piece.cc",
     "quiche/spdy/core/spdy_prefixed_buffer_reader.cc",
     "quiche/spdy/core/spdy_protocol.cc",
-    "quiche/web_transport/complete_buffer_visitor.cc"
+    "quiche/web_transport/complete_buffer_visitor.cc",
+    "quiche/web_transport/encapsulated/encapsulated_web_transport.cc"
   ],
   "quiche_tool_support_hdrs": [
     "quiche/common/platform/api/quiche_command_line_flags.h",
@@ -741,6 +743,7 @@
     "quiche/common/platform/api/quiche_test.h",
     "quiche/common/platform/api/quiche_test_loopback.h",
     "quiche/common/platform/api/quiche_test_output.h",
+    "quiche/common/test_tools/mock_streams.h",
     "quiche/common/test_tools/quiche_test_utils.h",
     "quiche/http2/adapter/mock_http2_visitor.h",
     "quiche/http2/adapter/recording_http2_visitor.h",
@@ -1072,6 +1075,7 @@
     "quiche/common/simple_buffer_allocator_test.cc",
     "quiche/common/structured_headers_generated_test.cc",
     "quiche/common/structured_headers_test.cc",
+    "quiche/common/test_tools/mock_streams_test.cc",
     "quiche/common/test_tools/quiche_test_utils_test.cc",
     "quiche/common/wire_serialization_test.cc",
     "quiche/http2/adapter/event_forwarder_test.cc",
@@ -1301,7 +1305,8 @@
     "quiche/spdy/core/spdy_intrusive_list_test.cc",
     "quiche/spdy/core/spdy_pinnable_buffer_piece_test.cc",
     "quiche/spdy/core/spdy_prefixed_buffer_reader_test.cc",
-    "quiche/spdy/core/spdy_protocol_test.cc"
+    "quiche/spdy/core/spdy_protocol_test.cc",
+    "quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc"
   ],
   "io_tests_hdrs": [
 
diff --git a/quiche/common/capsule.cc b/quiche/common/capsule.cc
index 66d4a66..421f11d 100644
--- a/quiche/common/capsule.cc
+++ b/quiche/common/capsule.cc
@@ -4,8 +4,13 @@
 
 #include "quiche/common/capsule.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <limits>
+#include <ostream>
+#include <string>
 #include <type_traits>
+#include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -350,6 +355,17 @@
   }
 }
 
+QuicheBuffer SerializeDatagramCapsuleHeader(uint64_t datagram_size,
+                                            QuicheBufferAllocator* allocator) {
+  absl::StatusOr<QuicheBuffer> buffer =
+      SerializeIntoBuffer(allocator, WireVarInt62(CapsuleType::DATAGRAM),
+                          WireVarInt62(datagram_size));
+  if (!buffer.ok()) {
+    return QuicheBuffer();
+  }
+  return *std::move(buffer);
+}
+
 QuicheBuffer SerializeCapsule(const Capsule& capsule,
                               quiche::QuicheBufferAllocator* allocator) {
   absl::StatusOr<QuicheBuffer> serialized =
diff --git a/quiche/common/capsule.h b/quiche/common/capsule.h
index b5e1831..3cadc4d 100644
--- a/quiche/common/capsule.h
+++ b/quiche/common/capsule.h
@@ -391,6 +391,10 @@
 QUICHE_EXPORT quiche::QuicheBuffer SerializeCapsule(
     const Capsule& capsule, quiche::QuicheBufferAllocator* allocator);
 
+// Serializes the header for a datagram of size |datagram_size|.
+QUICHE_EXPORT QuicheBuffer SerializeDatagramCapsuleHeader(
+    uint64_t datagram_size, QuicheBufferAllocator* allocator);
+
 }  // namespace quiche
 
 #endif  // QUICHE_COMMON_CAPSULE_H_
diff --git a/quiche/common/capsule_test.cc b/quiche/common/capsule_test.cc
index ae55aaf..0aed714 100644
--- a/quiche/common/capsule_test.cc
+++ b/quiche/common/capsule_test.cc
@@ -10,8 +10,10 @@
 #include <vector>
 
 #include "absl/strings/escaping.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_ip_address.h"
 #include "quiche/common/simple_buffer_allocator.h"
 #include "quiche/common/test_tools/quiche_test_utils.h"
@@ -86,6 +88,16 @@
   TestSerialization(expected_capsule, capsule_fragment);
 }
 
+TEST_F(CapsuleTest, DatagramCapsuleViaHeader) {
+  std::string datagram_payload = absl::HexStringToBytes("a1a2a3a4a5a6a7a8");
+  quiche::QuicheBuffer expected_capsule = SerializeCapsule(
+      Capsule::Datagram(datagram_payload), SimpleBufferAllocator::Get());
+  quiche::QuicheBuffer actual_header = SerializeDatagramCapsuleHeader(
+      datagram_payload.size(), SimpleBufferAllocator::Get());
+  EXPECT_EQ(expected_capsule.AsStringView(),
+            absl::StrCat(actual_header.AsStringView(), datagram_payload));
+}
+
 TEST_F(CapsuleTest, LegacyDatagramCapsule) {
   std::string capsule_fragment = absl::HexStringToBytes(
       "80ff37a0"          // LEGACY_DATAGRAM capsule type
diff --git a/quiche/common/test_tools/mock_streams.h b/quiche/common/test_tools/mock_streams.h
new file mode 100644
index 0000000..577a324
--- /dev/null
+++ b/quiche/common/test_tools/mock_streams.h
@@ -0,0 +1,101 @@
+// Copyright (c) 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_COMMON_TEST_TOOLS_MOCK_STREAMS_H_
+#define QUICHE_COMMON_TEST_TOOLS_MOCK_STREAMS_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_stream.h"
+
+namespace quiche::test {
+
+// Mockable stream that stores all of the data into an std::string by default.
+class MockWriteStream : public quiche::WriteStream {
+ public:
+  MockWriteStream() {
+    ON_CALL(*this, CanWrite()).WillByDefault(testing::Return(true));
+    ON_CALL(*this, Writev(testing::_, testing::_))
+        .WillByDefault([&](absl::Span<const absl::string_view> data,
+                           const StreamWriteOptions& options) {
+          return AppendToData(data, options);
+        });
+  }
+
+  MOCK_METHOD(absl::Status, Writev,
+              (absl::Span<const absl::string_view> data,
+               const StreamWriteOptions& options),
+              (override));
+  MOCK_METHOD(bool, CanWrite, (), (const, override));
+
+  absl::Status AppendToData(absl::Span<const absl::string_view> data,
+                            const StreamWriteOptions& options) {
+    for (absl::string_view fragment : data) {
+      data_.append(fragment.data(), fragment.size());
+    }
+    ProcessOptions(options);
+    return absl::OkStatus();
+  }
+  void ProcessOptions(const StreamWriteOptions& options) {
+    fin_written_ |= options.send_fin();
+  }
+
+  std::string& data() { return data_; }
+  bool fin_written() { return fin_written_; }
+
+ private:
+  std::string data_;
+  bool fin_written_ = false;
+};
+
+// Reads stream data from an std::string buffer.
+class ReadStreamFromString : public ReadStream {
+ public:
+  explicit ReadStreamFromString(std::string* data) : data_(data) {}
+
+  ReadResult Read(absl::Span<char> buffer) override {
+    size_t data_to_copy = std::min(buffer.size(), data_->size());
+    std::copy(data_->begin(), data_->begin() + data_to_copy, buffer.begin());
+    *data_ = data_->substr(data_to_copy);
+    return ReadResult{data_to_copy, data_->empty() && fin_};
+  }
+  ReadResult Read(std::string* output) override {
+    size_t bytes = data_->size();
+    output->append(std::move(*data_));
+    data_->clear();
+    return ReadResult{bytes, fin_};
+  }
+
+  size_t ReadableBytes() const override { return data_->size(); }
+
+  virtual PeekResult PeekNextReadableRegion() const override {
+    PeekResult result;
+    result.peeked_data = *data_;
+    result.fin_next = data_->empty() && fin_;
+    result.all_data_received = fin_;
+    return result;
+  }
+
+  bool SkipBytes(size_t bytes) override {
+    *data_ = data_->substr(bytes);
+    return data_->empty() && fin_;
+  }
+
+  void set_fin() { fin_ = true; }
+
+ private:
+  std::string* data_;
+  bool fin_ = false;
+};
+
+}  // namespace quiche::test
+
+#endif  // QUICHE_COMMON_TEST_TOOLS_MOCK_STREAMS_H_
diff --git a/quiche/common/test_tools/mock_streams_test.cc b/quiche/common/test_tools/mock_streams_test.cc
new file mode 100644
index 0000000..2e8a2e4
--- /dev/null
+++ b/quiche/common/test_tools/mock_streams_test.cc
@@ -0,0 +1,63 @@
+// Copyright (c) 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/common/test_tools/mock_streams.h"
+
+#include <array>
+#include <string>
+
+#include "absl/types/span.h"
+#include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_stream.h"
+#include "quiche/common/test_tools/quiche_test_utils.h"
+
+namespace quiche::test {
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::IsEmpty;
+
+TEST(MockWriteStreamTest, DefaultWrite) {
+  MockWriteStream stream;
+  QUICHE_EXPECT_OK(quiche::WriteIntoStream(stream, "test"));
+  EXPECT_EQ(stream.data(), "test");
+  EXPECT_FALSE(stream.fin_written());
+}
+
+TEST(ReadStreamFromStringTest, ReadIntoSpan) {
+  std::string source = "abcdef";
+  std::array<char, 3> buffer;
+  ReadStreamFromString stream(&source);
+  EXPECT_EQ(stream.ReadableBytes(), 6);
+
+  stream.Read(absl::MakeSpan(buffer));
+  EXPECT_THAT(buffer, ElementsAre('a', 'b', 'c'));
+  EXPECT_EQ(stream.ReadableBytes(), 3);
+
+  stream.Read(absl::MakeSpan(buffer));
+  EXPECT_THAT(buffer, ElementsAre('d', 'e', 'f'));
+  EXPECT_EQ(stream.ReadableBytes(), 0);
+  EXPECT_THAT(source, IsEmpty());
+}
+
+TEST(ReadStreamFromStringTest, ReadIntoString) {
+  std::string source = "abcdef";
+  std::string destination;
+  ReadStreamFromString stream(&source);
+  stream.Read(&destination);
+  EXPECT_EQ(destination, "abcdef");
+  EXPECT_THAT(source, IsEmpty());
+}
+
+TEST(ReadStreamFromStringTest, PeekAndSkip) {
+  std::string source = "abcdef";
+  ReadStreamFromString stream(&source);
+  EXPECT_EQ(stream.PeekNextReadableRegion().peeked_data, "abcdef");
+  stream.SkipBytes(2);
+  EXPECT_EQ(stream.PeekNextReadableRegion().peeked_data, "cdef");
+  EXPECT_EQ(source, "cdef");
+}
+
+}  // namespace
+}  // namespace quiche::test
diff --git a/quiche/web_transport/encapsulated/encapsulated_web_transport.cc b/quiche/web_transport/encapsulated/encapsulated_web_transport.cc
new file mode 100644
index 0000000..0aa3763
--- /dev/null
+++ b/quiche/web_transport/encapsulated/encapsulated_web_transport.cc
@@ -0,0 +1,355 @@
+// Copyright (c) 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/web_transport/encapsulated/encapsulated_web_transport.h"
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "absl/types/span.h"
+#include "quiche/common/capsule.h"
+#include "quiche/common/http/http_header_block.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_callbacks.h"
+#include "quiche/common/quiche_status_utils.h"
+#include "quiche/common/quiche_stream.h"
+#include "quiche/web_transport/web_transport.h"
+
+namespace webtransport {
+
+namespace {
+
+using ::quiche::Capsule;
+using ::quiche::CapsuleType;
+using ::quiche::CloseWebTransportSessionCapsule;
+
+// This is arbitrary, since we don't have any real MTU restriction when running
+// over TCP.
+constexpr uint64_t kEncapsulatedMaxDatagramSize = 9000;
+
+}  // namespace
+
+EncapsulatedSession::EncapsulatedSession(
+    Perspective perspective, FatalErrorCallback fatal_error_callback)
+    : perspective_(perspective),
+      fatal_error_callback_(std::move(fatal_error_callback)),
+      capsule_parser_(this) {}
+
+void EncapsulatedSession::InitializeClient(
+    std::unique_ptr<SessionVisitor> visitor,
+    quiche::HttpHeaderBlock& /*outgoing_headers*/, quiche::WriteStream* writer,
+    quiche::ReadStream* reader) {
+  if (state_ != kUninitialized) {
+    OnFatalError("Called InitializeClient() in an invalid state");
+    return;
+  }
+  if (perspective_ != Perspective::kClient) {
+    OnFatalError("Called InitializeClient() on a server session");
+    return;
+  }
+
+  visitor_ = std::move(visitor);
+  writer_ = writer;
+  reader_ = reader;
+  state_ = kWaitingForHeaders;
+}
+
+void EncapsulatedSession::InitializeServer(
+    std::unique_ptr<SessionVisitor> visitor,
+    const quiche::HttpHeaderBlock& /*incoming_headers*/,
+    quiche::HttpHeaderBlock& /*outgoing_headers*/, quiche::WriteStream* writer,
+    quiche::ReadStream* reader) {
+  if (state_ != kUninitialized) {
+    OnFatalError("Called InitializeServer() in an invalid state");
+    return;
+  }
+  if (perspective_ != Perspective::kServer) {
+    OnFatalError("Called InitializeServer() on a client session");
+    return;
+  }
+
+  visitor_ = std::move(visitor);
+  writer_ = writer;
+  reader_ = reader;
+  OpenSession();
+}
+void EncapsulatedSession::ProcessIncomingServerHeaders(
+    const quiche::HttpHeaderBlock& /*headers*/) {
+  if (state_ != kWaitingForHeaders) {
+    OnFatalError("Called ProcessIncomingServerHeaders() in an invalid state");
+    return;
+  }
+  OpenSession();
+}
+
+void EncapsulatedSession::CloseSession(SessionErrorCode error_code,
+                                       absl::string_view error_message) {
+  switch (state_) {
+    case kUninitialized:
+    case kWaitingForHeaders:
+      OnFatalError(absl::StrCat(
+          "Attempted to close a session before it opened with error 0x",
+          absl::Hex(error_code), ": ", error_message));
+      return;
+    case kSessionClosing:
+    case kSessionClosed:
+      OnFatalError(absl::StrCat(
+          "Attempted to close a session that is already closed with error 0x",
+          absl::Hex(error_code), ": ", error_message));
+      return;
+    case kSessionOpen:
+      break;
+  }
+  state_ = kSessionClosing;
+  buffered_session_close_ =
+      BufferedClose{error_code, std::string(error_message)};
+  OnCanWrite();
+}
+
+Stream* EncapsulatedSession::AcceptIncomingBidirectionalStream() {
+  return nullptr;
+}
+Stream* EncapsulatedSession::AcceptIncomingUnidirectionalStream() {
+  return nullptr;
+}
+bool EncapsulatedSession::CanOpenNextOutgoingBidirectionalStream() {
+  return false;
+}
+bool EncapsulatedSession::CanOpenNextOutgoingUnidirectionalStream() {
+  return false;
+}
+Stream* EncapsulatedSession::OpenOutgoingBidirectionalStream() {
+  return nullptr;
+}
+Stream* EncapsulatedSession::OpenOutgoingUnidirectionalStream() {
+  return nullptr;
+}
+
+Stream* EncapsulatedSession::GetStreamById(StreamId /*id*/) { return nullptr; }
+DatagramStats EncapsulatedSession::GetDatagramStats() {
+  DatagramStats stats;
+  stats.expired_outgoing = 0;
+  stats.lost_outgoing = 0;
+  return stats;
+}
+
+SessionStats EncapsulatedSession::GetSessionStats() {
+  // We could potentially get stats via tcp_info and similar mechanisms, but
+  // that would require us knowing what the underlying socket is.
+  return SessionStats();
+}
+
+void EncapsulatedSession::NotifySessionDraining() {
+  control_capsule_queue_.push_back(quiche::SerializeCapsule(
+      quiche::Capsule(quiche::DrainWebTransportSessionCapsule()), allocator_));
+  OnCanWrite();
+}
+void EncapsulatedSession::SetOnDraining(
+    quiche::SingleUseCallback<void()> callback) {
+  draining_callback_ = std::move(callback);
+}
+
+DatagramStatus EncapsulatedSession::SendOrQueueDatagram(
+    absl::string_view datagram) {
+  if (datagram.size() > GetMaxDatagramSize()) {
+    return DatagramStatus{
+        DatagramStatusCode::kTooBig,
+        absl::StrCat("Datagram is ", datagram.size(),
+                     " bytes long, while the specified maximum size is ",
+                     GetMaxDatagramSize())};
+  }
+
+  bool write_blocked;
+  switch (state_) {
+    case kUninitialized:
+      write_blocked = true;
+      break;
+    // We can send datagrams before receiving any headers from the peer, since
+    // datagrams are not subject to queueing.
+    case kWaitingForHeaders:
+    case kSessionOpen:
+      write_blocked = !writer_->CanWrite();
+      break;
+    case kSessionClosing:
+    case kSessionClosed:
+      return DatagramStatus{DatagramStatusCode::kInternalError,
+                            "Writing into an already closed session"};
+  }
+
+  if (write_blocked) {
+    // TODO: this *may* be useful to split into a separate queue.
+    control_capsule_queue_.push_back(
+        quiche::SerializeCapsule(Capsule::Datagram(datagram), allocator_));
+    return DatagramStatus{DatagramStatusCode::kSuccess, ""};
+  }
+
+  // We could always write via OnCanWrite() above, but the optimistic path below
+  // allows us to avoid a copy.
+  quiche::QuicheBuffer buffer =
+      quiche::SerializeDatagramCapsuleHeader(datagram.size(), allocator_);
+  std::array spans = {buffer.AsStringView(), datagram};
+  absl::Status write_status =
+      writer_->Writev(absl::MakeConstSpan(spans), quiche::StreamWriteOptions());
+  if (!write_status.ok()) {
+    OnWriteError(write_status);
+    return DatagramStatus{
+        DatagramStatusCode::kInternalError,
+        absl::StrCat("Write error for datagram: ", write_status.ToString())};
+  }
+  return DatagramStatus{DatagramStatusCode::kSuccess, ""};
+}
+
+uint64_t EncapsulatedSession::GetMaxDatagramSize() const {
+  return kEncapsulatedMaxDatagramSize;
+}
+
+void EncapsulatedSession::SetDatagramMaxTimeInQueue(
+    absl::Duration /*max_time_in_queue*/) {
+  // TODO(b/264263113): implement this (requires having a mockable clock).
+}
+
+void EncapsulatedSession::OnCanWrite() {
+  if (state_ == kUninitialized || !writer_) {
+    OnFatalError("Trying to write before the session is initialized");
+    return;
+  }
+  if (state_ == kSessionClosed) {
+    OnFatalError("Trying to write before the session is closed");
+    return;
+  }
+
+  if (state_ == kSessionClosing) {
+    if (writer_->CanWrite()) {
+      CloseWebTransportSessionCapsule capsule{
+          buffered_session_close_.error_code,
+          buffered_session_close_.error_message};
+      quiche::QuicheBuffer buffer =
+          quiche::SerializeCapsule(Capsule(std::move(capsule)), allocator_);
+      absl::Status write_status = SendFin(buffer.AsStringView());
+      if (!write_status.ok()) {
+        OnWriteError(quiche::AppendToStatus(write_status,
+                                            " while writing WT_CLOSE_SESSION"));
+        return;
+      }
+      OnSessionClosed(buffered_session_close_.error_code,
+                      buffered_session_close_.error_message);
+    }
+    return;
+  }
+
+  while (writer_->CanWrite() && !control_capsule_queue_.empty()) {
+    absl::Status write_status = quiche::WriteIntoStream(
+        *writer_, control_capsule_queue_.front().AsStringView());
+    if (!write_status.ok()) {
+      OnWriteError(write_status);
+      return;
+    }
+    control_capsule_queue_.pop_front();
+  }
+
+  // TODO(b/264263113): send stream data.
+}
+
+void EncapsulatedSession::OnCanRead() {
+  if (state_ == kSessionClosed || state_ == kSessionClosing) {
+    return;
+  }
+  bool has_fin = quiche::ProcessAllReadableRegions(
+      *reader_, [&](absl::string_view fragment) {
+        capsule_parser_.IngestCapsuleFragment(fragment);
+      });
+  if (has_fin) {
+    capsule_parser_.ErrorIfThereIsRemainingBufferedData();
+    OnSessionClosed(0, "");
+  }
+}
+
+bool EncapsulatedSession::OnCapsule(const quiche::Capsule& capsule) {
+  switch (capsule.capsule_type()) {
+    case CapsuleType::DATAGRAM:
+      visitor_->OnDatagramReceived(
+          capsule.datagram_capsule().http_datagram_payload);
+      break;
+    case CapsuleType::DRAIN_WEBTRANSPORT_SESSION:
+      if (draining_callback_) {
+        std::move(draining_callback_)();
+      }
+      break;
+    case CapsuleType::CLOSE_WEBTRANSPORT_SESSION:
+      OnSessionClosed(
+          capsule.close_web_transport_session_capsule().error_code,
+          std::string(
+              capsule.close_web_transport_session_capsule().error_message));
+      break;
+    default:
+      break;
+  }
+  return true;
+}
+
+void EncapsulatedSession::OnCapsuleParseFailure(
+    absl::string_view error_message) {
+  OnFatalError(absl::StrCat("Stream parse error: ", error_message));
+}
+
+void EncapsulatedSession::OpenSession() {
+  state_ = kSessionOpen;
+  visitor_->OnSessionReady();
+  OnCanWrite();
+  OnCanRead();
+}
+
+absl::Status EncapsulatedSession::SendFin(absl::string_view data) {
+  QUICHE_DCHECK(!fin_sent_);
+  fin_sent_ = true;
+  quiche::StreamWriteOptions options;
+  options.set_send_fin(true);
+  return quiche::WriteIntoStream(*writer_, data, options);
+}
+
+void EncapsulatedSession::OnSessionClosed(SessionErrorCode error_code,
+                                          const std::string& error_message) {
+  if (!fin_sent_) {
+    absl::Status status = SendFin("");
+    if (!status.ok()) {
+      OnWriteError(status);
+      return;
+    }
+  }
+
+  if (session_close_notified_) {
+    QUICHE_DCHECK_EQ(state_, kSessionClosed);
+    return;
+  }
+  state_ = kSessionClosed;
+  session_close_notified_ = true;
+
+  if (visitor_ != nullptr) {
+    visitor_->OnSessionClosed(error_code, error_message);
+  }
+}
+
+void EncapsulatedSession::OnFatalError(absl::string_view error_message) {
+  QUICHE_DLOG(ERROR) << "Fatal error in encapsulated WebTransport: "
+                     << error_message;
+  state_ = kSessionClosed;
+  if (fatal_error_callback_) {
+    std::move(fatal_error_callback_)(error_message);
+  }
+}
+
+void EncapsulatedSession::OnWriteError(absl::Status error) {
+  OnFatalError(absl::StrCat(
+      error, " while trying to write encapsulated WebTransport data"));
+}
+
+}  // namespace webtransport
diff --git a/quiche/web_transport/encapsulated/encapsulated_web_transport.h b/quiche/web_transport/encapsulated/encapsulated_web_transport.h
new file mode 100644
index 0000000..85c14c9
--- /dev/null
+++ b/quiche/web_transport/encapsulated/encapsulated_web_transport.h
@@ -0,0 +1,133 @@
+// Copyright (c) 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_WEB_TRANSPORT_ENCAPSULATED_ENCAPSULATED_WEB_TRANSPORT_H_
+#define QUICHE_WEB_TRANSPORT_ENCAPSULATED_ENCAPSULATED_WEB_TRANSPORT_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "quiche/common/capsule.h"
+#include "quiche/common/http/http_header_block.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_callbacks.h"
+#include "quiche/common/quiche_circular_deque.h"
+#include "quiche/common/quiche_stream.h"
+#include "quiche/common/simple_buffer_allocator.h"
+#include "quiche/web_transport/web_transport.h"
+
+namespace webtransport {
+
+using FatalErrorCallback = quiche::SingleUseCallback<void(absl::string_view)>;
+
+// Implementation of the WebTransport over HTTP/2 protocol; works over any
+// arbitrary bidirectional bytestream that can be prefixed with HTTP headers.
+// Specification: https://datatracker.ietf.org/doc/draft-ietf-webtrans-http2/
+class QUICHE_EXPORT EncapsulatedSession
+    : public webtransport::Session,
+      public quiche::WriteStreamVisitor,
+      public quiche::ReadStreamVisitor,
+      public quiche::CapsuleParser::Visitor {
+ public:
+  // The state machine of the transport.
+  enum State {
+    // The transport object has been created, but
+    // InitializeClient/InitializeServer has not been called yet.
+    kUninitialized,
+    // The client has sent its own headers, but haven't received a response yet.
+    kWaitingForHeaders,
+    // Both the client and the server headers have been processed.
+    kSessionOpen,
+    // The session close has been requested, but the CLOSE capsule hasn't been
+    // sent yet.
+    kSessionClosing,
+    // The session has been closed; no further data will be exchanged.
+    kSessionClosed,
+  };
+
+  // The `fatal_error_callback` implies that any state related to the session
+  // should be torn down after it's been called.
+  EncapsulatedSession(Perspective perspective,
+                      FatalErrorCallback fatal_error_callback);
+
+  // WebTransport uses HTTP headers in a similar way to how QUIC uses SETTINGS;
+  // thus, the headers are necessary to initialize the session.
+  void InitializeClient(std::unique_ptr<SessionVisitor> visitor,
+                        quiche::HttpHeaderBlock& outgoing_headers,
+                        quiche::WriteStream* writer,
+                        quiche::ReadStream* reader);
+  void InitializeServer(std::unique_ptr<SessionVisitor> visitor,
+                        const quiche::HttpHeaderBlock& incoming_headers,
+                        quiche::HttpHeaderBlock& outgoing_headers,
+                        quiche::WriteStream* writer,
+                        quiche::ReadStream* reader);
+  void ProcessIncomingServerHeaders(const quiche::HttpHeaderBlock& headers);
+
+  // webtransport::Session implementation.
+  void CloseSession(SessionErrorCode error_code,
+                    absl::string_view error_message) override;
+  Stream* AcceptIncomingBidirectionalStream() override;
+  Stream* AcceptIncomingUnidirectionalStream() override;
+  bool CanOpenNextOutgoingBidirectionalStream() override;
+  bool CanOpenNextOutgoingUnidirectionalStream() override;
+  Stream* OpenOutgoingBidirectionalStream() override;
+  Stream* OpenOutgoingUnidirectionalStream() override;
+  DatagramStatus SendOrQueueDatagram(absl::string_view datagram) override;
+  uint64_t GetMaxDatagramSize() const override;
+  void SetDatagramMaxTimeInQueue(absl::Duration max_time_in_queue) override;
+  Stream* GetStreamById(StreamId id) override;
+  DatagramStats GetDatagramStats() override;
+  SessionStats GetSessionStats() override;
+  void NotifySessionDraining() override;
+  void SetOnDraining(quiche::SingleUseCallback<void()> callback) override;
+
+  // quiche::WriteStreamVisitor implementation.
+  void OnCanWrite() override;
+  // quiche::ReadStreamVisitor implementation.
+  void OnCanRead() override;
+  // quiche::CapsuleParser::Visitor implementation.
+  bool OnCapsule(const quiche::Capsule& capsule) override;
+  void OnCapsuleParseFailure(absl::string_view error_message) override;
+
+  State state() const { return state_; }
+
+ private:
+  struct BufferedClose {
+    SessionErrorCode error_code = 0;
+    std::string error_message;
+  };
+
+  Perspective perspective_;
+  State state_ = kUninitialized;
+  std::unique_ptr<SessionVisitor> visitor_ = nullptr;
+  FatalErrorCallback fatal_error_callback_;
+  quiche::SingleUseCallback<void()> draining_callback_;
+  quiche::WriteStream* writer_ = nullptr;  // Not owned.
+  quiche::ReadStream* reader_ = nullptr;   // Not owned.
+  quiche::QuicheBufferAllocator* allocator_ =
+      quiche::SimpleBufferAllocator::Get();
+  quiche::CapsuleParser capsule_parser_;
+
+  bool session_close_notified_ = false;
+  bool fin_sent_ = false;
+
+  BufferedClose buffered_session_close_;
+  quiche::QuicheCircularDeque<quiche::QuicheBuffer> control_capsule_queue_;
+
+  void OpenSession();
+  absl::Status SendFin(absl::string_view data);
+  void OnSessionClosed(SessionErrorCode error_code,
+                       const std::string& error_message);
+  void OnFatalError(absl::string_view error_message);
+  void OnWriteError(absl::Status error);
+};
+
+}  // namespace webtransport
+
+#endif  // QUICHE_WEB_TRANSPORT_ENCAPSULATED_ENCAPSULATED_WEB_TRANSPORT_H_
diff --git a/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc b/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc
new file mode 100644
index 0000000..15728e4
--- /dev/null
+++ b/quiche/web_transport/encapsulated/encapsulated_web_transport_test.cc
@@ -0,0 +1,318 @@
+// Copyright (c) 2023 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/web_transport/encapsulated/encapsulated_web_transport.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "quiche/common/capsule.h"
+#include "quiche/common/http/http_header_block.h"
+#include "quiche/common/platform/api/quiche_test.h"
+#include "quiche/common/quiche_buffer_allocator.h"
+#include "quiche/common/quiche_stream.h"
+#include "quiche/common/simple_buffer_allocator.h"
+#include "quiche/common/test_tools/mock_streams.h"
+#include "quiche/web_transport/test_tools/mock_web_transport.h"
+#include "quiche/web_transport/web_transport.h"
+
+namespace webtransport::test {
+namespace {
+
+using ::quiche::Capsule;
+using ::quiche::CapsuleType;
+using ::testing::_;
+using ::testing::HasSubstr;
+using ::testing::IsEmpty;
+using ::testing::Return;
+using ::testing::StrEq;
+
+class EncapsulatedWebTransportTest : public quiche::test::QuicheTest,
+                                     public quiche::CapsuleParser::Visitor {
+ public:
+  EncapsulatedWebTransportTest() : parser_(this), reader_(&read_buffer_) {
+    ON_CALL(fatal_error_callback_, Call(_))
+        .WillByDefault([](absl::string_view error) {
+          ADD_FAILURE() << "Fatal session error: " << error;
+        });
+    ON_CALL(writer_, Writev(_, _))
+        .WillByDefault([&](absl::Span<const absl::string_view> data,
+                           const quiche::StreamWriteOptions& options) {
+          for (absl::string_view fragment : data) {
+            parser_.IngestCapsuleFragment(fragment);
+          }
+          writer_.ProcessOptions(options);
+          return absl::OkStatus();
+        });
+  }
+
+  std::unique_ptr<EncapsulatedSession> CreateTransport(
+      Perspective perspective) {
+    auto transport = std::make_unique<EncapsulatedSession>(
+        perspective, fatal_error_callback_.AsStdFunction());
+    session_ = transport.get();
+    return transport;
+  }
+
+  std::unique_ptr<SessionVisitor> CreateAndStoreVisitor() {
+    auto visitor = std::make_unique<testing::StrictMock<MockSessionVisitor>>();
+    visitor_ = visitor.get();
+    return visitor;
+  }
+
+  MOCK_METHOD(bool, OnCapsule, (const Capsule&), (override));
+
+  void OnCapsuleParseFailure(absl::string_view error_message) override {
+    ADD_FAILURE() << "Written an invalid capsule: " << error_message;
+  }
+
+  void ProcessIncomingCapsule(const Capsule& capsule) {
+    quiche::QuicheBuffer buffer =
+        quiche::SerializeCapsule(capsule, quiche::SimpleBufferAllocator::Get());
+    read_buffer_.append(buffer.data(), buffer.size());
+    session_->OnCanRead();
+  }
+
+  void DefaultHandshakeForClient(EncapsulatedSession& session) {
+    quiche::HttpHeaderBlock outgoing_headers, incoming_headers;
+    session.InitializeClient(CreateAndStoreVisitor(), outgoing_headers,
+                             &writer_, &reader_);
+    EXPECT_CALL(*visitor_, OnSessionReady());
+    session.ProcessIncomingServerHeaders(incoming_headers);
+  }
+
+ protected:
+  quiche::CapsuleParser parser_;
+  quiche::test::MockWriteStream writer_;
+  std::string read_buffer_;
+  quiche::test::ReadStreamFromString reader_;
+  MockSessionVisitor* visitor_ = nullptr;
+  EncapsulatedSession* session_ = nullptr;
+  testing::MockFunction<void(absl::string_view)> fatal_error_callback_;
+};
+
+TEST_F(EncapsulatedWebTransportTest, SetupClientSession) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  quiche::HttpHeaderBlock outgoing_headers, incoming_headers;
+  EXPECT_EQ(session->state(), EncapsulatedSession::kUninitialized);
+  session->InitializeClient(CreateAndStoreVisitor(), outgoing_headers, &writer_,
+                            &reader_);
+  EXPECT_EQ(session->state(), EncapsulatedSession::kWaitingForHeaders);
+  EXPECT_CALL(*visitor_, OnSessionReady());
+  session->ProcessIncomingServerHeaders(incoming_headers);
+  EXPECT_EQ(session->state(), EncapsulatedSession::kSessionOpen);
+}
+
+TEST_F(EncapsulatedWebTransportTest, SetupServerSession) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kServer);
+  quiche::HttpHeaderBlock outgoing_headers, incoming_headers;
+  EXPECT_EQ(session->state(), EncapsulatedSession::kUninitialized);
+  std::unique_ptr<SessionVisitor> visitor = CreateAndStoreVisitor();
+  EXPECT_CALL(*visitor_, OnSessionReady());
+  session->InitializeServer(std::move(visitor), outgoing_headers,
+                            incoming_headers, &writer_, &reader_);
+  EXPECT_EQ(session->state(), EncapsulatedSession::kSessionOpen);
+}
+
+TEST_F(EncapsulatedWebTransportTest, CloseSession) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(*this, OnCapsule(_)).WillOnce([](const Capsule& capsule) {
+    EXPECT_EQ(capsule.capsule_type(), CapsuleType::CLOSE_WEBTRANSPORT_SESSION);
+    EXPECT_EQ(capsule.close_web_transport_session_capsule().error_code, 0x1234);
+    EXPECT_EQ(capsule.close_web_transport_session_capsule().error_message,
+              "test close");
+    return true;
+  });
+  EXPECT_EQ(session->state(), EncapsulatedSession::kSessionOpen);
+  EXPECT_CALL(*visitor_, OnSessionClosed(0x1234, StrEq("test close")));
+  session->CloseSession(0x1234, "test close");
+  EXPECT_EQ(session->state(), EncapsulatedSession::kSessionClosed);
+  EXPECT_TRUE(writer_.fin_written());
+
+  EXPECT_CALL(fatal_error_callback_, Call(_))
+      .WillOnce([](absl::string_view error) {
+        EXPECT_THAT(error, HasSubstr("close a session that is already closed"));
+      });
+  session->CloseSession(0x1234, "test close");
+}
+
+TEST_F(EncapsulatedWebTransportTest, CloseSessionWriteBlocked) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(writer_, CanWrite()).WillOnce(Return(false));
+  EXPECT_CALL(*this, OnCapsule(_)).Times(0);
+  EXPECT_EQ(session->state(), EncapsulatedSession::kSessionOpen);
+  session->CloseSession(0x1234, "test close");
+  EXPECT_EQ(session->state(), EncapsulatedSession::kSessionClosing);
+
+  EXPECT_CALL(*this, OnCapsule(_)).WillOnce([](const Capsule& capsule) {
+    EXPECT_EQ(capsule.capsule_type(), CapsuleType::CLOSE_WEBTRANSPORT_SESSION);
+    EXPECT_EQ(capsule.close_web_transport_session_capsule().error_code, 0x1234);
+    EXPECT_EQ(capsule.close_web_transport_session_capsule().error_message,
+              "test close");
+    return true;
+  });
+  EXPECT_CALL(writer_, CanWrite()).WillOnce(Return(true));
+  EXPECT_CALL(*visitor_, OnSessionClosed(0x1234, StrEq("test close")));
+  session->OnCanWrite();
+  EXPECT_EQ(session->state(), EncapsulatedSession::kSessionClosed);
+  EXPECT_TRUE(writer_.fin_written());
+}
+
+TEST_F(EncapsulatedWebTransportTest, ReceiveFin) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+
+  EXPECT_CALL(*visitor_, OnSessionClosed(0, IsEmpty()));
+  reader_.set_fin();
+  session->OnCanRead();
+  EXPECT_TRUE(writer_.fin_written());
+}
+
+TEST_F(EncapsulatedWebTransportTest, ReceiveCloseSession) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+
+  EXPECT_CALL(*visitor_, OnSessionClosed(0x1234, StrEq("test")));
+  ProcessIncomingCapsule(Capsule::CloseWebTransportSession(0x1234, "test"));
+  EXPECT_TRUE(writer_.fin_written());
+  reader_.set_fin();
+  session->OnCanRead();
+}
+
+TEST_F(EncapsulatedWebTransportTest, ReceiveMalformedData) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+
+  EXPECT_CALL(fatal_error_callback_, Call(HasSubstr("too much capsule data")))
+      .WillOnce([] {});
+  read_buffer_ = std::string(2 * 1024 * 1024, '\xff');
+  session->OnCanRead();
+}
+
+TEST_F(EncapsulatedWebTransportTest, SendDatagrams) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(*this, OnCapsule(_)).WillOnce([](const Capsule& capsule) {
+    EXPECT_EQ(capsule.capsule_type(), quiche::CapsuleType::DATAGRAM);
+    EXPECT_EQ(capsule.datagram_capsule().http_datagram_payload, "test");
+    return true;
+  });
+  DatagramStatus status = session->SendOrQueueDatagram("test");
+  EXPECT_EQ(status.code, DatagramStatusCode::kSuccess);
+}
+
+TEST_F(EncapsulatedWebTransportTest, SendDatagramsEarly) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  quiche::HttpHeaderBlock outgoing_headers;
+  session->InitializeClient(CreateAndStoreVisitor(), outgoing_headers, &writer_,
+                            &reader_);
+  EXPECT_CALL(*this, OnCapsule(_)).WillOnce([](const Capsule& capsule) {
+    EXPECT_EQ(capsule.capsule_type(), quiche::CapsuleType::DATAGRAM);
+    EXPECT_EQ(capsule.datagram_capsule().http_datagram_payload, "test");
+    return true;
+  });
+  ASSERT_EQ(session->state(), EncapsulatedSession::kWaitingForHeaders);
+  session->SendOrQueueDatagram("test");
+}
+
+TEST_F(EncapsulatedWebTransportTest, SendDatagramsBeforeInitialization) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  quiche::HttpHeaderBlock outgoing_headers;
+  EXPECT_CALL(*this, OnCapsule(_)).Times(0);
+  ASSERT_EQ(session->state(), EncapsulatedSession::kUninitialized);
+  session->SendOrQueueDatagram("test");
+
+  EXPECT_CALL(*this, OnCapsule(_)).WillOnce([](const Capsule& capsule) {
+    EXPECT_EQ(capsule.capsule_type(), CapsuleType::DATAGRAM);
+    EXPECT_EQ(capsule.datagram_capsule().http_datagram_payload, "test");
+    return true;
+  });
+  DefaultHandshakeForClient(*session);
+}
+
+TEST_F(EncapsulatedWebTransportTest, SendDatagramsTooBig) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(*this, OnCapsule(_)).Times(0);
+  std::string long_string(16 * 1024, 'a');
+  DatagramStatus status = session->SendOrQueueDatagram(long_string);
+  EXPECT_EQ(status.code, DatagramStatusCode::kTooBig);
+}
+
+TEST_F(EncapsulatedWebTransportTest, ReceiveDatagrams) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(*visitor_, OnDatagramReceived(_))
+      .WillOnce([](absl::string_view data) { EXPECT_EQ(data, "test"); });
+  ProcessIncomingCapsule(Capsule::Datagram("test"));
+}
+
+TEST_F(EncapsulatedWebTransportTest, SendDraining) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(*this, OnCapsule(_)).WillOnce([](const Capsule& capsule) {
+    EXPECT_EQ(capsule.capsule_type(), CapsuleType::DRAIN_WEBTRANSPORT_SESSION);
+    return true;
+  });
+  session->NotifySessionDraining();
+}
+
+TEST_F(EncapsulatedWebTransportTest, ReceiveDraining) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  testing::MockFunction<void()> callback;
+  session->SetOnDraining(callback.AsStdFunction());
+  EXPECT_CALL(callback, Call());
+  ProcessIncomingCapsule(Capsule(quiche::DrainWebTransportSessionCapsule()));
+}
+
+TEST_F(EncapsulatedWebTransportTest, WriteErrorDatagram) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(writer_, Writev(_, _))
+      .WillOnce(Return(absl::InternalError("Test write error")));
+  EXPECT_CALL(fatal_error_callback_, Call(_))
+      .WillOnce([](absl::string_view error) {
+        EXPECT_THAT(error, HasSubstr("Test write error"));
+      });
+  DatagramStatus status = session->SendOrQueueDatagram("test");
+  EXPECT_EQ(status.code, DatagramStatusCode::kInternalError);
+}
+
+TEST_F(EncapsulatedWebTransportTest, WriteErrorControlCapsule) {
+  std::unique_ptr<EncapsulatedSession> session =
+      CreateTransport(Perspective::kClient);
+  DefaultHandshakeForClient(*session);
+  EXPECT_CALL(writer_, Writev(_, _))
+      .WillOnce(Return(absl::InternalError("Test write error")));
+  EXPECT_CALL(fatal_error_callback_, Call(_))
+      .WillOnce([](absl::string_view error) {
+        EXPECT_THAT(error, HasSubstr("Test write error"));
+      });
+  session->NotifySessionDraining();
+}
+
+}  // namespace
+}  // namespace webtransport::test
diff --git a/quiche/web_transport/web_transport.h b/quiche/web_transport/web_transport.h
index be08f89..dbf22f8 100644
--- a/quiche/web_transport/web_transport.h
+++ b/quiche/web_transport/web_transport.h
@@ -24,6 +24,8 @@
 
 namespace webtransport {
 
+enum class Perspective { kClient, kServer };
+
 // A numeric ID uniquely identifying a WebTransport stream. Note that by design,
 // those IDs are not available in the Web API, and the IDs do not necessarily
 // match between client and server perspective, since there may be a proxy