diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 647cef7..a7f3df8 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -1797,6 +1797,21 @@
          peer_supports_webtransport_;
 }
 
+WebTransportHttp3* QuicSpdySession::GetWebTransportSession(
+    WebTransportSessionId id) {
+  if (!SupportsWebTransport()) {
+    return nullptr;
+  }
+  if (!IsValidWebTransportSessionId(id, version())) {
+    return nullptr;
+  }
+  QuicSpdyStream* connect_stream = GetOrCreateSpdyDataStream(id);
+  if (connect_stream == nullptr) {
+    return nullptr;
+  }
+  return connect_stream->web_transport();
+}
+
 #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 bd5cb00..bbd97fc 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -461,6 +461,10 @@
   // Indicates whether the HTTP/3 session supports WebTransport.
   bool SupportsWebTransport();
 
+  // Returns a WebTransport session by its session ID.  Returns nullptr if no
+  // session is associated with the given ID.
+  WebTransportHttp3* GetWebTransportSession(WebTransportSessionId id);
+
  protected:
   // Override CreateIncomingStream(), CreateOutgoingBidirectionalStream() and
   // CreateOutgoingUnidirectionalStream() with QuicSpdyStream return type to
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index c532322..db3b98e 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -5,6 +5,7 @@
 #include "quic/core/http/quic_spdy_stream.h"
 
 #include <limits>
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -15,6 +16,7 @@
 #include "quic/core/http/http_decoder.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/qpack/qpack_decoder.h"
 #include "quic/core/qpack/qpack_encoder.h"
 #include "quic/core/quic_utils.h"
@@ -287,6 +289,8 @@
                       nullptr);
   }
 
+  MaybeProcessSentWebTransportHeaders(header_block);
+
   size_t bytes_written =
       WriteHeadersImpl(std::move(header_block), fin, std::move(ack_listener));
   if (!VersionUsesHttp3(transport_version()) && fin) {
@@ -648,6 +652,8 @@
   headers_decompressed_ = true;
   header_list_ = header_list;
 
+  MaybeProcessReceivedWebTransportHeaders();
+
   if (VersionUsesHttp3(transport_version())) {
     if (fin) {
       OnStreamFrame(QuicStreamFrame(id(), /* fin = */ true,
@@ -1163,5 +1169,64 @@
   return encoded_headers.size();
 }
 
+void QuicSpdyStream::MaybeProcessReceivedWebTransportHeaders() {
+  if (!spdy_session_->SupportsWebTransport()) {
+    return;
+  }
+  if (session()->perspective() != Perspective::IS_SERVER) {
+    return;
+  }
+  QUICHE_DCHECK(IsValidWebTransportSessionId(id(), version()));
+
+  std::string method;
+  std::string protocol;
+  for (const auto& header : header_list_) {
+    const std::string& header_name = header.first;
+    const std::string& header_value = header.second;
+    if (header_name == ":method") {
+      if (!method.empty() || header_value.empty()) {
+        return;
+      }
+      method = header_value;
+    }
+    if (header_name == ":protocol") {
+      if (!protocol.empty() || header_value.empty()) {
+        return;
+      }
+      protocol = header_value;
+    }
+  }
+
+  if (method != "CONNECT" || protocol != "webtransport") {
+    return;
+  }
+
+  web_transport_ =
+      std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
+}
+
+void QuicSpdyStream::MaybeProcessSentWebTransportHeaders(
+    spdy::SpdyHeaderBlock& headers) {
+  if (!spdy_session_->SupportsWebTransport()) {
+    return;
+  }
+  if (session()->perspective() != Perspective::IS_CLIENT) {
+    return;
+  }
+  QUICHE_DCHECK(IsValidWebTransportSessionId(id(), version()));
+
+  const auto method_it = headers.find(":method");
+  const auto protocol_it = headers.find(":protocol");
+  if (method_it == headers.end() || protocol_it == headers.end()) {
+    return;
+  }
+  if (method_it->second != "CONNECT" && protocol_it->second != "webtransport") {
+    return;
+  }
+
+  web_transport_ =
+      std::make_unique<WebTransportHttp3>(spdy_session_, this, id());
+}
+
 #undef ENDPOINT  // undef for jumbo builds
 }  // namespace quic
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 60d5e39..f3ec720 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -13,6 +13,7 @@
 
 #include <cstddef>
 #include <list>
+#include <memory>
 #include <string>
 
 #include "absl/strings/string_view.h"
@@ -28,6 +29,7 @@
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_socket_address.h"
 #include "spdy/core/spdy_framer.h"
+#include "spdy/core/spdy_header_block.h"
 
 namespace quic {
 
@@ -37,6 +39,7 @@
 }  // namespace test
 
 class QuicSpdySession;
+class WebTransportHttp3;
 
 // A QUIC stream that can send and receive HTTP2 (SPDY) headers.
 class QUIC_EXPORT_PRIVATE QuicSpdyStream
@@ -222,6 +225,9 @@
   // |last_sent_urgency_| is different from current priority.
   void MaybeSendPriorityUpdateFrame() override;
 
+  // Returns the WebTransport session owned by this stream, if one exists.
+  WebTransportHttp3* web_transport() { return web_transport_.get(); }
+
  protected:
   // Called when the received headers are too large. By default this will
   // reset the stream.
@@ -279,6 +285,9 @@
   QuicByteCount GetNumFrameHeadersInInterval(QuicStreamOffset offset,
                                              QuicByteCount data_length) const;
 
+  void MaybeProcessSentWebTransportHeaders(spdy::SpdyHeaderBlock& headers);
+  void MaybeProcessReceivedWebTransportHeaders();
+
   QuicSpdySession* spdy_session_;
 
   bool on_body_available_called_because_sequencer_is_closed_;
@@ -339,6 +348,10 @@
   // Urgency value sent in the last PRIORITY_UPDATE frame, or default urgency
   // defined by the spec if no PRIORITY_UPDATE frame has been sent.
   int last_sent_urgency_;
+
+  // If this stream is a WebTransport extended CONNECT stream, contains the
+  // WebTransport session associated with this stream.
+  std::unique_ptr<WebTransportHttp3> web_transport_;
 };
 
 }  // namespace quic
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 0e35c28..424fa0a 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -15,6 +15,7 @@
 #include "quic/core/crypto/null_encrypter.h"
 #include "quic/core/http/http_encoder.h"
 #include "quic/core/http/spdy_utils.h"
+#include "quic/core/http/web_transport_http3.h"
 #include "quic/core/quic_connection.h"
 #include "quic/core/quic_stream_sequencer_buffer.h"
 #include "quic/core/quic_utils.h"
@@ -255,6 +256,8 @@
     return &crypto_stream_;
   }
 
