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

net/quic/quic_stream_factory_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/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
@@ skipping 29 matching lines @@
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket(
       QuicPacketSequenceNumber num,
       QuicStreamId stream_id) {
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
     header.public_header.reset_flag = false;
     header.public_header.version_flag = true;
     header.packet_sequence_number = num;
+    header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
     header.entropy_flag = false;
     header.fec_flag = false;
     header.fec_group = 0;
 
-    QuicRstStreamFrame rst(stream_id, QUIC_STREAM_NO_ERROR);
+    QuicRstStreamFrame rst(stream_id, QUIC_SERVER_ERROR_PROCESSING_STREAM);
     return scoped_ptr<QuicEncryptedPacket>(
         ConstructPacket(header, QuicFrame(&rst)));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
     header.public_header.reset_flag = false;
@@ skipping 101 matching lines @@
   stream.reset();  // Will reset stream 7.
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 TEST_F(QuicStreamFactoryTest, MaxOpenStream) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
-  DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
+  scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket(1, 3));
+  MockWrite writes[] = {
+    MockWrite(ASYNC, rst->data(), rst->length(), 1),
+  };
+  DeterministicSocketData socket_data(reads, arraysize(reads),
+                                      writes, arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   HttpRequestInfo request_info;
   std::vector<QuicHttpStream*> streams;
   // The MockCryptoClientStream sets max_open_streams to be
   // 2 * kDefaultMaxStreamsPerConnection.
   for (size_t i = 0; i < 2 * kDefaultMaxStreamsPerConnection; i++) {
     QuicStreamRequest request(&factory_);
     int rv = request.Request(host_port_proxy_pair_, is_https_,
@@ skipping 172 matching lines @@
   stream.reset();  // Will reset stream 3.
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
   EXPECT_TRUE(socket_data2.at_write_eof());
 }
 
 }  // namespace test
 }  // namespace net