diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index de34250..163b890 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -724,4 +724,40 @@
   return false;
 }
 
+void QuicSpdySession::ProcessPendingStreamType(PendingStream* pending) {
+  DCHECK(VersionHasControlStreams(connection()->transport_version()));
+  struct iovec iov;
+  if (!pending->sequencer()->GetReadableRegion(&iov)) {
+    // We don't have the first byte yet.
+    return;
+  }
+
+  QuicDataReader reader(static_cast<char*>(iov.iov_base), iov.iov_len);
+  uint64_t stream_type = 0;
+  if (!reader.ReadVarInt62(&stream_type)) {
+    return;
+  }
+  CreateIncomingStreamFromPending(pending->id(), stream_type);
+}
+
+void QuicSpdySession::CreateIncomingStreamFromPending(QuicStreamId id,
+                                                      uint64_t stream_type) {
+  switch (stream_type) {
+    case 0x00:  // HTTP/3 control stream.
+      // TODO(renjietang): Create incoming control stream.
+      break;
+    case 0x01:  // Push Stream.
+      break;
+    case 0x02:  // QPACK encoder stream.
+      // TODO(bnc): Create QPACK encoder stream.
+      break;
+    case 0x03:  // QPACK decoder stream.
+      // TODO(bnc): Create QPACK decoder stream.
+      break;
+    default:
+      SendStopSending(0x0D, id);
+      return;
+  }
+}
+
 }  // namespace quic
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 23e57c3..46f2b8a 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -198,6 +198,10 @@
   // Overridden to buffer incoming streams for version 99.
   bool ShouldBufferIncomingStream(QuicStreamId id) const override;
 
+  // Overridden to Process HTTP/3 stream types. No action will be taken if
+  // stream type cannot be read.
+  void ProcessPendingStreamType(PendingStream* pending) override;
+
   size_t WriteHeadersOnHeadersStreamImpl(
       QuicStreamId id,
       spdy::SpdyHeaderBlock headers,
@@ -237,6 +241,10 @@
   void set_max_uncompressed_header_bytes(
       size_t set_max_uncompressed_header_bytes);
 
+  // Creates HTTP/3 unidirectional stream of |id| and |type|. Sends
+  // STOP_SENDING frame if |type| is not supported.
+  void CreateIncomingStreamFromPending(QuicStreamId id, uint64_t type);
+
  private:
   friend class test::QuicSpdySessionPeer;
 
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 6724e69..da920dc 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -267,6 +267,7 @@
 
   using QuicSession::closed_streams;
   using QuicSession::zombie_streams;
+  using QuicSpdySession::ProcessPendingStreamType;
   using QuicSpdySession::ShouldBufferIncomingStream;
 
  private:
@@ -1855,6 +1856,75 @@
   EXPECT_EQ(kV3HighestPriority, stream->priority());
 }
 
+TEST_P(QuicSpdySessionTestServer, SimplePendingStreamType) {
+  if (!VersionHasControlStreams(transport_version())) {
+    return;
+  }
+  PendingStream pending(QuicUtils::GetFirstUnidirectionalStreamId(
+                            transport_version(), Perspective::IS_CLIENT),
+                        &session_);
+  char input[] = {// type
+                  0x04,
+                  // data
+                  'a', 'b', 'c'};
+  QuicStreamFrame data(pending.id(), true, 0, QuicStringPiece(input, 4));
+  pending.OnStreamFrame(data);
+
+  // A stop sending frame will be sent to indicate unknown type.
+  EXPECT_CALL(*connection_, SendControlFrame(_));
+  session_.ProcessPendingStreamType(&pending);
+}
+
+TEST_P(QuicSpdySessionTestServer, SimplePendingStreamTypeOutOfOrderDelivery) {
+  if (!VersionHasControlStreams(transport_version())) {
+    return;
+  }
+  PendingStream pending(QuicUtils::GetFirstUnidirectionalStreamId(
+                            transport_version(), Perspective::IS_CLIENT),
+                        &session_);
+  char input[] = {// type
+                  0x04,
+                  // data
+                  'a', 'b', 'c'};
+  QuicStreamFrame data1(pending.id(), true, 1, QuicStringPiece(&input[1], 3));
+  pending.OnStreamFrame(data1);
+  session_.ProcessPendingStreamType(&pending);
+
+  QuicStreamFrame data2(pending.id(), false, 0, QuicStringPiece(input, 1));
+  pending.OnStreamFrame(data2);
+
+  EXPECT_CALL(*connection_, SendControlFrame(_));
+  session_.ProcessPendingStreamType(&pending);
+}
+
+TEST_P(QuicSpdySessionTestServer,
+       MultipleBytesPendingStreamTypeOutOfOrderDelivery) {
+  if (!VersionHasControlStreams(transport_version())) {
+    return;
+  }
+  PendingStream pending(QuicUtils::GetFirstUnidirectionalStreamId(
+                            transport_version(), Perspective::IS_CLIENT),
+                        &session_);
+  char input[] = {// type (256)
+                  0x40 + 0x01, 0x00,
+                  // data
+                  'a', 'b', 'c'};
+
+  QuicStreamFrame data1(pending.id(), true, 2, QuicStringPiece(&input[2], 3));
+  pending.OnStreamFrame(data1);
+  session_.ProcessPendingStreamType(&pending);
+
+  QuicStreamFrame data2(pending.id(), false, 0, QuicStringPiece(input, 1));
+  pending.OnStreamFrame(data2);
+  session_.ProcessPendingStreamType(&pending);
+
+  QuicStreamFrame data3(pending.id(), false, 1, QuicStringPiece(&input[1], 1));
+  pending.OnStreamFrame(data3);
+
+  EXPECT_CALL(*connection_, SendControlFrame(_));
+  session_.ProcessPendingStreamType(&pending);
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index d85f32c..e0f2458 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -575,6 +575,10 @@
 
   StreamHandler GetOrCreateStreamImpl(QuicStreamId stream_id, bool may_buffer);
 
+  // Processes the stream type information of |pending| depending on
+  // different kinds of sessions's own rules.
+  virtual void ProcessPendingStreamType(PendingStream* pending) {}
+
   bool eliminate_static_stream_map() const {
     return eliminate_static_stream_map_;
   }
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index f9b19b1..bad8a660 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -58,8 +58,8 @@
       sequencer_(this) {}
 
 void PendingStream::OnDataAvailable() {
-  QUIC_BUG << "OnDataAvailable should not be called.";
-  CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, "Unexpected data available");
+  // It will be called when pending stream receives its first byte. But this
+  // call should simply be ignored so that data remains in sequencer.
 }
 
 void PendingStream::OnFinRead() {
@@ -92,7 +92,6 @@
 
 void PendingStream::OnStreamFrame(const QuicStreamFrame& frame) {
   DCHECK_EQ(frame.stream_id, id_);
-  DCHECK_NE(0u, frame.offset);
 
   bool is_stream_too_long =
       (frame.offset > kMaxStreamLength) ||
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 0cacbe3..efe46a6 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -73,6 +73,8 @@
   // Returns the number of bytes read on this stream.
   uint64_t stream_bytes_read() { return stream_bytes_read_; }
 
+  const QuicStreamSequencer* sequencer() const { return &sequencer_; }
+
  private:
   friend class QuicStream;