Allow ProxyService to share URLRequestContext with everything else.

net/proxy/proxy_script_fetcher_impl.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/proxy/proxy_script_fetcher_impl.h"
 
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 105 matching lines @@
   FetchCompleted();
 }
 
 int ProxyScriptFetcherImpl::Fetch(
     const GURL& url, base::string16* text, const CompletionCallback& callback) {
   // It is invalid to call Fetch() while a request is already in progress.
   DCHECK(!cur_request_.get());
   DCHECK(!callback.is_null());
   DCHECK(text);
 
+  if (!url_request_context_)
+    return ERR_CONTEXT_SHUT_DOWN;
+
   // Handle base-64 encoded data-urls that contain custom PAC scripts.
   if (url.SchemeIs("data")) {
     std::string mime_type;
     std::string charset;
     std::string data;
     if (!DataURL::Parse(url, &mime_type, &charset, &data))
       return ERR_FAILED;
 
     ConvertResponseToUTF16(charset, data, text);
     return OK;
   }
 
   DCHECK(fetch_start_time_.is_null());
   fetch_start_time_ = base::TimeTicks::Now();
 
+  // Use highest priority, so if socket pools are being used for other types of
+  // requests, PAC requests are aren't blocked on them.
   cur_request_ =
-      url_request_context_->CreateRequest(url, DEFAULT_PRIORITY, this);
+      url_request_context_->CreateRequest(url, MAXIMUM_PRIORITY, this);
   cur_request_->set_method("GET");
 
   // Make sure that the PAC script is downloaded using a direct connection,
   // to avoid circular dependencies (fetching is a part of proxy resolution).
   // Also disable the use of the disk cache. The cache is disabled so that if
   // the user switches networks we don't potentially use the cached response
   // from old network when we should in fact be re-fetching on the new network.
   // If the PAC script is hosted on an HTTPS server we bypass revocation
   // checking in order to avoid a circular dependency when attempting to fetch
   // the OCSP response or CRL. We could make the revocation check go direct but
-  // the proxy might be the only way to the outside world.
+  // the proxy might be the only way to the outside world.  IGNORE_LIMITS is
+  // used to avoid blocking proxy resolution on other network requests.
   cur_request_->SetLoadFlags(LOAD_BYPASS_PROXY | LOAD_DISABLE_CACHE |
-                             LOAD_DISABLE_CERT_REVOCATION_CHECKING);
+                             LOAD_DISABLE_CERT_REVOCATION_CHECKING |
+                             LOAD_IGNORE_LIMITS);
 
   // Save the caller's info for notification on completion.
   callback_ = callback;
   result_text_ = text;
 
   bytes_read_so_far_.clear();
 
   // Post a task to timeout this request if it takes too long.
   cur_request_id_ = ++next_id_;
 
@@ skipping 10 matching lines @@
 void ProxyScriptFetcherImpl::Cancel() {
   // ResetCurRequestState will free the URLRequest, which will cause
   // cancellation.
   ResetCurRequestState();
 }
 
 URLRequestContext* ProxyScriptFetcherImpl::GetRequestContext() const {
   return url_request_context_;
 }
 
+void ProxyScriptFetcherImpl::OnShutdown() {
+  url_request_context_ = nullptr;
+  result_code_ = ERR_CONTEXT_SHUT_DOWN;
+  FetchCompleted();
+}
+
 void ProxyScriptFetcherImpl::OnAuthRequired(URLRequest* request,
                                             AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request, cur_request_.get());
   // TODO(eroman): http://crbug.com/77366
   LOG(WARNING) << "Auth required to fetch PAC script, aborting.";
   result_code_ = ERR_NOT_IMPLEMENTED;
   request->CancelAuth();
 }
 
 void ProxyScriptFetcherImpl::OnSSLCertificateError(URLRequest* request,
@@ skipping 138 matching lines @@
 }
 
 void ProxyScriptFetcherImpl::OnTimeout(int id) {
   // Timeout tasks may outlive the URLRequest they reference. Make sure it
   // is still applicable.
   if (cur_request_id_ != id)
     return;
 
   DCHECK(cur_request_.get());
   result_code_ = ERR_TIMED_OUT;
-  cur_request_->Cancel();
+  FetchCompleted();
 }
 
 }  // namespace net