Remove the HostResolverImpl::Shutdown() method.

This was originally needed to avoid crashing when the HostResolverImpl was being leaked, by forcing things to a "shutdown" state.
However since HostResolverImpl is no longer reference counted, this work-around is no longer necessary.

The other place that HostResolver::Shutdown() was used, was in SyncHostResolverBridge. It overrode it to unblock synchronous host resolves and avoid deadlock during shutdown. To accomodate this user, I added a separate interface (SyncHostResolver) to expose the shutdown method.

Lastly, fixed a leak of SyncHostResolverBridge by moving ownership of the dependency into ProxyResolverJSBindings.

BUG=74572,76427,18373

Review URL: http://codereview.chromium.org/7046097

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@89167 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 104 insertions, 122 deletions

diff --git a/chrome/browser/io_thread.cc b/chrome/browser/io_thread.cc
index aa22c105..32386c9 100644
--- a/chrome/browser/io_thread.cc
+++ b/chrome/browser/io_thread.cc
@@ -545,11 +545,6 @@ void IOThread::CleanUp() {
   delete speculative_interceptor_;
   speculative_interceptor_ = NULL;
 
-  // TODO(eroman): hack for http://crbug.com/15513
-  if (globals_->host_resolver->GetAsHostResolverImpl()) {
-    globals_->host_resolver.get()->GetAsHostResolverImpl()->Shutdown();
-  }
-
   system_proxy_config_service_.reset();
 
   delete globals_;
diff --git a/net/base/host_resolver.h b/net/base/host_resolver.h
index fd5cf6d..d46fcc3 100644
--- a/net/base/host_resolver.h
+++ b/net/base/host_resolver.h
@@ -189,9 +189,6 @@ class NET_API HostResolver {
   // additional functionality on the about:net-internals page.
   virtual HostResolverImpl* GetAsHostResolverImpl();
 
-  // Does additional cleanup prior to destruction.
-  virtual void Shutdown() {}
-
  protected:
   HostResolver();
 
diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc
index d404b7e..9b412a0 100644
--- a/net/base/host_resolver_impl.cc
+++ b/net/base/host_resolver_impl.cc
@@ -1085,7 +1085,6 @@ HostResolverImpl::HostResolverImpl(
       next_job_id_(0),
       resolver_proc_(resolver_proc),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
-      shutdown_(false),
       ipv6_probe_monitoring_(false),
       additional_resolver_flags_(0),
       net_log_(net_log) {
@@ -1154,9 +1153,6 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
                               const BoundNetLog& source_net_log) {
   DCHECK(CalledOnValidThread());
 
-  if (shutdown_)
-    return ERR_UNEXPECTED;
-
   // Choose a unique ID number for observers to see.
   int request_id = next_request_id_++;
 
@@ -1281,14 +1277,6 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
 // cancelled requests from Job::requests_.
 void HostResolverImpl::CancelRequest(RequestHandle req_handle) {
   DCHECK(CalledOnValidThread());
-  if (shutdown_) {
-    // TODO(eroman): temp hack for: http://crbug.com/18373
-    // Because we destroy outstanding requests during Shutdown(),
-    // |req_handle| is already cancelled.
-    LOG(ERROR) << "Called HostResolverImpl::CancelRequest() after Shutdown().";
-    base::debug::StackTrace().PrintBacktrace();
-    return;
-  }
   Request* req = reinterpret_cast<Request*>(req_handle);
   DCHECK(req);
 
@@ -1344,16 +1332,6 @@ HostResolverImpl* HostResolverImpl::GetAsHostResolverImpl() {
   return this;
 }
 
-void HostResolverImpl::Shutdown() {
-  DCHECK(CalledOnValidThread());
-
-  // Cancel the outstanding jobs.
-  CancelAllJobs();
-  DiscardIPv6ProbeJob();
-
-  shutdown_ = true;
-}
-
 void HostResolverImpl::AddOutstandingJob(Job* job) {
   scoped_refptr<Job>& found_job = jobs_[job->key()];
   DCHECK(!found_job);
@@ -1637,9 +1615,6 @@ void HostResolverImpl::OnIPAddressChanged() {
   if (cache_.get())
     cache_->clear();
   if (ipv6_probe_monitoring_) {
-    DCHECK(!shutdown_);
-    if (shutdown_)
-      return;
     DiscardIPv6ProbeJob();
     ipv6_probe_job_ = new IPv6ProbeJob(this);
     ipv6_probe_job_->Start();
diff --git a/net/base/host_resolver_impl.h b/net/base/host_resolver_impl.h
index 19b4a2e..a6f5220 100644
--- a/net/base/host_resolver_impl.h
+++ b/net/base/host_resolver_impl.h
@@ -148,9 +148,6 @@ class NET_API HostResolverImpl
 
   virtual HostResolverImpl* GetAsHostResolverImpl();
 
-  // TODO(eroman): hack for http://crbug.com/15513
-  virtual void Shutdown();
-
  private:
   // Allow tests to access our innards for testing purposes.
   friend class LookupAttemptHostResolverProc;
@@ -325,9 +322,6 @@ class NET_API HostResolverImpl
   // Address family to use when the request doesn't specify one.
   AddressFamily default_address_family_;
 
-  // TODO(eroman): hack for http://crbug.com/15513
-  bool shutdown_;
-
   // Indicate if probing is done after each network change event to set address
   // family.
   // When false, explicit setting of address family is used.
diff --git a/net/net.gyp b/net/net.gyp
index 63045517..9f4c86f 100644
--- a/net/net.gyp
+++ b/net/net.gyp
@@ -475,6 +475,7 @@
         'proxy/proxy_server.h',
         'proxy/proxy_service.cc',
         'proxy/proxy_service.h',
+        'proxy/sync_host_resolver.h',
         'proxy/sync_host_resolver_bridge.cc',
         'proxy/sync_host_resolver_bridge.h',
         'socket/client_socket_factory.cc',
diff --git a/net/proxy/proxy_resolver_js_bindings.cc b/net/proxy/proxy_resolver_js_bindings.cc
index 18d4e9e..8eed9be 100644
--- a/net/proxy/proxy_resolver_js_bindings.cc
+++ b/net/proxy/proxy_resolver_js_bindings.cc
@@ -16,6 +16,7 @@
 #include "net/base/sys_addrinfo.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/proxy/proxy_resolver_request_context.h"
+#include "net/proxy/sync_host_resolver.h"
 
 namespace net {
 
@@ -65,7 +66,7 @@ class AlertNetlogParams : public NetLog::EventParameters {
 // ProxyResolverJSBindings implementation.
 class DefaultJSBindings : public ProxyResolverJSBindings {
  public:
-  DefaultJSBindings(HostResolver* host_resolver,
+  DefaultJSBindings(SyncHostResolver* host_resolver,
                     NetLog* net_log,
                     ProxyResolverErrorObserver* error_observer)
       : host_resolver_(host_resolver),
@@ -255,9 +256,8 @@ class DefaultJSBindings : public ProxyResolverJSBindings {
       }
     }
 
-    // Otherwise ask the resolver.
-    int result = host_resolver_->Resolve(info, address_list, NULL, NULL,
-                                         BoundNetLog());
+    // Otherwise ask the host resolver.
+    int result = host_resolver_->Resolve(info, address_list);
 
     // Save the result back to the per-request DNS cache.
     if (host_cache) {
@@ -292,16 +292,17 @@ class DefaultJSBindings : public ProxyResolverJSBindings {
     }
   }
 
-  HostResolver* const host_resolver_;
+  scoped_ptr<SyncHostResolver> host_resolver_;
   NetLog* net_log_;
   scoped_ptr<ProxyResolverErrorObserver> error_observer_;
+  DISALLOW_COPY_AND_ASSIGN(DefaultJSBindings);
 };
 
 }  // namespace
 
 // static
 ProxyResolverJSBindings* ProxyResolverJSBindings::CreateDefault(
-    HostResolver* host_resolver,
+    SyncHostResolver* host_resolver,
     NetLog* net_log,
     ProxyResolverErrorObserver* error_observer) {
   return new DefaultJSBindings(host_resolver, net_log, error_observer);
diff --git a/net/proxy/proxy_resolver_js_bindings.h b/net/proxy/proxy_resolver_js_bindings.h
index d2a53d1..8d7e916 100644
--- a/net/proxy/proxy_resolver_js_bindings.h
+++ b/net/proxy/proxy_resolver_js_bindings.h
@@ -17,6 +17,7 @@ class HostResolver;
 class NetLog;
 class ProxyResolverErrorObserver;
 struct ProxyResolverRequestContext;
+class SyncHostResolver;
 
 // Interface for the javascript bindings.
 class NET_TEST ProxyResolverJSBindings {
@@ -65,10 +66,10 @@ class NET_TEST ProxyResolverJSBindings {
   //   - Send script alert()s to both VLOG(1) and the NetLog.
   //   - Use the provided host resolver to service dnsResolve().
   //
-  // Note that |host_resolver| will be used in sync mode mode.
-  // Takes ownership of |error_observer| which might be NULL.
+  // Takes ownership of |host_resolver| and |error_observer| (the latter can
+  // be NULL).
   static ProxyResolverJSBindings* CreateDefault(
-      HostResolver* host_resolver,
+      SyncHostResolver* host_resolver,
       NetLog* net_log,
       ProxyResolverErrorObserver* error_observer);
 
diff --git a/net/proxy/proxy_resolver_js_bindings_unittest.cc b/net/proxy/proxy_resolver_js_bindings_unittest.cc
index 3355adb..80618f3 100644
--- a/net/proxy/proxy_resolver_js_bindings_unittest.cc
+++ b/net/proxy/proxy_resolver_js_bindings_unittest.cc
@@ -14,6 +14,7 @@
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/proxy/proxy_resolver_request_context.h"
+#include "net/proxy/sync_host_resolver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -25,14 +26,11 @@ namespace {
 //     192.168.1.1
 //     172.22.34.1
 //     200.100.1.2
-class MockHostResolverWithMultipleResults : public HostResolver {
+class MockHostResolverWithMultipleResults : public SyncHostResolver {
  public:
   // HostResolver methods:
-  virtual int Resolve(const RequestInfo& info,
-                      AddressList* addresses,
-                      CompletionCallback* callback,
-                      RequestHandle* out_req,
-                      const BoundNetLog& net_log) {
+  virtual int Resolve(const HostResolver::RequestInfo& info,
+                      AddressList* addresses) {
     // Build up the result list (in reverse).
     AddressList temp_list = ResolveIPLiteral("200.100.1.2");
     temp_list = PrependAddressToList("172.22.34.1", temp_list);
@@ -40,9 +38,7 @@ class MockHostResolverWithMultipleResults : public HostResolver {
     *addresses = temp_list;
     return OK;
   }
-  virtual void CancelRequest(RequestHandle req) {}
-  virtual void AddObserver(Observer* observer) {}
-  virtual void RemoveObserver(Observer* observer) {}
+
   virtual void Shutdown() {}
 
  private:
@@ -71,23 +67,17 @@ class MockHostResolverWithMultipleResults : public HostResolver {
   }
 };
 
-class MockFailingHostResolver : public HostResolver {
+class MockFailingHostResolver : public SyncHostResolver {
  public:
   MockFailingHostResolver() : count_(0) {}
 
   // HostResolver methods:
-  virtual int Resolve(const RequestInfo& info,
-                      AddressList* addresses,
-                      CompletionCallback* callback,
-                      RequestHandle* out_req,
-                      const BoundNetLog& net_log) {
+  virtual int Resolve(const HostResolver::RequestInfo& info,
+                      AddressList* addresses) {
     count_++;
     return ERR_NAME_NOT_RESOLVED;
   }
 
-  virtual void CancelRequest(RequestHandle req) {}
-  virtual void AddObserver(Observer* observer) {}
-  virtual void RemoveObserver(Observer* observer) {}
   virtual void Shutdown() {}
 
   // Returns the number of times Resolve() has been called.
@@ -98,12 +88,29 @@ class MockFailingHostResolver : public HostResolver {
   int count_;
 };
 
+class MockSyncHostResolver : public SyncHostResolver {
+ public:
+  virtual int Resolve(const HostResolver::RequestInfo& info,
+                      AddressList* addresses) {
+    return resolver_.Resolve(info, addresses, NULL, NULL, BoundNetLog());
+  }
+
+  virtual void Shutdown() {}
+
+  RuleBasedHostResolverProc* rules() {
+    return resolver_.rules();
+  }
+
+ private:
+  MockHostResolver resolver_;
+};
+
 TEST(ProxyResolverJSBindingsTest, DnsResolve) {
-  scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver);
+  MockSyncHostResolver* host_resolver = new MockSyncHostResolver;
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver.get(), NULL, NULL));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL, NULL));
 
   std::string ip_address;
 
@@ -126,11 +133,11 @@ TEST(ProxyResolverJSBindingsTest, DnsResolve) {
 }
 
 TEST(ProxyResolverJSBindingsTest, MyIpAddress) {
-  scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver);
+  MockSyncHostResolver* host_resolver = new MockSyncHostResolver;
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver.get(), NULL, NULL));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL, NULL));
 
   // Our IP address is always going to be 127.0.0.1, since we are using a
   // mock host resolver.
@@ -153,11 +160,11 @@ TEST(ProxyResolverJSBindingsTest, MyIpAddress) {
 //     myIpAddressEx()
 //     dnsResolveEx()
 TEST(ProxyResolverJSBindingsTest, RestrictAddressFamily) {
-  scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver);
+  MockSyncHostResolver* host_resolver = new MockSyncHostResolver;
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver.get(), NULL, NULL));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL, NULL));
 
   // Make it so requests resolve to particular address patterns based on family:
   //  IPV4_ONLY --> 192.168.1.*
@@ -175,13 +182,11 @@ TEST(ProxyResolverJSBindingsTest, RestrictAddressFamily) {
   // depending if the address family was IPV4_ONLY or not.
   HostResolver::RequestInfo info(HostPortPair("foo", 80));
   AddressList address_list;
-  EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list, NULL, NULL,
-                                       BoundNetLog()));
+  EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list));
   EXPECT_EQ("192.168.2.1", NetAddressToString(address_list.head()));
 
   info.set_address_family(ADDRESS_FAMILY_IPV4);
-  EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list, NULL, NULL,
-                                       BoundNetLog()));
+  EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list));
   EXPECT_EQ("192.168.1.1", NetAddressToString(address_list.head()));
 
   std::string ip_address;
