relnote: Call methods to handle QUIC frames immediately instead of

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 "base/thread_task_runner_handle.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/transport_security_state.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_server_info.h"
 #include "net/quic/quic_client_session.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_default_packet_writer.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_reliable_client_stream.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_packet_maker.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 231 matching lines @@
         sequence_number, stream_id_, !kIncludeVersion, fin, response_headers_);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket(
       QuicPacketSequenceNumber sequence_number) {
     return maker_.MakeRstPacket(
         sequence_number, true, stream_id_,
         AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
   }
 
+  scoped_ptr<QuicEncryptedPacket> ConstructRstStreamCancelledPacket(
+      QuicPacketSequenceNumber sequence_number) {
+    return maker_.MakeRstPacket(sequence_number, !kIncludeVersion, stream_id_,
+                                QUIC_STREAM_CANCELLED);
+  }
+
   scoped_ptr<QuicEncryptedPacket> ConstructAckAndRstStreamPacket(
       QuicPacketSequenceNumber sequence_number) {
     return maker_.MakeAckAndRstPacket(
         sequence_number, !kIncludeVersion, stream_id_, QUIC_STREAM_CANCELLED,
         2, 1, !kIncludeCongestionFeedback);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicPacketSequenceNumber largest_received,
@@ skipping 369 matching lines @@
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, DestroyedEarly) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
-  AddWrite(ConstructAckAndRstStreamPacket(2));
+  if (FLAGS_quic_process_frames_inline) {
+    AddWrite(ConstructRstStreamCancelledPacket(2));
+  } else {
+    AddWrite(ConstructAckAndRstStreamPacket(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()));
 
   // Ack the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponse("404 OK", "hello world!");
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
 
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, Priority) {
   SetRequest("GET", "/", MEDIUM);
   AddWrite(ConstructRequestHeadersPacket(1, kFin, MEDIUM));
-  AddWrite(ConstructAckAndRstStreamPacket(2));
+  if (FLAGS_quic_process_frames_inline) {
+    AddWrite(ConstructRstStreamCancelledPacket(2));
+  } else {
+    AddWrite(ConstructAckAndRstStreamPacket(2));
+  }
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM,
                                           net_log_, callback_.callback()));
 
   // Check that priority is highest.
@@ skipping 50 matching lines @@
   // Set Delegate to nullptr and make sure EffectivePriority returns highest
   // priority.
   reliable_stream->SetDelegate(nullptr);
   DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
             reliable_stream->EffectivePriority());
   reliable_stream->SetDelegate(delegate);
 }
 
 }  // namespace test
 }  // namespace net