Update from https://crrev.com/312398

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/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
@@ skipping 64 matching lines @@
     QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
   }
 
   void SetReceiveAlgorithm(ReceiveAlgorithmInterface* receive_algorithm) {
     QuicConnectionPeer::SetReceiveAlgorithm(this, receive_algorithm);
   }
 };
 
 class TestReceiveAlgorithm : public ReceiveAlgorithmInterface {
  public:
-  virtual bool GenerateCongestionFeedback(
-      QuicCongestionFeedbackFrame* /*congestion_feedback*/) {
-    return false;
-  }
-
   MOCK_METHOD3(RecordIncomingPacket,
                void(QuicByteCount, QuicPacketSequenceNumber, QuicTime));
 };
 
 // Subclass of QuicHttpStream that closes itself when the first piece of data
 // is received.
 class AutoClosingStream : public QuicHttpStream {
  public:
   explicit AutoClosingStream(const base::WeakPtr<QuicClientSession>& session)
       : QuicHttpStream(session) {
@@ skipping 158 matching lines @@
     response_headers_ = maker_.GetResponseHeaders(status);
     response_data_ = body;
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
       bool should_include_version,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
-    return maker_.MakeDataPacket(
-        sequence_number, stream_id_, should_include_version, fin, offset, data);
+    return maker_.MakeDataPacket(sequence_number, stream_id_,
+                                 should_include_version, fin, offset, data);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
       QuicPacketSequenceNumber sequence_number,
-      bool fin) {
-    return maker_.MakeRequestHeadersPacket(
-        sequence_number, stream_id_, kIncludeVersion, fin, request_headers_);
+      bool fin,
+      RequestPriority request_priority) {
+    QuicPriority priority =
+        ConvertRequestPriorityToQuicPriority(request_priority);
+    return maker_.MakeRequestHeadersPacket(sequence_number, stream_id_,
+                                           kIncludeVersion, fin, priority,
+                                           request_headers_);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
       QuicPacketSequenceNumber sequence_number,
       bool fin) {
     return maker_.MakeResponseHeadersPacket(
         sequence_number, stream_id_, !kIncludeVersion, fin, response_headers_);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket(
@@ skipping 67 matching lines @@
   EXPECT_TRUE(stream_->CanFindEndOfResponse());
 }
 
 TEST_P(QuicHttpStreamTest, IsConnectionReusable) {
   Initialize();
   EXPECT_FALSE(stream_->IsConnectionReusable());
 }
 
 TEST_P(QuicHttpStreamTest, GetRequest) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
   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 18 matching lines @@
   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_P(QuicHttpStreamTest, GetRequestLargeResponse) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
   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 42 matching lines @@
   session_->connection()->CloseConnection(QUIC_NO_ERROR, true);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED,
             stream_->SendRequest(headers_, &response_,
                                  callback_.callback()));
 }
 
 // Regression test for http://crbug.com/409871
 TEST_P(QuicHttpStreamTest, SessionClosedBeforeReadResponseHeaders) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
   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()));
 
   session_->connection()->CloseConnection(QUIC_NO_ERROR, true);
 
   EXPECT_NE(OK, stream_->ReadResponseHeaders(callback_.callback()));
 }
 
 TEST_P(QuicHttpStreamTest, SendPostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY));
   AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, kUploadData));
   AddWrite(ConstructAckPacket(3, 3, 1));
 
   Initialize();
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadBytesElementReader(kUploadData, strlen(kUploadData)));
   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
   request_.method = "POST";
@@ skipping 27 matching lines @@
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t chunk_size = strlen(kUploadData);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY));
   AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData));
   AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size,
                                kUploadData));
   AddWrite(ConstructAckPacket(4, 3, 1));
   Initialize();
 
   ChunkedUploadDataStream upload_data_stream(0);
   upload_data_stream.AppendData(kUploadData, chunk_size, false);
 
   request_.method = "POST";
@@ skipping 32 matching lines @@
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t chunk_size = strlen(kUploadData);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY));
   AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData));
   AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size, ""));
   AddWrite(ConstructAckPacket(4, 3, 1));
   Initialize();
 
   ChunkedUploadDataStream upload_data_stream(0);
   upload_data_stream.AppendData(kUploadData, chunk_size, false);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
@@ skipping 29 matching lines @@
   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_P(QuicHttpStreamTest, SendChunkedPostRequestWithOneEmptyDataPacket) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY));
   AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, ""));
   AddWrite(ConstructAckPacket(3, 3, 1));
   Initialize();
 
   ChunkedUploadDataStream upload_data_stream(0);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(
@@ skipping 27 matching lines @@
   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_P(QuicHttpStreamTest, DestroyedEarly) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructRequestHeadersPacket(1, kFin));
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY));
   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));
+  AddWrite(ConstructRequestHeadersPacket(1, kFin, MEDIUM));
   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()));
 
@@ skipping 51 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