@@ -209,12 +214,12 @@ TEST(ProxyResolverJSBindingsTest, RestrictAddressFamily) {
 // separated list of addresses (as opposed to the non-Ex versions which
 // just return the first result).
 TEST(ProxyResolverJSBindingsTest, ExFunctionsReturnList) {
-  scoped_ptr<HostResolver> host_resolver(
-      new MockHostResolverWithMultipleResults);
+  SyncHostResolver* host_resolver =
+      new MockHostResolverWithMultipleResults;
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver.get(), NULL, NULL));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL, NULL));
 
   std::string ip_addresses;
 
@@ -226,12 +231,11 @@ TEST(ProxyResolverJSBindingsTest, ExFunctionsReturnList) {
 }
 
 TEST(ProxyResolverJSBindingsTest, PerRequestDNSCache) {
-  scoped_ptr<MockFailingHostResolver> host_resolver(
-      new MockFailingHostResolver);
+  MockFailingHostResolver* host_resolver = new MockFailingHostResolver;
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
-      ProxyResolverJSBindings::CreateDefault(host_resolver.get(), NULL, NULL));
+      ProxyResolverJSBindings::CreateDefault(host_resolver, NULL, NULL));
 
   std::string ip_address;
 
@@ -276,15 +280,14 @@ TEST(ProxyResolverJSBindingsTest, PerRequestDNSCache) {
 
 // Test that when a binding is called, it logs to the per-request NetLog.
 TEST(ProxyResolverJSBindingsTest, NetLog) {
-  scoped_ptr<MockFailingHostResolver> host_resolver(
-      new MockFailingHostResolver);
+  MockFailingHostResolver* host_resolver = new MockFailingHostResolver;
 
   CapturingNetLog global_log(CapturingNetLog::kUnbounded);
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
       ProxyResolverJSBindings::CreateDefault(
-          host_resolver.get(), &global_log, NULL));
+          host_resolver, &global_log, NULL));
 
   // Attach a capturing NetLog as the current request's log stream.
   CapturingNetLog log(CapturingNetLog::kUnbounded);
