Start using the proxy resolve IPC for plugins....

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 491 matching lines @@
 
   url_domain += url.host();
   // This isn't superfluous; GURL case canonicalization doesn't hit the embedded
   // percent-encoded characters.
   StringToLowerASCII(&url_domain);
 
   if (config_.proxy_bypass_local_names) {
     if (url.host().find('.') == std::string::npos)
       return true;
   }
-  
+
   for(std::vector<std::string>::const_iterator i = config_.proxy_bypass.begin();
       i != config_.proxy_bypass.end(); ++i) {
     std::string bypass_url_domain = *i;
 
     // The proxy server bypass list can contain entities with http/https
     // If no scheme is specified then it indicates that all schemes are
     // allowed for the current entry. For matching this we just use
     // the protocol scheme of the url passed in.
     if (bypass_url_domain.find("://") == std::string::npos) {
       std::string bypass_url_domain_with_scheme = url.scheme();
       bypass_url_domain_with_scheme += "://";
       bypass_url_domain_with_scheme += bypass_url_domain;
 
       bypass_url_domain = bypass_url_domain_with_scheme;
     }
 
     StringToLowerASCII(&bypass_url_domain);
 
     if (MatchPattern(url_domain, bypass_url_domain))
       return true;
-      
+
     // 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