Avoid doing concurrent DNS resolves of the same hostname

net/proxy/proxy_resolver_v8.cc

 // Copyright (c) 2009 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_resolver_v8.h"
 
+#include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/waitable_event.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/address_list.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_script.h"
 #include "v8/include/v8.h"
 
@@ skipping 25 matching lines @@
     return false;
 
   v8::HandleScope scope;
   v8::Local<v8::String> str_object = object->ToString();
   if (str_object.IsEmpty())
     return false;
   *result = V8StringToStdString(str_object);
   return true;
 }
 
+// Wrapper around HostResolver to give a sync API while running the resolve
+// in async mode on |host_resolver_loop|. If |host_resolver_loop| is NULL,
+// runs sync on the current thread (this mode is just used by testing).
+class SyncHostResolverBridge
+    : public base::RefCountedThreadSafe<SyncHostResolverBridge> {
+ public:
+  SyncHostResolverBridge(HostResolver* host_resolver,
+                         MessageLoop* host_resolver_loop)
+      : host_resolver_(host_resolver),
+        host_resolver_loop_(host_resolver_loop),
+        event_(false, false),
+        ALLOW_THIS_IN_INITIALIZER_LIST(
+            callback_(this, &SyncHostResolverBridge::OnResolveCompletion)) {
+  }
+
+  // Run the resolve on host_resolver_loop, and wait for result.
+  int Resolve(const std::string& hostname, net::AddressList* addresses) {
+    int kPort = 80;   // Doesn't matter.
+
+    // Hack for tests -- run synchronously on current thread.
+    if (!host_resolver_loop_)
+      return host_resolver_->Resolve(hostname, kPort, addresses, NULL, NULL);
+
+    // Otherwise start an async resolve on the resolver's thread.
+    host_resolver_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
+        &SyncHostResolverBridge::StartResolve, hostname, kPort, addresses));
+
+    // Wait for the resolve to complete in the resolver's thread.
+    event_.Wait();
+    return err_;
+  }
+
+ private:
+  // Called on host_resolver_loop_.
+  void StartResolve(const std::string& hostname,
+                    int port,
+                    net::AddressList* addresses) {
+    DCHECK_EQ(host_resolver_loop_, MessageLoop::current());
+    int error = host_resolver_->Resolve(
+        hostname, port, addresses, &callback_, NULL);
+    if (error != ERR_IO_PENDING)
+      OnResolveCompletion(error);  // Completed synchronously.
+  }
+
+  // Called on host_resolver_loop_.
+  void OnResolveCompletion(int result) {
+    DCHECK_EQ(host_resolver_loop_, MessageLoop::current());
+    err_ = result;
+    event_.Signal();
+  }
+
+  HostResolver* host_resolver_;
+  MessageLoop* host_resolver_loop_;
+
+  // Event to notify completion of resolve request.
+  base::WaitableEvent event_;
+
+  // Callback for when the resolve completes on host_resolver_loop_.
+  net::CompletionCallbackImpl<SyncHostResolverBridge> callback_;
+
+  // The result from the result request (set by in host_resolver_loop_).
+  int err_;
+};
+
 // JSBIndings implementation.
 class DefaultJSBindings : public ProxyResolverV8::JSBindings {
  public:
+  DefaultJSBindings(HostResolver* host_resolver,
+                    MessageLoop* host_resolver_loop)
+      : host_resolver_(new SyncHostResolverBridge(
+          host_resolver, host_resolver_loop)) {}
+
   // Handler for "alert(message)".
   virtual void Alert(const std::string& message) {
     LOG(INFO) << "PAC-alert: " << message;
   }
 
   // Handler for "myIpAddress()". Returns empty string on failure.
   virtual std::string MyIpAddress() {
     // DnsResolve("") returns "", so no need to check for failure.
     return DnsResolve(GetHostName());
   }
 
   // Handler for "dnsResolve(host)". Returns empty string on failure.
   virtual std::string DnsResolve(const std::string& host) {
     // TODO(eroman): Should this return our IP address, or fail, or
     // simply be unspecified (works differently on windows and mac os x).
     if (host.empty())
       return std::string();
 
-    // Try to resolve synchronously.
+    // Do a sync resolve of the hostname.
     net::AddressList address_list;
-    const int kPort = 80;  // Doesn't matter what this is.
-    int result = host_resolver_.Resolve(host, kPort, &address_list, NULL);
+    int result = host_resolver_->Resolve(host, &address_list);
 
     if (result != OK)
       return std::string();  // Failed.
 
     if (!address_list.head())
       return std::string();
 
     // There may be multiple results; we will just use the first one.
     // This returns empty string on failure.
     return net::NetAddressToString(address_list.head());
   }
 
   // Handler for when an error is encountered. |line_number| may be -1.
   virtual void OnError(int line_number, const std::string& message) {
     if (line_number == -1)
       LOG(INFO) << "PAC-error: " << message;
     else
       LOG(INFO) << "PAC-error: " << "line: " << line_number << ": " << message;
   }
 
  private:
-  HostResolver host_resolver_;
+  scoped_refptr<SyncHostResolverBridge> host_resolver_;
 };
 
 }  // namespace
 
 // ProxyResolverV8::Context ---------------------------------------------------
 
 class ProxyResolverV8::Context {
  public:
   Context(JSBindings* js_bindings, const std::string& pac_data)
-       : js_bindings_(js_bindings) {
+      : js_bindings_(js_bindings) {
     DCHECK(js_bindings != NULL);
     InitV8(pac_data);
   }
 
   ~Context() {
     v8::Locker locked;
 
     v8_this_.Dispose();
     v8_context_.Dispose();
   }
@@ skipping 139 matching lines @@
         return v8::Undefined();
     }
 
     std::string result = context->js_bindings_->DnsResolve(host);
 
     // DoDnsResolve() returns empty string on failure.
     return result.empty() ? v8::Null() : StdStringToV8String(result);
   }
 
   JSBindings* js_bindings_;
