Land Recent QUIC changes.

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"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.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/quic_client_session.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
+#include "net/quic/quic_http_utils.h"
+#include "net/quic/quic_reliable_client_stream.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_utils.h"
 #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 "net/spdy/write_blocked_list.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 {
@@ skipping 51 matching lines @@
   }
 
   virtual int OnDataReceived(const char* data, int length) OVERRIDE {
     Close(false);
     return OK;
   }
 };
 
 }  // namespace
 
+class QuicHttpStreamPeer {
+ public:
+  static QuicReliableClientStream* GetQuicReliableClientStream(
+      QuicHttpStream* stream) {
+    return stream->stream_;
+  }
+};
+
 class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
  protected:
   const static bool kFin = true;
   // Holds a packet to be written to the wire, and the IO mode that should
   // be used by the mock socket when performing the write.
   struct PacketToWrite {
     PacketToWrite(IoMode mode, QuicEncryptedPacket* packet)
         : mode(mode),
           packet(packet) {
     }
@@ skipping 55 matching lines @@
                                                     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_, SentPacket(_, _, _, _, _)).Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
         Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
         WillRepeatedly(Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(
         Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(
         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,
                               &crypto_client_stream_factory_,
                               "www.google.com", DefaultQuicConfig(),
                               &crypto_config_, NULL));
     session_->GetCryptoStream()->CryptoConnect();
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
     stream_.reset(use_closing_stream_ ?
                   new AutoClosingStream(session_->GetWeakPtr()) :
                   new QuicHttpStream(session_->GetWeakPtr()));
   }
 
-  void SetRequestString(const std::string& method, const std::string& path) {
+  void SetRequestString(const std::string& method,
+                        const std::string& path,
+                        RequestPriority priority) {
     SpdyHeaderBlock headers;
     headers[":method"] = method;
     headers[":host"] = "www.google.com";
     headers[":path"] = path;
     headers[":scheme"] = "http";
     headers[":version"] = "HTTP/1.1";
-    request_data_ = SerializeHeaderBlock(headers, true);
+    request_data_ = SerializeHeaderBlock(headers, true, priority);
   }
 
   void SetResponseString(const std::string& status, const std::string& body) {
     SpdyHeaderBlock headers;
     headers[":status"] = status;
     headers[":version"] = "HTTP/1.1";
     headers["content-type"] = "text/plain";
-    response_data_ = SerializeHeaderBlock(headers, false) + body;
+    response_data_ = SerializeHeaderBlock(headers, false, DEFAULT_PRIORITY) +
+        body;
   }
 
   std::string SerializeHeaderBlock(const SpdyHeaderBlock& headers,
-                                   bool write_priority) {
+                                   bool write_priority,
+                                   RequestPriority priority) {
     QuicSpdyCompressor compressor;
     if (framer_.version() >= QUIC_VERSION_9 && write_priority) {
-      return compressor.CompressHeadersWithPriority(0, headers);
+      return compressor.CompressHeadersWithPriority(
+          ConvertRequestPriorityToQuicPriority(priority), headers);
     }
     return compressor.CompressHeaders(headers);
   }
 
   // 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);
+    QuicRstStreamFrame frame(3, QUIC_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);
 
@@ skipping 80 matching lines @@
   Initialize();
   EXPECT_TRUE(stream_->CanFindEndOfResponse());
 }
 
 TEST_F(QuicHttpStreamTest, IsConnectionReusable) {
   Initialize();
   EXPECT_FALSE(stream_->IsConnectionReusable());
 }
 
 TEST_F(QuicHttpStreamTest, GetRequest) {
-  SetRequestString("GET", "/");
+  SetRequestString("GET", "/", DEFAULT_PRIORITY);
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0,
                                             request_data_));
   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_,
@@ skipping 22 matching lines @@
   // There is no body, so this should return immediately.
   EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
                                          read_buffer_->size(),
                                          callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 // Regression test for http://crbug.com/288128
 TEST_F(QuicHttpStreamTest, GetRequestLargeResponse) {
-  SetRequestString("GET", "/");
+  SetRequestString("GET", "/", DEFAULT_PRIORITY);
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0,
                                             request_data_));
   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_,
@@ skipping 26 matching lines @@
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
                                          read_buffer_->size(),
                                          callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
-  SetRequestString("GET", "/");
+  SetRequestString("GET", "/", DEFAULT_PRIORITY);
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0, request_data_));
   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 21 matching lines @@
   // There is no body, so this should return immediately.
   // Since the body has already arrived, this should return immediately.
   EXPECT_EQ(12, stream_->ReadResponseBody(read_buffer_.get(),
                                           read_buffer_->size(),
                                           callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, SendPostRequest) {
-  SetRequestString("POST", "/");
+  SetRequestString("POST", "/", DEFAULT_PRIORITY);
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, !kFin, 0, request_data_));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, true, kFin,
                                             request_data_.length(),
                                             kUploadData));
   AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 3, 1));
 
   Initialize();
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
@@ skipping 36 matching lines @@
   // Since the body has already arrived, this should return immediately.
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
-  SetRequestString("POST", "/");
+  SetRequestString("POST", "/", DEFAULT_PRIORITY);
   size_t chunk_size = strlen(kUploadData);
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, !kFin, 0, request_data_));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, true, !kFin,
                                             request_data_.length(),
                                             kUploadData));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(3, true, kFin,
                                             request_data_.length() + chunk_size,
                                             kUploadData));
   AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 3, 1));
 
@@ skipping 41 matching lines @@
   // Since the body has already arrived, this should return immediately.
   ASSERT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, DestroyedEarly) {
-  SetRequestString("GET", "/");
+  SetRequestString("GET", "/", DEFAULT_PRIORITY);
   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()));
+                                     callback_.callback()));
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
 
   // Ack the request.
   scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0, 0));
   ProcessPacket(*ack);
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream_->ReadResponseHeaders(callback_.callback()));
+
+  // Send the response with a body.
+  SetResponseString("404 OK", "hello world!");
+  scoped_ptr<QuicEncryptedPacket> resp(
+      ConstructDataPacket(2, false, kFin, 0, response_data_));
+
+  // In the course of processing this packet, the QuicHttpStream close itself.
+  ProcessPacket(*resp);
+
+  EXPECT_TRUE(AtEof());
+}
+
+TEST_F(QuicHttpStreamTest, Priority) {
+  SetRequestString("GET", "/", MEDIUM);
+  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_, MEDIUM,
+                                          net_log_, callback_.callback()));
+
+  // Check that priority is highest.
+  QuicReliableClientStream* reliable_stream =
+      QuicHttpStreamPeer::GetQuicReliableClientStream(stream_.get());
+  DCHECK(reliable_stream);
+  DCHECK_EQ(static_cast<QuicPriority>(kHighestPriority),
+            reliable_stream->EffectivePriority());
+
+  EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
+                                     callback_.callback()));
+  EXPECT_EQ(&response_, stream_->GetResponseInfo());
+
+  // Check that priority has now dropped back to MEDIUM.
+  DCHECK_EQ(MEDIUM, ConvertQuicPriorityToRequestPriority(
+      reliable_stream->EffectivePriority()));
+
+  // Ack the request.
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0, 0));
+  ProcessPacket(*ack);
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponseString("404 OK", "hello world!");
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, kFin, 0, response_data_));
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net