Use a utility process for the Mojo v8 proxy resolver.

net/proxy/proxy_service.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_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 809 matching lines @@
     results_->config_source_ = config_source_;
     results_->did_use_pac_script_ = true;
     results_->proxy_resolve_start_time_ = proxy_resolve_start_time_;
     results_->proxy_resolve_end_time_ = TimeTicks::Now();
 
     // Reset the state associated with in-progress-resolve.
     resolve_job_ = NULL;
     config_id_ = ProxyConfig::kInvalidConfigID;
     config_source_ = PROXY_CONFIG_SOURCE_UNKNOWN;
 
+    // If the PAC script failed fatally, it needs to be reloaded. Currently,
+    // this only applies to out-of-process proxy resolution and only happens
+    // when the process crashes.
+    if (result_code == ERR_PAC_SCRIPT_TERMINATED) {
+      VLOG(1) << "Detected PAC script terminated. Resetting proxy config.";
+      // Reset the proxy config.
+      // REVIEWERS: Should the fetched proxy config be reset?
+      service_->ResetProxyConfig(false);
+
+      // If there are any pending requests, excluding this one, re-start the
+      // config fetch/apply process.
+      size_t pending_requests = service_->NumPendingRequests();
+      if (pending_requests > 1 ||
+          (pending_requests && !service_->ContainsPendingRequest(this))) {
+        service_->ApplyProxyConfigIfAvailable();
+      }
+    }
+
     return rv;
   }
 
   BoundNetLog* net_log() { return &net_log_; }
 
   LoadState GetLoadState() const {
     if (is_started())
       return resolver()->GetLoadState(resolve_job_);
     return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
   }
@@ skipping 479 matching lines @@
   return pending_requests_.end() != it;
 }
 
 void ProxyService::RemovePendingRequest(PacRequest* req) {
   DCHECK(ContainsPendingRequest(req));
   PendingRequests::iterator it = std::find(
       pending_requests_.begin(), pending_requests_.end(), req);
   pending_requests_.erase(it);
 }
 
+size_t ProxyService::NumPendingRequests() const {
+  return pending_requests_.size();
+}
+
 int ProxyService::DidFinishResolvingProxy(const GURL& url,
                                           int load_flags,
                                           NetworkDelegate* network_delegate,
                                           ProxyInfo* result,
                                           int result_code,
                                           const BoundNetLog& net_log) {
   // Log the result of the proxy resolution.
   if (result_code == OK) {
     // Allow the network delegate to interpose on the resolution decision,
     // possibly modifying the ProxyInfo.
@@ skipping 262 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net