Remove the --use-spdy-over-quic command line option. Always use SPDY over QUIC.

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/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_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"
 
 namespace net {
 
 static const size_t kHeaderBufInitialSize = 4096;
 
-QuicHttpStream::QuicHttpStream(QuicReliableClientStream* stream,
-                               bool use_spdy)
+QuicHttpStream::QuicHttpStream(QuicReliableClientStream* stream)
     : io_state_(STATE_NONE),
       stream_(stream),
       request_info_(NULL),
       request_body_stream_(NULL),
       response_info_(NULL),
       response_status_(OK),
       response_headers_received_(false),
-      use_spdy_(use_spdy),
       read_buf_(new GrowableIOBuffer()),
       user_buffer_len_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(stream_);
   stream_->SetDelegate(this);
 }
 
 QuicHttpStream::~QuicHttpStream() {
   Close(false);
 }
@@ skipping 12 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);
 
   // Store the serialized request headers.
-  if (use_spdy_) {
-    SpdyHeaderBlock headers;
-    CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
-                                     &headers, 3, /*direct=*/true);
-    size_t len = SpdyFramer::GetSerializedLength(3, &headers);
-    SpdyFrameBuilder builder(len);
-    SpdyFramer::WriteHeaderBlock(&builder, 3, &headers);
-    scoped_ptr<SpdyFrame> frame(builder.take());
-    request_ = std::string(frame->data(), len);
-    // 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));
-  } else {
-    std::string path = HttpUtil::PathForRequest(request_info_->url);
-    std::string first_line = base::StringPrintf("%s %s HTTP/1.1\r\n",
-                                                request_info_->method.c_str(),
-                                                path.c_str());
-    request_ = first_line + request_headers.ToString();
-    // Log the actual request with the URL Request's net log.
-    stream_net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
-        base::Bind(&HttpRequestHeaders::NetLogCallback,
-                   base::Unretained(&request_headers),
-                   &first_line));
-    // Also log to the QuicSession's net log.
-    stream_->net_log().AddEvent(
-        NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS,
-        base::Bind(&HttpRequestHeaders::NetLogCallback,
-                   base::Unretained(&request_headers),
-                   &first_line));
-  }
+  SpdyHeaderBlock headers;
+  CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
+                                   &headers, 3, /*direct=*/true);
+  size_t len = SpdyFramer::GetSerializedLength(3, &headers);
+  SpdyFrameBuilder builder(len);
+  SpdyFramer::WriteHeaderBlock(&builder, 3, &headers);
+  scoped_ptr<SpdyFrame> frame(builder.take());
+  request_ = std::string(frame->data(), len);
+  // 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));
 
   // Store the request body.
   request_body_stream_ = request_info_->upload_data_stream;
   if (request_body_stream_ && (request_body_stream_->size() ||
                                request_body_stream_->is_chunked())) {
     // Use kMaxPacketSize as the buffer size, since the request
     // body data is written with this size at a time.
     // TODO(rch): use a smarter value since we can't write an entire
     // packet due to overhead.
     raw_request_body_buf_ = new IOBufferWithSize(kMaxPacketSize);
@@ skipping 342 matching lines @@
   if (rv < 0) {
     io_state_ = STATE_NONE;
     return rv;
   }
 
   io_state_ = STATE_READ_REQUEST_BODY;
   return OK;
 }
 
 int QuicHttpStream::ParseResponseHeaders() {
-  if (use_spdy_) {
-    size_t read_buf_len = static_cast<size_t>(read_buf_->offset());
-    SpdyFramer framer(3);
-    SpdyHeaderBlock headers;
-    char* data = read_buf_->StartOfBuffer();
-    size_t len = framer.ParseHeaderBlockInBuffer(data, read_buf_->offset(),
-                                                 &headers);
+  size_t read_buf_len = static_cast<size_t>(read_buf_->offset());
+  SpdyFramer framer(3);
+  SpdyHeaderBlock headers;
+  char* data = read_buf_->StartOfBuffer();
+  size_t len = framer.ParseHeaderBlockInBuffer(data, read_buf_->offset(),
+                                               &headers);
 
-    if (len == 0) {
-      return ERR_IO_PENDING;
-    }
-
-    // Save the remaining received data.
-    size_t delta = read_buf_len - len;
-    if (delta > 0) {
-      BufferResponseBody(data + len, delta);
-    }
-
-    // The URLRequest logs these headers, so only log to the QuicSession's
-    // net log.
-    stream_->net_log().AddEvent(
-        NetLog::TYPE_QUIC_HTTP_STREAM_READ_RESPONSE_HEADERS,
-        base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
-
-    if (!SpdyHeadersToHttpResponse(headers, 3, response_info_)) {
-      DLOG(WARNING) << "Invalid headers";
-      return ERR_QUIC_PROTOCOL_ERROR;
-    }
-    // Put the peer's IP address and port into the response.
-    IPEndPoint address = stream_->GetPeerAddress();
-    response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
-    response_info_->vary_data.Init(*request_info_, *response_info_->headers);
-    response_headers_received_ = true;
-
-    return OK;
-  }
-  int end_offset = HttpUtil::LocateEndOfHeaders(read_buf_->StartOfBuffer(),
-                                                read_buf_->offset(), 0);
-
-  if (end_offset == -1) {
+  if (len == 0) {
     return ERR_IO_PENDING;
   }
 
-  if (!stream_)
-    return ERR_UNEXPECTED;
-
-  scoped_refptr<HttpResponseHeaders> headers = new HttpResponseHeaders(
-      HttpUtil::AssembleRawHeaders(read_buf_->StartOfBuffer(), end_offset));
-
-  // Put the peer's IP address and port into the response.
-  IPEndPoint address = stream_->GetPeerAddress();
-  response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
-  response_info_->headers = headers;
-  response_info_->vary_data.Init(*request_info_, *response_info_->headers);
-  response_headers_received_ = true;
+  // Save the remaining received data.
+  size_t delta = read_buf_len - len;
+  if (delta > 0) {
+    BufferResponseBody(data + len, delta);
+  }
 
   // The URLRequest logs these headers, so only log to the QuicSession's
   // net log.
   stream_->net_log().AddEvent(
       NetLog::TYPE_QUIC_HTTP_STREAM_READ_RESPONSE_HEADERS,
-      base::Bind(&HttpResponseHeaders::NetLogCallback,
-                 response_info_->headers));
+      base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
 
-  // Save the remaining received data.
-  int delta = read_buf_->offset() - end_offset;
-  if (delta > 0) {
-    BufferResponseBody(read_buf_->data(), delta);
+  if (!SpdyHeadersToHttpResponse(headers, 3, response_info_)) {
+    DLOG(WARNING) << "Invalid headers";
+    return ERR_QUIC_PROTOCOL_ERROR;
   }
+  // Put the peer's IP address and port into the response.
+  IPEndPoint address = stream_->GetPeerAddress();
+  response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
+  response_info_->vary_data.Init(*request_info_, *response_info_->headers);
+  response_headers_received_ = true;
 
   return OK;
 }
 
 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