If the stream is being closed locally (for example in the case of a

net/quic/quic_http_stream_test.cc

Index: net/quic/quic_http_stream_test.cc
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 2c49bcb99e6ad6af8c366a61ef1077827fcc3878..d59ce70291b76bce8a0ea031850a34785a5dc9e3 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -34,6 +34,8 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
+using testing::AnyNumber;
+using testing::Return;
 
 namespace net {
 namespace test {
@@ -168,14 +170,17 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
     runner_ = new TestTaskRunner(&clock_);
     send_algorithm_ = new MockSendAlgorithm();
     receive_algorithm_ = new TestReceiveAlgorithm(NULL);
+    EXPECT_CALL(*receive_algorithm_, RecordIncomingPacket(_, _, _, _)).
+        Times(AnyNumber());
+    EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
-        testing::Return(QuicTime::Delta::Zero()));
+        Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
-        WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
+        WillRepeatedly(Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(
-        testing::Return(QuicTime::Delta::Zero()));
+        Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(
-        testing::Return(QuicBandwidth::Zero()));
+        Return(QuicBandwidth::Zero()));
     helper_ = new QuicConnectionHelper(runner_.get(), &clock_,
                                        &random_generator_, socket);
     connection_ = new TestQuicConnection(guid_, peer_addr_, helper_);
@@ -223,7 +228,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
     return compressor.CompressHeaders(headers);
   }
 
-  // Returns a newly created packet to send kData on stream 1.
+  // Returns a newly created packet to send kData on stream 3.
   QuicEncryptedPacket* ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
       bool should_include_version,
@@ -235,6 +240,14 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
     return ConstructPacket(header_, QuicFrame(&frame));
   }
 
+  // Returns a newly created packet to RST_STREAM stream 3.
+  QuicEncryptedPacket* ConstructRstStreamPacket(
+      QuicPacketSequenceNumber sequence_number) {
+    InitializeHeader(sequence_number, false);
+    QuicRstStreamFrame frame(3, QUIC_SERVER_ERROR_PROCESSING_STREAM);
+    return ConstructPacket(header_, QuicFrame(&frame));
+  }
+
   // Returns a newly created packet to send ack data.
   QuicEncryptedPacket* ConstructAckPacket(
       QuicPacketSequenceNumber sequence_number,
@@ -537,6 +550,7 @@ TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
 TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0, request_data_));
+  AddWrite(SYNCHRONOUS, ConstructRstStreamPacket(2));
   use_closing_stream_ = true;
   Initialize();