Refactorings surrounding HostResolver:...

chrome/test/unit/chrome_test_suite.h

 // 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.
 
 #ifndef CHROME_TEST_UNIT_CHROME_TEST_SUITE_H_
 #define CHROME_TEST_UNIT_CHROME_TEST_SUITE_H_
 
 #include "build/build_config.h"
 
 #include <string>
@@ skipping 10 matching lines @@
 #include "base/scoped_nsautorelease_pool.h"
 #include "base/test_suite.h"
 #include "chrome/app/scoped_ole_initializer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #if defined(OS_MACOSX)
 #include "chrome/common/mac_app_names.h"
 #endif
 #include "chrome/test/testing_browser_process.h"
-#include "net/base/host_resolver_unittest.h"
+#include "net/base/mock_host_resolver.h"
 #include "net/base/net_util.h"
 
 // In many cases it may be not obvious that a test makes a real DNS lookup.
 // We generally don't want to rely on external DNS servers for our tests,
-// so this mapper catches external queries.
-class WarningHostMapper : public net::HostMapper {
+// so this host resolver procedure catches external queries.
+class WarningHostResolverProc : public net::HostResolverProc {
  public:
-  virtual std::string Map(const std::string& host) {
+  WarningHostResolverProc() : HostResolverProc(NULL) {}
+
+  virtual int Resolve(const std::string& host, net::AddressList* addrlist) {
     const char* kLocalHostNames[] = {"localhost", "127.0.0.1"};
     bool local = false;
 
     if (host == net::GetHostName()) {
       local = true;
     } else {
       for (size_t i = 0; i < arraysize(kLocalHostNames); i++)
         if (host == kLocalHostNames[i]) {
           local = true;
           break;
         }
     }
 
     // Make the test fail so it's harder to ignore.
-    // If you really need to make real DNS query, use net::RuleBasedHostMapper
-    // and its AllowDirectLookup method.
+    // If you really need to make real DNS query, use
+    // net::RuleBasedHostResolverProc and its AllowDirectLookup method.
     EXPECT_TRUE(local) << "Making external DNS lookup of " << host;
 
-    return MapUsingPrevious(host);
+    return ResolveUsingPrevious(host, addrlist);
   }
 };
 
 class ChromeTestSuite : public TestSuite {
  public:
   ChromeTestSuite(int argc, char** argv) : TestSuite(argc, argv) {
   }
 
  protected:
 
   virtual void Initialize() {
     base::ScopedNSAutoreleasePool autorelease_pool;
 
     TestSuite::Initialize();
 
-    host_mapper_ = new WarningHostMapper();
-    scoped_host_mapper_.Init(host_mapper_.get());
+    host_resolver_proc_ = new WarningHostResolverProc();
+    scoped_host_resolver_proc_.Init(host_resolver_proc_.get());
 
     chrome::RegisterPathProvider();
     app::RegisterPathProvider();
     g_browser_process = new TestingBrowserProcess;
 
     // Notice a user data override, and otherwise default to using a custom
     // user data directory that lives alongside the current app.
     // NOTE: The user data directory will be erased before each UI test that
     //       uses it, in order to ensure consistency.
     FilePath user_data_dir = FilePath::FromWStringHack(
@@ skipping 47 matching lines @@
     if (PathService::Get(chrome::DIR_USER_DATA, &user_data_dir) &&
         !user_data_dir.empty()) {
       file_util::Delete(user_data_dir, true);
       file_util::Delete(user_data_dir.DirName(), false);
     }
     TestSuite::Shutdown();
   }
 
   StatsTable* stats_table_;
   ScopedOleInitializer ole_initializer_;
-  scoped_refptr<WarningHostMapper> host_mapper_;
-  net::ScopedHostMapper scoped_host_mapper_;
+  scoped_refptr<WarningHostResolverProc> host_resolver_proc_;
+  net::ScopedDefaultHostResolverProc scoped_host_resolver_proc_;
 };
 
 #endif  // CHROME_TEST_UNIT_CHROME_TEST_SUITE_H_