-  HostResolver host_resolver_;
   v8::Persistent<v8::External> v8_this_;
   v8::Persistent<v8::Context> v8_context_;
 };
 
 // ProxyResolverV8 ------------------------------------------------------------
 
-// the |false| argument to ProxyResolver means the ProxyService will handle
-// downloading of the PAC script, and notify changes through SetPacScript().
-ProxyResolverV8::ProxyResolverV8()
-    : ProxyResolver(false /*does_fetch*/),
-      js_bindings_(new DefaultJSBindings()) {
-}
-
 ProxyResolverV8::ProxyResolverV8(
     ProxyResolverV8::JSBindings* custom_js_bindings)
     : ProxyResolver(false), js_bindings_(custom_js_bindings) {
 }
 
 ProxyResolverV8::~ProxyResolverV8() {}
 
 int ProxyResolverV8::GetProxyForURL(const GURL& query_url,
                                     const GURL& /*pac_url*/,
                                     ProxyInfo* results) {
   // If the V8 instance has not been initialized (either because SetPacScript()
   // wasn't called yet, or because it was called with empty string).
   if (!context_.get())
     return ERR_FAILED;
 
   // Otherwise call into V8.
   return context_->ResolveProxy(query_url, results);
 }
 
 void ProxyResolverV8::SetPacScript(const std::string& data) {
   context_.reset();
   if (!data.empty())
     context_.reset(new Context(js_bindings_.get(), data));
 }
 
+// static
+ProxyResolverV8::JSBindings* ProxyResolverV8::CreateDefaultBindings(
+    HostResolver* host_resolver, MessageLoop* host_resolver_loop) {
+  return new DefaultJSBindings(host_resolver, host_resolver_loop);
+}
+
 }  // namespace net