Enable QUIC proxies to be used for HTTP URLs.

net/http/http_stream_factory_impl_job.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/http/http_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 657 matching lines @@
   return session_->proxy_service()->ResolveProxy(
       request_info_.url, &proxy_info_, io_callback_, &pac_request_, net_log_);
 }
 
 int HttpStreamFactoryImpl::Job::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   if (result == OK) {
     // Remove unsupported proxies from the list.
     proxy_info_.RemoveProxiesWithoutScheme(
-        ProxyServer::SCHEME_DIRECT |
+        ProxyServer::SCHEME_DIRECT | ProxyServer::SCHEME_QUIC |
         ProxyServer::SCHEME_HTTP | ProxyServer::SCHEME_HTTPS |
         ProxyServer::SCHEME_SOCKS4 | ProxyServer::SCHEME_SOCKS5);
 
     if (proxy_info_.is_empty()) {
       // No proxies/direct to choose from. This happens when we don't support
       // any of the proxies in the returned list.
       result = ERR_NO_SUPPORTED_PROXIES;
     }
   }
 
@@ skipping 47 matching lines @@
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   using_ssl_ = request_info_.url.SchemeIs("https") ||
       request_info_.url.SchemeIs("wss") || ShouldForceSpdySSL();
   using_spdy_ = false;
 
   if (ShouldForceQuic())
     using_quic_ = true;
 
+  if (proxy_info_.is_quic())
+    using_quic_ = true;
+
   if (using_quic_) {
     DCHECK(session_->params().enable_quic);
-    if (!proxy_info_.is_direct()) {
+    if (proxy_info_.is_quic() && !request_info_.url.SchemeIs("http")) {
       NOTREACHED();
-      // TODO(rch): support QUIC proxies.
+      // TODO(rch): support QUIC proxies for HTTPS urls.
       return ERR_NOT_IMPLEMENTED;
     }
+    HostPortProxyPair destination;
+    destination.first = proxy_info_.is_quic() ?
+        proxy_info_.proxy_server().host_port_pair() : origin_;
+    destination.second = ProxyServer::Direct();
     next_state_ = STATE_INIT_CONNECTION_COMPLETE;
-    const ProxyServer& proxy_server = proxy_info_.proxy_server();
-    int rv = quic_request_.Request(HostPortProxyPair(origin_, proxy_server),
-                                   using_ssl_, session_->cert_verifier(),
-                                   net_log_, io_callback_);
+    bool secure_quic = using_ssl_ || proxy_info_.is_quic();
+    int rv = quic_request_.Request(
+        destination, secure_quic, session_->cert_verifier(), net_log_,
+        io_callback_);
     if (rv != OK) {
       // OK, there's no available QUIC session. Let |waiting_job_| resume
       // if it's paused.
       if (waiting_job_) {
         waiting_job_->Resume(this);
         waiting_job_ = NULL;
       }
     }
     return rv;
   }
@@ skipping 701 matching lines @@
       (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
        net::LOAD_IS_DOWNLOAD)) {
     // Avoid pipelining resources that may be streamed for a long time.
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
       *http_pipelining_key_.get());
 }
 
 }  // namespace net