Better match IE's proxy settings....

net/proxy/proxy_service.cc

 // Copyright (c) 2006-2008 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/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
+#include "net/proxy/init_proxy_resolver.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_script_fetcher.h"
 #if defined(OS_WIN)
 #include "net/proxy/proxy_config_service_win.h"
 #include "net/proxy/proxy_resolver_winhttp.h"
 #elif defined(OS_MACOSX)
 #include "net/proxy/proxy_resolver_mac.h"
 #elif defined(OS_LINUX)
 #include "net/proxy/proxy_config_service_linux.h"
 #endif
@@ skipping 28 matching lines @@
                              CompletionCallback* callback,
                              RequestHandle* request) {
     return ERR_NOT_IMPLEMENTED;
   }
 
   virtual void CancelRequest(RequestHandle request) {
     NOTREACHED();
   }
 
  private:
-  virtual void SetPacScriptByUrlInternal(const GURL& pac_url) {}
+  virtual int SetPacScript(const GURL& /*pac_url*/,
+                           const std::string& /*pac_bytes*/,
+                           CompletionCallback* /*callback*/) {
+    return ERR_NOT_IMPLEMENTED;
+  }
 };
 
 // ProxyService::PacRequest ---------------------------------------------------
 
 class ProxyService::PacRequest
     : public base::RefCounted<ProxyService::PacRequest> {
  public:
   PacRequest(ProxyService* service,
              const GURL& url,
              ProxyInfo* results,
@@ skipping 18 matching lines @@
 
     return resolver()->GetProxyForURL(
         url_, results_, &io_callback_, &resolve_job_);
   }
 
   bool is_started() const {
     // Note that !! casts to bool. (VS gives a warning otherwise).
     return !!resolve_job_;
   }
 
-  void StartAndComplete() {
-    int rv = Start();
+  void StartAndCompleteCheckingForSynchronous() {
+    int rv = service_->TryToCompleteSynchronously(url_, results_);
+    if (rv == ERR_IO_PENDING)
+      rv = Start();
     if (rv != ERR_IO_PENDING)
       QueryComplete(rv);
   }
 
-  void Cancel() {
+  void CancelResolveJob() {
     // The request may already be running in the resolver.
     if (is_started()) {
       resolver()->CancelRequest(resolve_job_);
       resolve_job_ = NULL;
     }
+    DCHECK(!is_started());
+  }
+
+  void Cancel() {
+    CancelResolveJob();
 
     // Mark as cancelled, to prevent accessing this again later.
     service_ = NULL;
     user_callback_ = NULL;
     results_ = NULL;
   }
 
   // Returns true if Cancel() has been called.
   bool was_cancelled() const { return user_callback_ == NULL; }
 
@@ skipping 45 matching lines @@
 };
 
 // ProxyService ---------------------------------------------------------------
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
                            ProxyResolver* resolver)
     : config_service_(config_service),
       resolver_(resolver),
       next_config_id_(1),
       config_is_bad_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(proxy_script_fetcher_callback_(
-          this, &ProxyService::OnScriptFetchCompletion)),
-      fetched_pac_config_id_(ProxyConfig::INVALID_ID),
-      fetched_pac_error_(OK),
-      in_progress_fetch_config_id_(ProxyConfig::INVALID_ID) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(init_proxy_resolver_callback_(
+          this, &ProxyService::OnInitProxyResolverComplete)) {
 }
 
 // static
 ProxyService* ProxyService::Create(
     const ProxyConfig* pc,
     bool use_v8_resolver,
     URLRequestContext* url_request_context,
     MessageLoop* io_loop) {
   // Choose the system configuration service appropriate for each platform.
   ProxyConfigService* proxy_config_service = pc ?
@@ skipping 52 matching lines @@
 
   // Check if the request can be completed right away. This is the case when
   // using a direct connection, or when the config is bad.
   UpdateConfigIfOld();
   int rv = TryToCompleteSynchronously(url, result);
   if (rv != ERR_IO_PENDING)
     return rv;
 
   scoped_refptr<PacRequest> req = new PacRequest(this, url, result, callback);
 
-  bool resolver_is_ready = PrepareResolverForRequests();
+  bool resolver_is_ready = !IsInitializingProxyResolver();
 
   if (resolver_is_ready) {
     // Start the resolve request.
     rv = req->Start();
     if (rv != ERR_IO_PENDING)
       return req->QueryDidComplete(rv);
   }
 
   DCHECK_EQ(ERR_IO_PENDING, rv);
   DCHECK(!ContainsPendingRequest(req));
@@ skipping 15 matching lines @@
   // Fallback to a "direct" (no proxy) connection if the current configuration
   // is known to be bad.
   if (config_is_bad_) {
     // Reset this flag to false in case the ProxyInfo object is being
     // re-used by the caller.
     result->config_was_tried_ = false;
   } else {
     // Remember that we are trying to use the current proxy configuration.
     result->config_was_tried_ = true;
 
+    if (config_.MayRequirePACResolver()) {
+      // Need to go through ProxyResolver for this.
+      return ERR_IO_PENDING;
+    }
+
     if (!config_.proxy_rules.empty()) {
       ApplyProxyRules(url, config_.proxy_rules, result);
       return OK;
     }
-
-    if (config_.pac_url.is_valid() || config_.auto_detect) {
-      // If we failed to download the PAC script, return the network error
-      // from the failed download. This is only going to happen for the first
-      // request after the failed download -- after that |config_is_bad_| will
-      // be set to true, so we short-cuircuit sooner.
-      if (fetched_pac_error_ != OK && !IsFetchingPacScript()) {
-        DidCompletePacRequest(fetched_pac_config_id_, fetched_pac_error_);
-        return fetched_pac_error_;
-      }
-      return ERR_IO_PENDING;
-    }
   }
 
   // otherwise, we have no proxy config
   result->UseDirect();
   return OK;
 }
 
 void ProxyService::ApplyProxyRules(const GURL& url,
                                    const ProxyConfig::ProxyRules& proxy_rules,
                                    ProxyInfo* result) {
@@ skipping 28 matching lines @@
 
 ProxyService::~ProxyService() {
   // Cancel any inprogress requests.
   for (PendingRequests::iterator it = pending_requests_.begin();
        it != pending_requests_.end();
        ++it) {
     (*it)->Cancel();
   }
 }
 
+void ProxyService::SuspendAllPendingRequests() {
+  for (PendingRequests::iterator it = pending_requests_.begin();
+       it != pending_requests_.end();
+       ++it) {
+    it->get()->CancelResolveJob();
+  }
+}
+
 void ProxyService::ResumeAllPendingRequests() {
+  DCHECK(!IsInitializingProxyResolver());
+
   // Make a copy in case |this| is deleted during the synchronous completion
   // of one of the requests. If |this| is deleted then all of the PacRequest
   // instances will be Cancel()-ed.
   PendingRequests pending_copy = pending_requests_;
 
   for (PendingRequests::iterator it = pending_copy.begin();
        it != pending_copy.end();
        ++it) {
     PacRequest* req = it->get();
-    if (!req->is_started() && !req->was_cancelled())
-      req->StartAndComplete();
+    if (!req->is_started() && !req->was_cancelled()) {
+      // Note that we re-check for synchronous completion, in case we are
+      // no longer using a ProxyResolver (can happen if we fell-back to manual).
+      req->StartAndCompleteCheckingForSynchronous();
+    }
   }
 }
 
-bool ProxyService::PrepareResolverForRequests() {
-  // While the PAC script is being downloaded, block requests.
-  if (IsFetchingPacScript())
-    return false;
+void ProxyService::OnInitProxyResolverComplete(int result) {
+  DCHECK(init_proxy_resolver_.get());
+  DCHECK(config_.MayRequirePACResolver());
+  init_proxy_resolver_.reset();
 
-  // Check if a new PAC script needs to be downloaded.
-  DCHECK(config_.id() != ProxyConfig::INVALID_ID);
-  if (resolver_->expects_pac_bytes() &&
-      config_.id() != fetched_pac_config_id_) {
-    // For auto-detect we use the well known WPAD url.
-    GURL pac_url = config_.auto_detect ?
-        GURL("http://wpad/wpad.dat") : config_.pac_url;
-
-    in_progress_fetch_config_id_ = config_.id();
-
-    LOG(INFO) << "Starting fetch of PAC script " << pac_url
-              << " for config_id=" << in_progress_fetch_config_id_;
-
-    proxy_script_fetcher_->Fetch(
-        pac_url, &in_progress_fetch_bytes_, &proxy_script_fetcher_callback_);
-    return false;
+  if (result != OK) {
+    LOG(INFO) << "Failed configuring with PAC script, falling-back to manual "
+                 "proxy servers.";
+    config_.auto_detect = false;
+    config_.pac_url = GURL();
+    DCHECK(!config_.MayRequirePACResolver());
   }
 
-  // We are good to go.
-  return true;
-}
-
-void ProxyService::OnScriptFetchCompletion(int result) {
-  DCHECK(IsFetchingPacScript());
-  DCHECK(resolver_->expects_pac_bytes());
-
-  LOG(INFO) << "Completed PAC script fetch for config_id="
-            << in_progress_fetch_config_id_
-            << " with error " << ErrorToString(result)
-            << ". Fetched a total of " << in_progress_fetch_bytes_.size()
-            << " bytes";
-
-  // Notify the ProxyResolver of the new script data (will be empty string if
-  // result != OK).
-  resolver_->SetPacScriptByData(in_progress_fetch_bytes_);
-
-  fetched_pac_config_id_ = in_progress_fetch_config_id_;
-  fetched_pac_error_ = result;
-  in_progress_fetch_config_id_ = ProxyConfig::INVALID_ID;
-  in_progress_fetch_bytes_.clear();
-
   // Resume any requests which we had to defer until the PAC script was
   // downloaded.
   ResumeAllPendingRequests();
 }
 
 int ProxyService::ReconsiderProxyAfterError(const GURL& url,
                                             ProxyInfo* result,
                                             CompletionCallback* callback,
                                             PacRequest** pac_request) {
   // Check to see if we have a new config since ResolveProxy was called.  We
@@ skipping 20 matching lines @@
     proxy_retry_info_.clear();
     return ResolveProxy(url, result, callback, pac_request);
   }
 
   // We don't have new proxy settings to try, fallback to the next proxy
   // in the list.
   bool was_direct = result->is_direct();
   if (!was_direct && result->Fallback(&proxy_retry_info_))
     return OK;
 
+  // TODO(eroman): Hmm, this doesn't seem right. For starters just because
+  // auto_detect is true doesn't mean we are actually using it.
   if (!config_.auto_detect && !config_.proxy_rules.empty()) {
     // If auto detect is on, then we should try a DIRECT connection
     // as the attempt to reach the proxy failed.
     return ERR_FAILED;
   }
 
   // If we already tried a direct connection, then just give up.
   if (was_direct)
     return ERR_FAILED;
 
@@ skipping 112 matching lines @@
 
   // Increment the ID to reflect that the config has changed.
   config_.set_id(next_config_id_++);
 
   LOG(INFO) << "New proxy configuration was loaded:\n" << config_;
 
   // Reset state associated with latest config.
   config_is_bad_ = false;
   proxy_retry_info_.clear();
 
-  // Tell the resolver to use the new PAC URL (for resolvers that fetch the
-  // PAC script internally).
-  // TODO(eroman): this isn't quite right. See http://crbug.com/9985
-  if ((config_.pac_url.is_valid() || config_.auto_detect) &&
-      !resolver_->expects_pac_bytes()) {
-    const GURL pac_url = config_.auto_detect ? GURL() : config_.pac_url;
-    resolver_->SetPacScriptByUrl(pac_url);
+  // Cancel any PAC fetching / ProxyResolver::SetPacScript() which was
+  // in progress for the previous configuration.
+  init_proxy_resolver_.reset();
+
+  // Start downloading + testing the PAC scripts for this new configuration.
+  if (config_.MayRequirePACResolver()) {
+    // Since InitProxyResolver will be playing around with the proxy resolver
+    // as it tests the parsing of various PAC scripts, make sure there is
+    // nothing in-flight in |resolver_|. These paused requests are resumed by
+    // OnInitProxyResolverComplete().
+    SuspendAllPendingRequests();
+
+    init_proxy_resolver_.reset(
+        new InitProxyResolver(resolver_.get(), proxy_script_fetcher_.get()));
+    int rv = init_proxy_resolver_->Init(
+        config_, &init_proxy_resolver_callback_);
+    if (rv != ERR_IO_PENDING)
+      OnInitProxyResolverComplete(rv);
   }
 }
 
 void ProxyService::UpdateConfigIfOld() {
   // The overhead of calling ProxyConfigService::GetProxyConfig is very low.
   const TimeDelta kProxyConfigMaxAge = TimeDelta::FromSeconds(5);
 
   // Periodically check for a new config.
   if (!config_has_been_initialized() ||
       (TimeTicks::Now() - config_last_update_time_) > kProxyConfigMaxAge)
@@ skipping 139 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net