* Move the global "DnsResolutionObserver" code depended on by DNS prefetcher,...

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"
@@ skipping 52 matching lines @@
                          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.
+    // Port number doesn't matter.
+    HostResolver::RequestInfo info(hostname, 80);
 
     // Hack for tests -- run synchronously on current thread.
     if (!host_resolver_loop_)
-      return host_resolver_->Resolve(hostname, kPort, addresses, NULL, NULL);
+      return host_resolver_->Resolve(info, 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));
+        &SyncHostResolverBridge::StartResolve, info, 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,
+  void StartResolve(const HostResolver::RequestInfo& info,
                     net::AddressList* addresses) {
     DCHECK_EQ(host_resolver_loop_, MessageLoop::current());
-    int error = host_resolver_->Resolve(
-        hostname, port, addresses, &callback_, NULL);
+    int error = host_resolver_->Resolve(info, 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();
   }
@@ skipping 262 matching lines @@
     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