Respect QuicAllowed policy for new streams

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 213 matching lines @@
           !alternative_proxy_server_.is_valid()) ||
          (job_type_ == ALTERNATIVE || job_type_ == PRECONNECT));
   // If the alternative proxy server is valid, then the job type must be
   // set to ALTERNATIVE.
   DCHECK(!alternative_proxy_server_.is_valid() || job_type_ == ALTERNATIVE);
 
   if (IsSpdyAlternative()) {
     DCHECK(origin_url_.SchemeIs(url::kHttpsScheme));
   }
   if (IsQuicAlternative()) {
-    DCHECK(session_->params().enable_quic);
+    DCHECK(session_->IsQuicEnabled());
     using_quic_ = true;
   }
 }
 
 HttpStreamFactoryImpl::Job::~Job() {
   net_log_.EndEvent(NetLogEventType::HTTP_STREAM_JOB);
 
   // When we're in a partially constructed state, waiting for the user to
   // provide certificate handling information or authentication, we can't reuse
   // this stream at all.
@@ skipping 485 matching lines @@
 int HttpStreamFactoryImpl::Job::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   if (result == OK) {
     // Remove unsupported proxies from the list.
     int supported_proxies =
         ProxyServer::SCHEME_DIRECT | ProxyServer::SCHEME_HTTP |
         ProxyServer::SCHEME_HTTPS | ProxyServer::SCHEME_SOCKS4 |
         ProxyServer::SCHEME_SOCKS5;
 
-    if (session_->params().enable_quic)
+    if (session_->IsQuicEnabled())
       supported_proxies |= ProxyServer::SCHEME_QUIC;
 
     proxy_info_.RemoveProxiesWithoutScheme(supported_proxies);
 
     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;
     } else if (using_quic_ &&
                (!proxy_info_.is_quic() && !proxy_info_.is_direct())) {
@@ skipping 10 matching lines @@
   next_state_ = STATE_WAIT;
 
   delegate_->OnResolveProxyComplete(this, request_info_, priority_,
                                     server_ssl_config_, proxy_ssl_config_,
                                     stream_type_);
 
   return OK;
 }
 
 bool HttpStreamFactoryImpl::Job::ShouldForceQuic() const {
-  return session_->params().enable_quic &&
+  return session_->IsQuicEnabled() &&
          (base::ContainsKey(session_->params().origins_to_force_quic_on,
                             HostPortPair()) ||
           base::ContainsKey(session_->params().origins_to_force_quic_on,
                             destination_)) &&
          proxy_info_.is_direct() && origin_url_.SchemeIs(url::kHttpsScheme);
 }
 
 int HttpStreamFactoryImpl::Job::DoWait() {
   next_state_ = STATE_WAIT_COMPLETE;
   if (delegate_->ShouldWait(this))
@@ skipping 30 matching lines @@
     return OK;
   }
 
   using_ssl_ = origin_url_.SchemeIs(url::kHttpsScheme) ||
                origin_url_.SchemeIs(url::kWssScheme);
   using_spdy_ = false;
 
   if (ShouldForceQuic())
     using_quic_ = true;
 
-  DCHECK(!using_quic_ || session_->params().enable_quic);
+  DCHECK(!using_quic_ || session_->IsQuicEnabled());
 
   if (proxy_info_.is_quic()) {
     using_quic_ = true;
-    DCHECK(session_->params().enable_quic);
+    DCHECK(session_->IsQuicEnabled());
   }
 
   if (proxy_info_.is_https() || proxy_info_.is_quic()) {
     InitSSLConfig(&proxy_ssl_config_, /*is_proxy=*/true);
     // Disable revocation checking for HTTPS proxies since the revocation
     // requests are probably going to need to go through the proxy too.
     proxy_ssl_config_.rev_checking_enabled = false;
   }
   if (using_ssl_) {
     InitSSLConfig(&server_ssl_config_, /*is_proxy=*/false);
@@ skipping 668 matching lines @@
 
   ConnectionAttempts socket_attempts = connection_->connection_attempts();
   if (connection_->socket()) {
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
   }
 
   delegate_->AddConnectionAttemptsToRequest(this, socket_attempts);
 }
 
 }  // namespace net