Get rid of synchronous ResolveProxy API.

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"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <winhttp.h>
 #endif
 
 #include <algorithm>
 
+#include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #if defined(OS_WIN)
 #include "net/proxy/proxy_config_service_win.h"
 #include "net/proxy/proxy_resolver_winhttp.h"
@@ skipping 134 matching lines @@
 }
 
 void ProxyInfo::UseDirect() {
   proxy_list_.Set(std::string());
 }
 
 void ProxyInfo::UseNamedProxy(const std::string& proxy_server) {
   proxy_list_.Set(proxy_server);
 }
 
-#if defined(OS_WIN)
-void ProxyInfo::Apply(HINTERNET request_handle) {
-  WINHTTP_PROXY_INFO pi;
-  std::wstring proxy;  // We need to declare this variable here because
-                       // lpszProxy needs to be valid in WinHttpSetOption.
-  if (is_direct()) {
-    pi.dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
-    pi.lpszProxy = WINHTTP_NO_PROXY_NAME;
-    pi.lpszProxyBypass = WINHTTP_NO_PROXY_BYPASS;
-  } else {
-    proxy = ASCIIToWide(proxy_list_.Get());
-    pi.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
-    pi.lpszProxy = const_cast<LPWSTR>(proxy.c_str());
-    // NOTE: Specifying a bypass list here would serve no purpose.
-    pi.lpszProxyBypass = WINHTTP_NO_PROXY_BYPASS;
-  }
-  WinHttpSetOption(request_handle, WINHTTP_OPTION_PROXY, &pi, sizeof(pi));
-}
-#endif
-
 std::string ProxyInfo::GetAnnotatedProxyList() {
   return is_direct() ? "DIRECT" : proxy_list_.GetAnnotatedList();
 }
 
 // ProxyService::PacRequest ---------------------------------------------------
 
 // We rely on the fact that the origin thread (and its message loop) will not
 // be destroyed until after the PAC thread is destroyed.
 
 class ProxyService::PacRequest :
     public base::RefCountedThreadSafe<ProxyService::PacRequest> {
  public:
   PacRequest(ProxyService* service,
              const GURL& pac_url,
              CompletionCallback* callback)
       : service_(service),
         callback_(callback),
         results_(NULL),
         config_id_(service->config_id()),
         pac_url_(pac_url),
-        origin_loop_(NULL) {
-    // We need to remember original loop if only in case of asynchronous call
-    if (callback_)
-      origin_loop_ = MessageLoop::current();
+        origin_loop_(MessageLoop::current()) {
+    DCHECK(callback);
   }
 
   void Query(const GURL& url, ProxyInfo* results) {
     results_ = results;
-    // If we have a valid callback then execute Query asynchronously
-    if (callback_) {
-      AddRef();  // balanced in QueryComplete
-      service_->pac_thread()->message_loop()->PostTask(FROM_HERE,
-          NewRunnableMethod(this, &ProxyService::PacRequest::DoQuery,
-                            service_->resolver(), url, pac_url_));
-    } else {
-      DoQuery(service_->resolver(), url, pac_url_);
-    }
+    // Execute Query asynchronously
+    AddRef();  // balanced in QueryComplete
+    service_->pac_thread()->message_loop()->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &ProxyService::PacRequest::DoQuery,
+                          service_->resolver(), url, pac_url_));
   }
 
   void Cancel() {
     // Clear these to inform QueryComplete that it should not try to
     // access them.
     service_ = NULL;
     callback_ = NULL;
     results_ = NULL;
   }
 
  private:
-  // Runs on the PAC thread if a valid callback is provided.
+  // Runs on the PAC thread.
   void DoQuery(ProxyResolver* resolver,
                const GURL& query_url,
                const GURL& pac_url) {
     int rv = resolver->GetProxyForURL(query_url, pac_url, &results_buf_);
-    if (origin_loop_) {
-      origin_loop_->PostTask(FROM_HERE,
-          NewRunnableMethod(this, &PacRequest::QueryComplete, rv));
-    } else {
-      QueryComplete(rv);
-    }
+    origin_loop_->PostTask(FROM_HERE,
+        NewRunnableMethod(this, &PacRequest::QueryComplete, rv));
   }
 
