Don't preresolve DNS if a fixed proxy configuration is in place.

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 961 matching lines @@
                           NULL);
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                int load_flags,
                                ProxyInfo* result,
                                const net::CompletionCallback& callback,
                                PacRequest** pac_request,
                                NetworkDelegate* network_delegate,
                                const BoundNetLog& net_log) {
+  DCHECK(!callback.is_null());
+  return ResolveProxyHelper(raw_url,
+                            load_flags,
+                            result,
+                            callback,
+                            pac_request,
+                            network_delegate,
+                            net_log);
+}
+
+int ProxyService::ResolveProxyHelper(const GURL& raw_url,
+                                     int load_flags,
+                                     ProxyInfo* result,
+                                     const net::CompletionCallback& callback,
+                                     PacRequest** pac_request,
+                                     NetworkDelegate* network_delegate,
+                                     const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
-  DCHECK(!callback.is_null());
 
   net_log.BeginEvent(NetLog::TYPE_PROXY_SERVICE);
 
   // Notify our polling-based dependencies that a resolve is taking place.
   // This way they can schedule their polls in response to network activity.
   config_service_->OnLazyPoll();
   if (script_poller_.get())
      script_poller_->OnLazyPoll();
 
   if (current_state_ == STATE_NONE)
     ApplyProxyConfigIfAvailable();
 
   // Strip away any reference fragments and the username/password, as they
   // are not relevant to proxy resolution.
   GURL url = SimplifyUrlForRequest(raw_url);
 
   // Check if the request can be completed right away. (This is the case when
   // using a direct connection for example).
   int rv = TryToCompleteSynchronously(url, load_flags,
                                       network_delegate, result);
   if (rv != ERR_IO_PENDING)
     return DidFinishResolvingProxy(url, load_flags, network_delegate,
                                    result, rv, net_log);
 
+  if (callback.is_null())
+    return ERR_IO_PENDING;
+
   scoped_refptr<PacRequest> req(
       new PacRequest(this, url, load_flags, network_delegate,
                      result, callback, net_log));
 
   if (current_state_ == STATE_READY) {
     // Start the resolve request.
     rv = req->Start();
     if (rv != ERR_IO_PENDING)
       return req->QueryDidComplete(rv);
   } else {
     req->net_log()->BeginEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
   }
 
   DCHECK_EQ(ERR_IO_PENDING, rv);
   DCHECK(!ContainsPendingRequest(req.get()));
   pending_requests_.push_back(req);
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |pac_request|.
   if (pac_request)
     *pac_request = req.get();
   return rv;  // ERR_IO_PENDING
 }
 
+bool ProxyService:: TryResolveProxySynchronously(
+    const GURL& raw_url,
+    int load_flags,
+    ProxyInfo* result,
+    NetworkDelegate* network_delegate,
+    const BoundNetLog& net_log) {
+  net::CompletionCallback null_callback;
+  return ResolveProxyHelper(raw_url,
+                            load_flags,
+                            result,
+                            null_callback,
+                            NULL /* pac_request*/,
+                            network_delegate,
+                            net_log) == OK;
+}
+
 int ProxyService::TryToCompleteSynchronously(const GURL& url,
                                              int load_flags,
                                              NetworkDelegate* network_delegate,
                                              ProxyInfo* result) {
   DCHECK_NE(STATE_NONE, current_state_);
 
   if (current_state_ != STATE_READY)
     return ERR_IO_PENDING;  // Still initializing.
 
   DCHECK_NE(config_.id(), ProxyConfig::kInvalidConfigID);
@@ skipping 512 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net