+  bool ShouldNegotiateWebTransport() override { return true; }
+
  private:
   StrictMock<TestCryptoStream> crypto_stream_;
 };
@@ -3071,6 +3074,47 @@
   }
 }
 
+TEST_P(QuicSpdyStreamTest, ProcessOutgoingWebTransportHeaders) {
+  if (!UsesHttp3()) {
+    return;
+  }
+
+  InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
+  QuicSpdySessionPeer::EnableWebTransport(*session_);
+
+  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, ProcessIncomingWebTransportHeaders) {
+  if (!UsesHttp3()) {
+    return;
+  }
+
+  Initialize(kShouldProcessData);
+  QuicSpdySessionPeer::EnableWebTransport(*session_);
+
+  headers_[":method"] = "CONNECT";
+  headers_[":protocol"] = "webtransport";
+
+  stream_->OnStreamHeadersPriority(
+      spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  ProcessHeaders(false, headers_);
+  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());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/http/web_transport_http3.cc b/quic/core/http/web_transport_http3.cc
new file mode 100644
index 0000000..0c7c9a8
--- /dev/null
+++ b/quic/core/http/web_transport_http3.cc
@@ -0,0 +1,75 @@
+// Copyright 2021 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 "quic/core/http/web_transport_http3.h"
+
+#include <memory>
+
+#include "quic/core/http/quic_spdy_session.h"
+#include "quic/core/http/quic_spdy_stream.h"
+
+namespace quic {
+
+namespace {
+class QUIC_EXPORT_PRIVATE NoopWebTransportVisitor : public WebTransportVisitor {
+  void OnSessionReady() override {}
+  void OnIncomingBidirectionalStreamAvailable() override {}
+  void OnIncomingUnidirectionalStreamAvailable() override {}
+  void OnDatagramReceived(absl::string_view /*datagram*/) override {}
+  void OnCanCreateNewOutgoingBidirectionalStream() override {}
+  void OnCanCreateNewOutgoingUnidirectionalStream() override {}
+};
+}  // namespace
+
+WebTransportHttp3::WebTransportHttp3(QuicSpdySession* session,
+                                     QuicSpdyStream* connect_stream,
+                                     WebTransportSessionId id)
+    : session_(session),
+      connect_stream_(connect_stream),
+      id_(id),
+      visitor_(std::make_unique<NoopWebTransportVisitor>()) {}
+
+void WebTransportHttp3::HeadersReceived(
+    const spdy::SpdyHeaderBlock& /*headers*/) {
+  ready_ = true;
+  visitor_->OnSessionReady();
+}
+
+WebTransportStream* WebTransportHttp3::AcceptIncomingBidirectionalStream() {
+  // TODO(vasilvv): implement this.
+  return nullptr;
+}
+WebTransportStream* WebTransportHttp3::AcceptIncomingUnidirectionalStream() {
+  // TODO(vasilvv): implement this.
+  return nullptr;
+}
+
+bool WebTransportHttp3::CanOpenNextOutgoingBidirectionalStream() {
+  // TODO(vasilvv): implement this.
+  return false;
+}
+bool WebTransportHttp3::CanOpenNextOutgoingUnidirectionalStream() {
+  // TODO(vasilvv): implement this.
+  return false;
+}
+WebTransportStream* WebTransportHttp3::OpenOutgoingBidirectionalStream() {
+  // TODO(vasilvv): implement this.
+  return nullptr;
+}
+WebTransportStream* WebTransportHttp3::OpenOutgoingUnidirectionalStream() {
+  // TODO(vasilvv): implement this.
+  return nullptr;
+}
+
+MessageStatus WebTransportHttp3::SendOrQueueDatagram(
+    QuicMemSlice /*datagram*/) {
+  // TODO(vasilvv): implement this.
+  return MessageStatus::MESSAGE_STATUS_UNSUPPORTED;
+}
+void WebTransportHttp3::SetDatagramMaxTimeInQueue(
+    QuicTime::Delta /*max_time_in_queue*/) {
+  // TODO(vasilvv): implement this.
+}
+
+}  // namespace quic
diff --git a/quic/core/http/web_transport_http3.h b/quic/core/http/web_transport_http3.h
new file mode 100644
index 0000000..7176411
--- /dev/null
+++ b/quic/core/http/web_transport_http3.h
@@ -0,0 +1,62 @@
+// Copyright 2021 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_QUIC_CORE_HTTP_WEB_TRANSPORT_HTTP3_H_
+#define QUICHE_QUIC_CORE_HTTP_WEB_TRANSPORT_HTTP3_H_
+
+#include <memory>
+
+#include "quic/core/quic_types.h"
+#include "quic/core/web_transport_interface.h"
+#include "spdy/core/spdy_header_block.h"
+
+namespace quic {
+
+class QuicSpdySession;
+class QuicSpdyStream;
+
+// A session of WebTransport over HTTP/3.  The session is owned by
+// QuicSpdyStream object for the CONNECT stream that established it.
+//
+// WebTransport over HTTP/3 specification:
+// <https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3>
+class QUIC_EXPORT_PRIVATE WebTransportHttp3 : public WebTransportSession {
+ public:
+  WebTransportHttp3(QuicSpdySession* session,
+                    QuicSpdyStream* connect_stream,
+                    WebTransportSessionId id);
+
+  void HeadersReceived(const spdy::SpdyHeaderBlock& headers);
+  void SetVisitor(std::unique_ptr<WebTransportVisitor> visitor) {
+    visitor_ = std::move(visitor);
+  }
+
+  WebTransportSessionId id() { return id_; }
+
+  // Return the earliest incoming stream that has been received by the session
+  // but has not been accepted.  Returns nullptr if there are no incoming
+  // streams.
+  WebTransportStream* AcceptIncomingBidirectionalStream() override;
+  WebTransportStream* AcceptIncomingUnidirectionalStream() override;
+
+  bool CanOpenNextOutgoingBidirectionalStream() override;
+  bool CanOpenNextOutgoingUnidirectionalStream() override;
+  WebTransportStream* OpenOutgoingBidirectionalStream() override;
+  WebTransportStream* OpenOutgoingUnidirectionalStream() override;
+
+  MessageStatus SendOrQueueDatagram(QuicMemSlice datagram) override;
+  void SetDatagramMaxTimeInQueue(QuicTime::Delta max_time_in_queue) override;
+
+ private:
+  const QuicSpdySession* session_;        // Unowned.
+  const QuicSpdyStream* connect_stream_;  // Unowned.
+  const WebTransportSessionId id_;
+  // |ready_| is set to true when the peer has seen both sets of headers.
+  bool ready_ = false;
+  std::unique_ptr<WebTransportVisitor> visitor_;
+};
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_CORE_HTTP_WEB_TRANSPORT_HTTP3_H_
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h
index 0e13f56..83404c5 100644
--- a/quic/core/quic_types.h
+++ b/quic/core/quic_types.h
@@ -7,6 +7,7 @@
 
 #include <array>
 #include <cstddef>
+#include <cstdint>
 #include <map>
 #include <ostream>
 #include <vector>
@@ -43,6 +44,9 @@
 using DiversificationNonce = std::array<char, 32>;
 using PacketTimeVector = std::vector<std::pair<QuicPacketNumber, QuicTime>>;
 
+// WebTransport session IDs are stream IDs.
+using WebTransportSessionId = uint64_t;
+
 enum : size_t { kQuicPathFrameBufferSize = 8 };
 using QuicPathFrameBuffer = std::array<uint8_t, kQuicPathFrameBufferSize>;
 
@@ -708,10 +712,10 @@
 
 // Indicates the fate of a serialized packet in WritePacket().
 enum SerializedPacketFate : uint8_t {
-  DISCARD,         // Discard the packet.
-  COALESCE,        // Try to coalesce packet.
-  BUFFER,          // Buffer packet in buffered_packets_.
-  SEND_TO_WRITER,  // Send packet to writer.
+  DISCARD,                     // Discard the packet.
+  COALESCE,                    // Try to coalesce packet.
+  BUFFER,                      // Buffer packet in buffered_packets_.
+  SEND_TO_WRITER,              // Send packet to writer.
   LEGACY_VERSION_ENCAPSULATE,  // Perform Legacy Version Encapsulation on this
                                // packet.
 };
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index c26b8dd..1f190e0 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cstdint>
 #include <cstring>
+#include <limits>
 #include <string>
 
 #include "absl/base/macros.h"
@@ -21,6 +22,7 @@
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_prefetch.h"
 #include "quic/platform/api/quic_uint128.h"
+#include "common/platform/api/quiche_logging.h"
 #include "common/quiche_endian.h"
 
 namespace quic {
@@ -686,5 +688,13 @@
   }
 }
 
+bool IsValidWebTransportSessionId(WebTransportSessionId id,
+                                  ParsedQuicVersion version) {
+  QUICHE_DCHECK(version.UsesHttp3());
+  return (id <= std::numeric_limits<QuicStreamId>::max()) &&
+         QuicUtils::IsBidirectionalStreamId(id, version) &&
+         QuicUtils::IsClientInitiatedStreamId(version.transport_version, id);
+}
+
 #undef RETURN_STRING_LITERAL  // undef for jumbo builds
 }  // namespace quic
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 9175117..463b63f 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -239,6 +239,11 @@
   static bool IsProbingFrame(QuicFrameType type);
 };
 
