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 825 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,

[eroman, 2015/03/11 18:48:36]

This change would best be proposed as a separate changelist (the rest of this
change l-g-t-m but I have more comments for this part)

I believe the right way to do this is to instead call:
  service_->InitializeUsingLastFetchedConfig();

This simulates as if the config just changed, and it will re-download any PAC
script, and then re-initialize the ProxyResolver.

Moreover, it will increment the "config id". This has the following effect:

Upon return, this request will fail with ERR_PAC_SCRIPT_TERMINATED. However
there is re-try logic which will re-try the request if there is a new config
available (which there will be in this case because the ID) got incremented.

This should then mask the failure from appearing as a network error to the user
and simply re-start things.

[Anand Mistry (off Chromium), 2015/03/12 05:10:22]

I've removed this from this CL. So out-of-process will work until the utility
process dies.

+    // 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 475 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();

[eroman, 2015/03/11 18:48:36]

Not needed per discussion above.

[Anand Mistry (off Chromium), 2015/03/12 05:10:22]

Done.

+}
+
 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 250 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net