Groundwork for cancelling quartc streams after a deadline is exceeded.

net/quic/quartc/quartc_session.cc

 // Copyright (c) 2017 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 "net/quic/quartc/quartc_session.h"
 
 #include "net/quic/platform/api/quic_ptr_util.h"
 
 using std::string;
 
@@ skipping 156 matching lines @@
 void QuartcSession::CloseStream(QuicStreamId stream_id) {
   if (IsClosedStream(stream_id)) {
     // When CloseStream has been called recursively (via
     // QuicStream::OnClose), the stream is already closed so return.
     return;
   }
   write_blocked_streams()->UnregisterStream(stream_id);
   QuicSession::CloseStream(stream_id);
 }
 
+void QuartcSession::CancelStream(QuicStreamId stream_id) {
+  ResetStream(stream_id, QuicRstStreamErrorCode::QUIC_STREAM_CANCELLED);
+}
+
+void QuartcSession::ResetStream(QuicStreamId stream_id,
+                                QuicRstStreamErrorCode error) {
+  if (!IsOpenStream(stream_id)) {
+    return;
+  }
+  QuicStream* stream = QuicSession::GetOrCreateStream(stream_id);
+  if (stream) {
+    stream->Reset(error);
+  }
+}
+
 void QuartcSession::OnConnectionClosed(QuicErrorCode error,
                                        const string& error_details,
                                        ConnectionCloseSource source) {
   QuicSession::OnConnectionClosed(error, error_details, source);
   DCHECK(session_delegate_);
   session_delegate_->OnConnectionClosed(
       error, source == ConnectionCloseSource::FROM_PEER);
 }
 
 void QuartcSession::StartCryptoHandshake() {
@@ skipping 95 matching lines @@
     // Encryption not active so no stream created
     return nullptr;
   }
   auto stream = QuicMakeUnique<QuartcStream>(id, this);
   if (stream) {
     // Register the stream to the QuicWriteBlockedList. |priority| is clamped
     // between 0 and 7, with 0 being the highest priority and 7 the lowest
     // priority.
     write_blocked_streams()->RegisterStream(stream->id(), priority);
 
-    // Incoming streams need to be registered with the session_delegate_.
     if (IsIncomingStream(id)) {
       DCHECK(session_delegate_);
+      // Incoming streams need to be registered with the session_delegate_.
       session_delegate_->OnIncomingStream(stream.get());
+      // Quartc doesn't send on incoming streams.
+      stream->set_fin_sent(true);
+    } else {
+      // Quartc doesn't receive on outgoing streams.
+      stream->set_fin_received(true);
     }
   }
   return stream;
 }
 
 QuartcStream* QuartcSession::ActivateDataStream(
     std::unique_ptr<QuartcStream> stream) {
   // Transfer ownership of the data stream to the session via ActivateStream().
   QuartcStream* raw = stream.release();
   if (raw) {
     // Make QuicSession take ownership of the stream.
     ActivateStream(std::unique_ptr<QuicStream>(raw));
   }
   return raw;
 }
 
 }  // namespace net