Land Recent QUIC changes.

net/quic/quic_http_stream.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 "base/callback_helpers.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/quic/quic_client_session.h"
+#include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_reliable_client_stream.h"
 #include "net/quic/quic_utils.h"
 #include "net/socket/next_proto.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/ssl/ssl_info.h"
 
 namespace net {
 
 static const size_t kHeaderBufInitialSize = 4096;
 
 QuicHttpStream::QuicHttpStream(const base::WeakPtr<QuicClientSession> session)
     : next_state_(STATE_NONE),
       session_(session),
       stream_(NULL),
       request_info_(NULL),
       request_body_stream_(NULL),
+      priority_(MINIMUM_PRIORITY),
       response_info_(NULL),
       response_status_(OK),
       response_headers_received_(false),
       read_buf_(new GrowableIOBuffer()),
       user_buffer_len_(0),
       weak_factory_(this) {
   DCHECK(session_);
 }
 
 QuicHttpStream::~QuicHttpStream() {
   Close(false);
 }
 
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   DCHECK(!stream_);
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
   stream_net_log_ = stream_net_log;
   request_info_ = request_info;
+  priority_ = priority;
 
   int rv = stream_request_.StartRequest(
       session_, &stream_, base::Bind(&QuicHttpStream::OnStreamReady,
                                      weak_factory_.GetWeakPtr()));
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   if (rv == OK)
     stream_->SetDelegate(this);
 
@@ skipping 10 matching lines @@
 
 int QuicHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
                                 HttpResponseInfo* response,
                                 const CompletionCallback& callback) {
   CHECK(stream_);
   CHECK(!request_body_stream_);
   CHECK(!response_info_);
   CHECK(!callback.is_null());
   CHECK(response);
 
+  QuicPriority priority = ConvertRequestPriorityToQuicPriority(priority_);
+  stream_->set_priority(priority);
   // Store the serialized request headers.
   SpdyHeaderBlock headers;
   CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
                                    &headers, 3, /*direct=*/true);
   if (session_->connection()->version() < QUIC_VERSION_9) {
     request_ = stream_->compressor()->CompressHeaders(headers);
   } else {
-    request_ = stream_->compressor()->CompressHeadersWithPriority(0, headers);
+    request_ = stream_->compressor()->CompressHeadersWithPriority(priority,
+                                                                  headers);
   }
   // Log the actual request with the URL Request's net log.
   stream_net_log_.AddEvent(
       NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
       base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
   // Also log to the QuicSession's net log.
   stream_->net_log().AddEvent(
       NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS,
       base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
 
@@ skipping 97 matching lines @@
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 void QuicHttpStream::Close(bool not_reusable) {
   // Note: the not_reusable flag has no meaning for SPDY streams.
   if (stream_) {
     stream_->SetDelegate(NULL);
     // TODO(rch): use new CANCELLED error code here once quic 11
     // is everywhere.
-    stream_->Close(QUIC_SERVER_ERROR_PROCESSING_STREAM);
+    stream_->Close(QUIC_ERROR_PROCESSING_STREAM);
     stream_ = NULL;
   }
 }
 
 HttpStream* QuicHttpStream::RenewStreamForAuth() {
   return NULL;
 }
 
 bool QuicHttpStream::IsResponseBodyComplete() const {
   return next_state_ == STATE_OPEN && !stream_;
@@ skipping 36 matching lines @@
 bool QuicHttpStream::IsSpdyHttpStream() const {
   return false;
 }
 
 void QuicHttpStream::Drain(HttpNetworkSession* session) {
   Close(false);
   delete this;
 }
 
 void QuicHttpStream::SetPriority(RequestPriority priority) {
-  // Nothing to do here (yet).
+  priority_ = priority;
 }
 
 int QuicHttpStream::OnSendData() {
   // TODO(rch): Change QUIC IO to provide notifications to the streams.
   NOTREACHED();
   return OK;
 }
 
 int QuicHttpStream::OnSendDataComplete(int status, bool* eof) {
   // TODO(rch): Change QUIC IO to provide notifications to the streams.
@@ skipping 51 matching lines @@
     DoCallback(response_status_);
 }
 
 void QuicHttpStream::OnError(int error) {
   stream_ = NULL;
   response_status_ = error;
   if (!callback_.is_null())
     DoCallback(response_status_);
 }
 
+bool QuicHttpStream::HasSendHeadersComplete() {
+  return next_state_ > STATE_SEND_HEADERS_COMPLETE;
+}
+
 void QuicHttpStream::OnIOComplete(int rv) {
   rv = DoLoop(rv);
 
   if (rv != ERR_IO_PENDING && !callback_.is_null()) {
     DoCallback(rv);
   }
 }
 
 void QuicHttpStream::DoCallback(int rv) {
   CHECK_NE(rv, ERR_IO_PENDING);
@@ skipping 167 matching lines @@
 
 void QuicHttpStream::BufferResponseBody(const char* data, int length) {
   if (length == 0)
     return;
   IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
   memcpy(io_buffer->data(), data, length);
   response_body_.push_back(make_scoped_refptr(io_buffer));
 }
 
 }  // namespace net