diff --git a/net/proxy/proxy_resolver_perftest.cc b/net/proxy/proxy_resolver_perftest.cc
index c3d6588..e4989fe 100644
--- a/net/proxy/proxy_resolver_perftest.cc
+++ b/net/proxy/proxy_resolver_perftest.cc
@@ -12,6 +12,7 @@
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
 #include "net/proxy/proxy_resolver_v8.h"
+#include "net/proxy/sync_host_resolver.h"
 #include "net/test/test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -21,6 +22,16 @@
 #include "net/proxy/proxy_resolver_mac.h"
 #endif
 
+class MockSyncHostResolver : public net::SyncHostResolver {
+ public:
+  virtual int Resolve(const net::HostResolver::RequestInfo& info,
+                      net::AddressList* addresses) {
+    return net::ERR_NAME_NOT_RESOLVED;
+  }
+
+  virtual void Shutdown() {}
+};
+
 // This class holds the URL to use for resolving, and the expected result.
 // We track the expected result in order to make sure the performance
 // test is actually resolving URLs properly, otherwise the perf numbers
@@ -193,7 +204,7 @@ TEST(ProxyResolverPerfTest, ProxyResolverMac) {
 TEST(ProxyResolverPerfTest, ProxyResolverV8) {
   net::ProxyResolverJSBindings* js_bindings =
       net::ProxyResolverJSBindings::CreateDefault(
-          new net::MockHostResolver, NULL, NULL);
+          new MockSyncHostResolver, NULL, NULL);
 
   net::ProxyResolverV8 resolver(js_bindings);
   PacPerfSuiteRunner runner(&resolver, "ProxyResolverV8");
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index a16cb57..31e20c5 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -193,7 +193,8 @@ class ProxyResolverFactoryForV8 : public ProxyResolverFactory {
         new NetworkDelegateErrorObserver(
             network_delegate_, origin_loop_.get());
 
-    // ProxyResolverJSBindings takes ownership of |error_observer|.
+    // ProxyResolverJSBindings takes ownership of |error_observer| and
+    // |sync_host_resolver|.
     ProxyResolverJSBindings* js_bindings =
         ProxyResolverJSBindings::CreateDefault(
             sync_host_resolver, net_log_, error_observer);
diff --git a/net/proxy/sync_host_resolver.h b/net/proxy/sync_host_resolver.h
new file mode 100644
index 0000000..db06e64
--- /dev/null
+++ b/net/proxy/sync_host_resolver.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2011 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.
+
+#ifndef NET_PROXY_SYNC_HOST_RESOLVER_H_
+#define NET_PROXY_SYNC_HOST_RESOLVER_H_
+#pragma once
+
+#include "net/base/host_resolver.h"
+
+namespace net {
+
+// Interface used by ProxyResolverJSBindings to abstract a synchronous host
+// resolver module (which includes a Shutdown method).
+class SyncHostResolver {
+ public:
+  virtual ~SyncHostResolver() {}
+
+  virtual int Resolve(const HostResolver::RequestInfo& info,
+                      AddressList* addresses) = 0;
+
+  // Optionally aborts any blocking resolves that are in progress.
+  virtual void Shutdown() = 0;
+};
+
+}  // namespace net
+
+#endif  // NET_PROXY_SYNC_HOST_RESOLVER_H_
diff --git a/net/proxy/sync_host_resolver_bridge.cc b/net/proxy/sync_host_resolver_bridge.cc
index 80270f6..4d204bc 100644
--- a/net/proxy/sync_host_resolver_bridge.cc
+++ b/net/proxy/sync_host_resolver_bridge.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
@@ -160,29 +160,11 @@ SyncHostResolverBridge::~SyncHostResolverBridge() {
   DCHECK(core_->HasShutdown());
 }
 
-int SyncHostResolverBridge::Resolve(const RequestInfo& info,
-                                    AddressList* addresses,
-                                    CompletionCallback* callback,
-                                    RequestHandle* out_req,
-                                    const BoundNetLog& net_log) {
-  DCHECK(!callback);
-  DCHECK(!out_req);
-
+int SyncHostResolverBridge::Resolve(const HostResolver::RequestInfo& info,
+                                    AddressList* addresses) {
   return core_->ResolveSynchronously(info, addresses);
 }
 
-void SyncHostResolverBridge::CancelRequest(RequestHandle req) {
-  NOTREACHED();
-}
-
-void SyncHostResolverBridge::AddObserver(Observer* observer) {
-  NOTREACHED();
-}
-
-void SyncHostResolverBridge::RemoveObserver(Observer* observer) {
-  NOTREACHED();
-}
-
 void SyncHostResolverBridge::Shutdown() {
   DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
   core_->Shutdown();
diff --git a/net/proxy/sync_host_resolver_bridge.h b/net/proxy/sync_host_resolver_bridge.h
index e39c6eed..88e4cd4 100644
--- a/net/proxy/sync_host_resolver_bridge.h
+++ b/net/proxy/sync_host_resolver_bridge.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include "base/memory/scoped_ptr.h"
-#include "net/base/host_resolver.h"
+#include "net/proxy/sync_host_resolver.h"
 
 class MessageLoop;
 
@@ -15,22 +15,16 @@ namespace net {
 
 // Wrapper around HostResolver to give a sync API while running the resolver
 // in async mode on |host_resolver_loop|.
-class NET_TEST SyncHostResolverBridge : public HostResolver {
+class NET_TEST SyncHostResolverBridge : public SyncHostResolver {
  public:
   SyncHostResolverBridge(HostResolver* host_resolver,
                          MessageLoop* host_resolver_loop);
 
   virtual ~SyncHostResolverBridge();
 
-  // HostResolver methods:
-  virtual int Resolve(const RequestInfo& info,
-                      AddressList* addresses,
-                      CompletionCallback* callback,
-                      RequestHandle* out_req,
-                      const BoundNetLog& net_log);
-  virtual void CancelRequest(RequestHandle req);
-  virtual void AddObserver(Observer* observer);
-  virtual void RemoveObserver(Observer* observer);
+  // SyncHostResolver methods:
+  virtual int Resolve(const HostResolver::RequestInfo& info,
+                      AddressList* addresses);
 
   // The Shutdown() method should be called prior to destruction, from
   // |host_resolver_loop_|. It aborts any in progress synchronous resolves, to
diff --git a/net/proxy/sync_host_resolver_bridge_unittest.cc b/net/proxy/sync_host_resolver_bridge_unittest.cc
index 5cb053ec..d2eca42 100644
--- a/net/proxy/sync_host_resolver_bridge_unittest.cc
+++ b/net/proxy/sync_host_resolver_bridge_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
@@ -93,8 +93,7 @@ class SyncProxyResolver : public ProxyResolver {
     // Do a synchronous host resolve.
     HostResolver::RequestInfo info(HostPortPair::FromURL(url));
     AddressList addresses;
-    int rv =
-        host_resolver_->Resolve(info, &addresses, NULL, NULL, BoundNetLog());
+    int rv = host_resolver_->Resolve(info, &addresses);
 
     EXPECT_EQ(ERR_ABORTED, rv);