+// Returns true if the specific ID is a valid WebTransport session ID that our
+// implementation can process.
+bool IsValidWebTransportSessionId(WebTransportSessionId id,
+                                  ParsedQuicVersion transport_version);
+
 template <typename Mask>
 class QUIC_EXPORT_PRIVATE BitMask {
  public:
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index d41ddfd..aee5d12 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -7,7 +7,9 @@
 #include "quic/core/http/quic_spdy_session.h"
 #include "quic/core/qpack/qpack_receive_stream.h"
 #include "quic/core/quic_utils.h"
+#include "quic/platform/api/quic_flags.h"
 #include "quic/test_tools/quic_session_peer.h"
+#include "common/platform/api/quiche_logging.h"
 
 namespace quic {
 namespace test {
@@ -115,5 +117,13 @@
   session->h3_datagram_supported_ = h3_datagram_supported;
 }
 
+// static
+void QuicSpdySessionPeer::EnableWebTransport(QuicSpdySession& session) {
+  SetQuicReloadableFlag(quic_h3_datagram, true);
+  QUICHE_DCHECK(session.WillNegotiateWebTransport());
+  session.h3_datagram_supported_ = true;
+  session.peer_supports_webtransport_ = true;
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/quic_spdy_session_peer.h b/quic/test_tools/quic_spdy_session_peer.h
index 4ad0367..bbcb696 100644
--- a/quic/test_tools/quic_spdy_session_peer.h
+++ b/quic/test_tools/quic_spdy_session_peer.h
@@ -59,6 +59,7 @@
       QuicSpdySession* session);
   static void SetH3DatagramSupported(QuicSpdySession* session,
                                      bool h3_datagram_supported);
+  static void EnableWebTransport(QuicSpdySession& session);
 };
 
 }  // namespace test