Created new URLRequestContext for secure proxy check

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 700 matching lines @@
 }
 
 bool HttpStreamFactoryImpl::Job::ShouldForceSpdyWithoutSSL() const {
   bool rv = session_->params().force_spdy_always &&
       !session_->params().force_spdy_over_ssl;
   return rv && !session_->HasSpdyExclusion(origin_);
 }
 
 bool HttpStreamFactoryImpl::Job::ShouldForceQuic() const {
   return session_->params().enable_quic &&
-    session_->params().origin_to_force_quic_on.Equals(origin_) &&
-    proxy_info_.is_direct();
+         session_->params().origin_to_force_quic_on.Equals(origin_) &&
+         proxy_info_.is_direct() &&
+         (request_info_.load_flags & LOAD_UNENCRYPTED_HTTP11) == 0;

[Ryan Hamilton, 2015/03/06 23:19:52]

This method is also only called from a command line argument. I'm not sure how
important it is for the load flag to work in this case.

 }
 
 int HttpStreamFactoryImpl::Job::DoWaitForJob() {
   DCHECK(blocking_job_);
   next_state_ = STATE_WAIT_FOR_JOB_COMPLETE;
   return ERR_IO_PENDING;
 }
 
 int HttpStreamFactoryImpl::Job::DoWaitForJobComplete(int result) {
   DCHECK(!blocking_job_);
   DCHECK_EQ(OK, result);
   next_state_ = STATE_INIT_CONNECTION;
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnection() {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/462812 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "462812 HttpStreamFactoryImpl::Job::DoInitConnection"));
   DCHECK(!blocking_job_);
   DCHECK(!connection_->is_initialized());
   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();
+  DCHECK(!using_ssl_ ||
+         (request_info_.load_flags & LOAD_UNENCRYPTED_HTTP11) == 0);
+
   using_spdy_ = false;
 
   if (ShouldForceQuic())
     using_quic_ = true;
 
   DCHECK(!using_quic_ || session_->params().enable_quic);
+  DCHECK(!using_quic_ ||
+         (request_info_.load_flags & LOAD_UNENCRYPTED_HTTP11) == 0);
 
   if (proxy_info_.is_quic()) {
     using_quic_ = true;
     DCHECK(session_->params().enable_quic_for_proxies);
   }
 
   if (using_quic_) {
     if (proxy_info_.is_quic() && !request_info_.url.SchemeIs("http")) {
       NOTREACHED();
       // TODO(rch): support QUIC proxies for HTTPS urls.
@@ skipping 32 matching lines @@
       return OK;
     using_spdy_ = true;
     next_state_ = STATE_CREATE_STREAM;
     existing_spdy_session_ = spdy_session;
     return OK;
   } else if (request_ && !request_->HasSpdySessionKey() &&
              (using_ssl_ || ShouldForceSpdyWithoutSSL())) {
     // Update the spdy session key for the request that launched this job.
     request_->SetSpdySessionKey(spdy_session_key);
   }
+  DCHECK(!using_spdy_ ||
+         (request_info_.load_flags & LOAD_UNENCRYPTED_HTTP11) == 0);
 
   // OK, there's no available SPDY session. Let |waiting_job_| resume if it's
   // paused.
 
   if (waiting_job_) {
     waiting_job_->Resume(this);
     waiting_job_ = NULL;
   }
 
   if (proxy_info_.is_http() || proxy_info_.is_https())
@@ skipping 684 matching lines @@
 
   if (job_status_ == STATUS_SUCCEEDED && other_job_status_ == STATUS_BROKEN) {
     HistogramBrokenAlternateProtocolLocation(
         BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_MAIN);
     session_->http_server_properties()->SetBrokenAlternateProtocol(
         HostPortPair::FromURL(request_info_.url));
   }
 }
 
 }  // namespace net