-  // If a valid callback is provided, this runs on the origin thread to
-  // indicate that the completion callback should be run.
+  // Runs the completion callback on the origin thread.
   void QueryComplete(int result_code) {
-    if (service_)
+    // The PacRequest may have been cancelled after it was started. If it was
+    // cancelled then |callback_|, |service_|, and |results_| will be NULL.
+    bool was_cancelled = callback_ == NULL;
+
+    if (!was_cancelled) {
       service_->DidCompletePacRequest(config_id_, result_code);
 
-    if (result_code == OK && results_) {
-      results_->Use(results_buf_);
-      results_->RemoveBadProxies(service_->proxy_retry_info_);
+      if (result_code == OK) {
+        results_->Use(results_buf_);
+        results_->RemoveBadProxies(service_->proxy_retry_info_);
+      }
+      callback_->Run(result_code);
     }
 
-    if (callback_)
-      callback_->Run(result_code);
-
-    if (origin_loop_) {
-      Release();  // balances the AddRef in Query.  we may get deleted after
-                  // we return.
-    }
+    Release();  // balances the AddRef in Query.  we may get deleted after
+                // we return.
   }
 
   // Must only be used on the "origin" thread.
   ProxyService* service_;
   CompletionCallback* callback_;
   ProxyInfo* results_;
   ProxyConfig::ID config_id_;
 
   // Usable from within DoQuery on the PAC thread.
   ProxyInfo results_buf_;
@@ skipping 37 matching lines @@
 // static
 ProxyService* ProxyService::CreateNull() {
   // The ProxyResolver is set to NULL, since it should never be called
   // (because the configuration will never require PAC).
   return new ProxyService(new ProxyConfigServiceNull, NULL);
 }
 
 int ProxyService::ResolveProxy(const GURL& url, ProxyInfo* result,
                                CompletionCallback* callback,
                                PacRequest** pac_request) {
+  DCHECK(callback);
   // 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_updated_ ||
       (TimeTicks::Now() - config_last_update_time_) > kProxyConfigMaxAge)
     UpdateConfig();
   result->config_id_ = config_.id();
 
   // Fallback to a "direct" (no proxy) connection if the current configuration
@@ skipping 40 matching lines @@
           }
         }
         // We failed to find a matching proxy server for the current URL
         // scheme. Default to direct.
         result->UseDirect();
       }
       return OK;
     }
 
     if (config_.pac_url.is_valid() || config_.auto_detect) {
-      if (callback) {
-        // Create PAC thread for asynchronous mode.
-        if (!pac_thread_.get()) {
-          pac_thread_.reset(new base::Thread("pac-thread"));
-          pac_thread_->Start();
-        }
-      } else {
-        // If this request is synchronous, then there's no point
-        // in returning PacRequest instance
-        DCHECK(!pac_request);
+      if (!pac_thread_.get()) {
+        pac_thread_.reset(new base::Thread("pac-thread"));
+        pac_thread_->Start();
       }
-
+   
       scoped_refptr<PacRequest> req =
           new PacRequest(this, config_.pac_url, callback);
 
       // Strip away any reference fragments and the username/password, as they
       // are not relevant to proxy resolution.
       GURL sanitized_url;
       { // TODO(eroman): The following duplicates logic from
         // HttpUtil::SpecForRequest. Should probably live in net_util.h
         GURL::Replacements replacements;
         replacements.ClearUsername();
         replacements.ClearPassword();
         replacements.ClearRef();
         sanitized_url = url.ReplaceComponents(replacements);
       }
 
       req->Query(sanitized_url, result);
 
-      if (callback) {
-        if (pac_request)
-          *pac_request = req;
-        return ERR_IO_PENDING;  // Wait for callback.
-      }
-      return OK;
+      if (pac_request)
+        *pac_request = req;
+
+      return ERR_IO_PENDING;  // Wait for callback.
     }
   }
 
   // otherwise, we have no proxy config
   result->UseDirect();
   return OK;
 }
 
 int ProxyService::ReconsiderProxyAfterError(const GURL& url,
                                             ProxyInfo* result,
@@ skipping 118 matching lines @@
     // Some systems (the Mac, for example) allow CIDR-style specification of
     // proxy bypass for IP-specified hosts (e.g.  "10.0.0.0/8"; see
     // http://www.tcd.ie/iss/internet/osx_proxy.php for a real-world example).
     // That's kinda cool so we'll provide that for everyone.
     // TODO(avi): implement here
   }
 
   return false;
 }
 
+SyncProxyServiceHelper::SyncProxyServiceHelper(MessageLoop* io_message_loop,
+                                               ProxyService* proxy_service)
+    : io_message_loop_(io_message_loop),
+      proxy_service_(proxy_service),
+      event_(false, false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+          this, &SyncProxyServiceHelper::OnCompletion)) {
+  DCHECK(io_message_loop_ != MessageLoop::current());
+}
+
+int SyncProxyServiceHelper::ResolveProxy(const GURL& url,
+                                         ProxyInfo* proxy_info) {
+  DCHECK(io_message_loop_ != MessageLoop::current());
+
+  io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &SyncProxyServiceHelper::StartAsyncResolve, url));
+
+  event_.Wait();
+
+  if (result_ == net::OK) {
+    *proxy_info = proxy_info_;
+  }
+  return result_;
+}
+
+int SyncProxyServiceHelper::ReconsiderProxyAfterError(const GURL& url,
+                                                      ProxyInfo* proxy_info) {
+  DCHECK(io_message_loop_ != MessageLoop::current());
+
+  io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &SyncProxyServiceHelper::StartAsyncReconsider, url));
+
+  event_.Wait();
+
+  if (result_ == net::OK) {
+    *proxy_info = proxy_info_;
+  }
+  return result_;
+}
+
+void SyncProxyServiceHelper::StartAsyncResolve(const GURL& url) {
+  result_ = proxy_service_->ResolveProxy(url, &proxy_info_, &callback_, NULL);
+  if (result_ != net::ERR_IO_PENDING) {
+    OnCompletion(result_);
+  }
+}
+
+void SyncProxyServiceHelper::StartAsyncReconsider(const GURL& url) {
+  result_ = proxy_service_->ReconsiderProxyAfterError(
+      url, &proxy_info_, &callback_, NULL);
+  if (result_ != net::ERR_IO_PENDING) {
+    OnCompletion(result_);
+  }
+}
+
+void SyncProxyServiceHelper::OnCompletion(int rv) {
+  result_ = rv;
+  event_.Signal();
+}
+
 }  // namespace net