Refactorings surrounding HostResolver:...

net/socket/tcp_client_socket_pool_unittest.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/socket/tcp_client_socket_pool.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
-#include "net/base/host_resolver_unittest.h"
+#include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/client_socket.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
@@ skipping 197 matching lines @@
  private:
   std::vector<TestSocketRequest*>* request_order_;
   TestCompletionCallback callback_;
 };
 
 int TestSocketRequest::completion_count = 0;
 
 class TCPClientSocketPoolTest : public testing::Test {
  protected:
   TCPClientSocketPoolTest()
-      : pool_(new TCPClientSocketPool(kMaxSocketsPerGroup,
-                                      new HostResolver,
-                                      &client_socket_factory_)) {}
+      : host_resolver_(new MockHostResolver),
+        pool_(new TCPClientSocketPool(kMaxSocketsPerGroup,
+                                      host_resolver_,
+                                      &client_socket_factory_)) {
+    // We enable caching on the mock host-resolver (it is off by default),
+    // because some of the tests in this file expect it.
+    host_resolver_->Reset(NULL, 100, 60000);
+  }
 
   virtual void SetUp() {
-    RuleBasedHostMapper *host_mapper = new RuleBasedHostMapper();
-    host_mapper->AddRule("*", "127.0.0.1");
-    scoped_host_mapper_.Init(host_mapper);
     TestSocketRequest::completion_count = 0;
   }
 
   virtual void TearDown() {
     // The tests often call Reset() on handles at the end which may post
     // DoReleaseSocket() tasks.
     MessageLoop::current()->RunAllPending();
   }
 
-  ScopedHostMapper scoped_host_mapper_;
+  scoped_refptr<MockHostResolver> host_resolver_;
   MockClientSocketFactory client_socket_factory_;
   scoped_refptr<ClientSocketPool> pool_;
   std::vector<TestSocketRequest*> request_order_;
 };
 
 TEST_F(TCPClientSocketPoolTest, Basic) {
   TestCompletionCallback callback;
   ClientSocketHandle handle(pool_.get());
   HostResolver::RequestInfo info("www.google.com", 80);
   int rv = handle.Init("a", info, 0, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
 
   handle.Reset();
 }
 
 TEST_F(TCPClientSocketPoolTest, InitHostResolutionFailure) {
-  RuleBasedHostMapper* host_mapper = new RuleBasedHostMapper;
-  host_mapper->AddSimulatedFailure("unresolvable.host.name");
-  ScopedHostMapper scoped_host_mapper(host_mapper);
+  host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
   TestSocketRequest req(pool_.get(), &request_order_);
   HostResolver::RequestInfo info("unresolvable.host.name", 80);
   EXPECT_EQ(ERR_IO_PENDING, req.handle.Init("a", info, 5, &req));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req.WaitForResult());
 }
 
 TEST_F(TCPClientSocketPoolTest, InitConnectionFailure) {
   client_socket_factory_.set_client_socket_type(
       MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
   TestSocketRequest req(pool_.get(), &request_order_);
@@ skipping 335 matching lines @@
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   for (size_t i = 0; i < arraysize(reqs); ++i)
     EXPECT_EQ(ERR_CONNECTION_FAILED, reqs[i]->WaitForResult());
 }
 
 }  // namespace
 
 }  // namespace net