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

net/quic/quic_http_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/quic_http_stream.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 16 matching lines @@
 #include "net/quic/test_tools/test_task_runner.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
+using testing::AnyNumber;
+using testing::Return;
 
 namespace net {
 namespace test {
 namespace {
 
 const char kUploadData[] = "hello world!";
 
 class TestQuicConnection : public QuicConnection {
  public:
   TestQuicConnection(QuicGuid guid,
@@ skipping 114 matching lines @@
 
     socket_data_.reset(new StaticSocketDataProvider(NULL, 0, mock_writes_.get(),
                                                     writes_.size()));
 
     MockUDPClientSocket* socket = new MockUDPClientSocket(socket_data_.get(),
                                                           net_log_.net_log());
     socket->Connect(peer_addr_);
     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_);
     connection_->set_visitor(&visitor_);
     connection_->SetSendAlgorithm(send_algorithm_);
     connection_->SetReceiveAlgorithm(receive_algorithm_);
     crypto_config_.SetDefaults();
     session_.reset(
         new QuicClientSession(connection_,
                               scoped_ptr<DatagramClientSocket>(socket), NULL,
@@ skipping 27 matching lines @@
 
   std::string SerializeHeaderBlock(const SpdyHeaderBlock& headers,
                                    bool write_priority) {
     QuicSpdyCompressor compressor;
     if (framer_.version() >= QUIC_VERSION_9 && write_priority) {
       return compressor.CompressHeadersWithPriority(0, headers);
     }
     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,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
     InitializeHeader(sequence_number, should_include_version);
     QuicStreamFrame frame(3, fin, offset, data);
     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,
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
     InitializeHeader(sequence_number, false);
 
     QuicAckFrame ack(largest_received, QuicTime::Zero(), least_unacked);
     ack.sent_info.entropy_hash = 0;
     ack.received_info.entropy_hash = 0;
@@ skipping 282 matching lines @@
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0, request_data_));
+  AddWrite(SYNCHRONOUS, ConstructRstStreamPacket(2));
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                     callback_.callback()));
@@ skipping 12 matching lines @@
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net