Add support for speaking SPDY to an HTTPS proxy....

net/spdy/spdy_http_stream.cc

 // Copyright (c) 2010 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/spdy/spdy_http_stream.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 
@@ skipping 73 matching lines @@
   }
 
   response->headers = new net::HttpResponseHeaders(raw_headers);
   response->was_fetched_via_spdy = true;
   return true;
 }
 
 // Create a SpdyHeaderBlock for a Spdy SYN_STREAM Frame from
 // a HttpRequestInfo block.
 void CreateSpdyHeadersFromHttpRequest(
-    const net::HttpRequestInfo& info, spdy::SpdyHeaderBlock* headers) {
+    const net::HttpRequestInfo& info, spdy::SpdyHeaderBlock* headers,
+    bool direct) {
   // TODO(willchan): It's not really necessary to convert from
   // HttpRequestHeaders to spdy::SpdyHeaderBlock.
 
   static const char kHttpProtocolVersion[] = "HTTP/1.1";
 
   net::HttpRequestHeaders::Iterator it(info.extra_headers);
 
   while (it.GetNext()) {
     std::string name = StringToLowerASCII(it.name());
     if (headers->find(name) == headers->end()) {
@@ skipping 19 matching lines @@
         base::Int64ToString(info.upload_data->GetContentLength());
   } else if (info.method == "POST" || info.method == "PUT" ||
              info.method == "HEAD") {
     // An empty POST/PUT request still needs a content length.  As for HEAD,
     // IE and Safari also add a content length header.  Presumably it is to
     // support sending a HEAD request to an URL that only expects to be sent a
     // POST or some other method that normally would have a message body.
     (*headers)["content-length"] = "0";
   }
 
-  (*headers)["url"] = net::HttpUtil::PathForRequest(info.url);
+  if (direct)
+    (*headers)["url"] = net::HttpUtil::PathForRequest(info.url);
+  else
+    (*headers)["url"] = net::HttpUtil::SpecForRequest(info.url);
   (*headers)["host"] = net::GetHostAndOptionalPort(info.url);
   (*headers)["scheme"] = info.url.scheme();
   (*headers)["version"] = kHttpProtocolVersion;
   if (!info.referrer.is_empty())
     (*headers)["referer"] = info.referrer.spec();
 
   // Honor load flags that impact proxy caches.
   if (info.load_flags & net::LOAD_BYPASS_CACHE) {
     (*headers)["pragma"] = "no-cache";
     (*headers)["cache-control"] = "no-cache";
   } else if (info.load_flags & net::LOAD_VALIDATE_CACHE) {
     (*headers)["cache-control"] = "max-age=0";
   }
 }
 
 }  // anonymous namespace
 
 namespace net {
 
-SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session)
+SpdyHttpStream::SpdyHttpStream(SpdySession* spdy_session, bool direct)
     : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_factory_(this)),
       stream_(NULL),
       spdy_session_(spdy_session),
       response_info_(NULL),
       download_finished_(false),
       user_callback_(NULL),
       user_buffer_len_(0),
       buffered_read_callback_pending_(false),
-      more_read_data_pending_(false) { }
+      more_read_data_pending_(false),
+      direct_(direct) { }
 
 SpdyHttpStream::~SpdyHttpStream() {
   if (stream_)
     stream_->DetachDelegate();
 }
 
 int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      const BoundNetLog& stream_net_log,
                                      CompletionCallback* callback) {
   if (spdy_session_->IsClosed())
@@ skipping 98 matching lines @@
 int SpdyHttpStream::SendRequest(const std::string& /*headers_string*/,
                                 UploadDataStream* request_body,
                                 HttpResponseInfo* response,
                                 CompletionCallback* callback) {
   base::Time request_time = base::Time::Now();
   CHECK(stream_.get());
 
   stream_->SetDelegate(this);
 
   linked_ptr<spdy::SpdyHeaderBlock> headers(new spdy::SpdyHeaderBlock);
-  CreateSpdyHeadersFromHttpRequest(*request_info_, headers.get());
+  CreateSpdyHeadersFromHttpRequest(*request_info_, headers.get(), direct_);
   stream_->set_spdy_headers(headers);
 
   stream_->SetRequestTime(request_time);
   // This should only get called in the case of a request occurring
   // during server push that has already begun but hasn't finished,
   // so we set the response's request time to be the actual one
   if (response_info_)
     response_info_->request_time = request_time;
 
   CHECK(!request_body_stream_.get());
@@ skipping 212 matching lines @@
   stream_->GetSSLInfo(ssl_info, &using_npn);
 }
 
 void SpdyHttpStream::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(stream_);
   stream_->GetSSLCertRequestInfo(cert_request_info);
 }
 
 }  // namespace net