This QUIC change includes:

net/quic/core/quic_stream_test.cc

 // Copyright (c) 2012 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/core/quic_stream.h"
 
 #include <memory>
 
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_utils.h"
@@ skipping 44 matching lines @@
   uint32_t ProcessRawData(const char* data, uint32_t data_len) {
     EXPECT_NE(0u, data_len);
     QUIC_DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
   using QuicStream::WriteOrBufferData;
   using QuicStream::CloseWriteSide;
   using QuicStream::OnClose;
+  using QuicStream::SetIsDeletable;
 
  private:
   bool should_process_data_;
   string data_;
 };
 
 class QuicStreamTest : public QuicTestWithParam<bool> {
  public:
   QuicStreamTest()
       : initial_flow_control_window_bytes_(kMaxPacketSize),
@@ skipping 632 matching lines @@
   // Send data and FIN for the response.
   stream_->WriteOrBufferData(kData1, false, nullptr);
   EXPECT_TRUE(QuicStreamPeer::read_side_closed(stream_));
   // Receive remaining data and FIN for the request.
   QuicStreamFrame frame2(stream_->id(), true, 0, QuicStringPiece("End"));
   stream_->OnStreamFrame(frame2);
   EXPECT_TRUE(stream_->fin_received());
   EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
 }
 
+TEST_F(QuicStreamTest, StreamIsDeletable) {
+  Initialize(kShouldProcessData);
+  if (!session_->use_stream_notifier()) {
+    return;
+  }
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
+      .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
+  // Stream is deletable initially.
+  EXPECT_TRUE(stream_->is_deletable());
+
+  // Send kData1.
+  stream_->WriteOrBufferData(kData1, false, nullptr);
+  EXPECT_FALSE(stream_->is_deletable());
+  QuicStreamFrame frame1(stream_->id(), false, 0, kData1);
+  stream_->OnStreamFrameAcked(frame1, QuicTime::Delta::Zero());
+  // Stream is deletable as all sent data is acked.
+  EXPECT_TRUE(stream_->is_deletable());
+
+  // Send kData2.
+  stream_->WriteOrBufferData(kData2, false, nullptr);
+  EXPECT_FALSE(stream_->is_deletable());
+  // Send FIN.
+  stream_->WriteOrBufferData("", true, nullptr);
+
+  // kData2 is acked.
+  QuicStreamFrame frame2(stream_->id(), false, 9, kData2);
+  stream_->OnStreamFrameAcked(frame2, QuicTime::Delta::Zero());
+  // Stream is not deletable as FIN is not acked.
+  EXPECT_FALSE(stream_->is_deletable());
+
+  // FIN is acked.
+  QuicStreamFrame frame3(stream_->id(), true, 18, "");
+  stream_->OnStreamFrameAcked(frame3, QuicTime::Delta::Zero());
+  EXPECT_TRUE(stream_->is_deletable());
+}
+
+TEST_F(QuicStreamTest, CancelStream) {
+  Initialize(kShouldProcessData);
+  if (!session_->use_stream_notifier()) {
+    return;
+  }
+
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
+      .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
+  EXPECT_TRUE(stream_->is_deletable());
+
+  stream_->WriteOrBufferData(kData1, false, nullptr);
+  EXPECT_FALSE(stream_->is_deletable());
+  // Cancel stream.
+  stream_->Reset(QUIC_STREAM_NO_ERROR);
+  // stream is not deletable as the error code is QUIC_STREAM_NO_ERROR, and data
+  // is going to be retransmitted.
+  EXPECT_FALSE(stream_->is_deletable());
+  stream_->Reset(QUIC_STREAM_CANCELLED);
+  // Stream is deletable as data is not going to be retransmitted.
+  EXPECT_TRUE(stream_->is_deletable());
+}
+
+TEST_F(QuicStreamTest, RstFrameReceived) {
+  Initialize(kShouldProcessData);
+  if (!session_->use_stream_notifier()) {
+    return;
+  }
+
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
+      .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
+  EXPECT_TRUE(stream_->is_deletable());
+
+  stream_->WriteOrBufferData(kData1, false, nullptr);
+  EXPECT_FALSE(stream_->is_deletable());
+
+  // RST_STREAM received.
+  QuicRstStreamFrame rst_frame(stream_->id(), QUIC_STREAM_CANCELLED, 1234);
+  stream_->OnStreamReset(rst_frame);
+  // Stream is not deletable as it has outstanding data.
+  EXPECT_FALSE(stream_->is_deletable());
+}
+
+TEST_F(QuicStreamTest, ConnectionClosed) {
+  Initialize(kShouldProcessData);
+  if (!session_->use_stream_notifier()) {
+    return;
+  }
+
+  EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
+      .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData));
+  EXPECT_TRUE(stream_->is_deletable());
+
+  stream_->WriteOrBufferData(kData1, false, nullptr);
+  EXPECT_FALSE(stream_->is_deletable());
+
+  stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR,
+                              ConnectionCloseSource::FROM_SELF);
+  // Stream is deletable as connection is closed.
+  EXPECT_TRUE(stream_->is_deletable());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace net