Refactorings surrounding HostResolver:...

net/http/http_network_transaction_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 <math.h>  // ceil
 
 #include "base/compiler_specific.h"
 #include "net/base/completion_callback.h"
-#include "net/base/host_resolver_unittest.h"
+#include "net/base/mock_host_resolver.h"
 #include "net/base/ssl_info.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_auth_handler_ntlm.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/socket_test_util.h"
 #include "net/socket/ssl_client_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 //-----------------------------------------------------------------------------
 
 namespace net {
 
 // Create a proxy service which fails on all requests (falls back to direct).
 ProxyService* CreateNullProxyService() {
   return ProxyService::CreateNull();
 }
 
 // Helper to manage the lifetimes of the dependencies for a
 // HttpNetworkTransaction.
 class SessionDependencies {
  public:
   // Default set of dependencies -- "null" proxy service.
-  SessionDependencies() : host_resolver(new HostResolver),
+  SessionDependencies() : host_resolver(new MockHostResolver),
       proxy_service(CreateNullProxyService()) {}
 
   // Custom proxy service dependency.
   explicit SessionDependencies(ProxyService* proxy_service)
-      : host_resolver(new HostResolver), proxy_service(proxy_service) {}
+      : host_resolver(new MockHostResolver), proxy_service(proxy_service) {}
 
-  scoped_refptr<HostResolver> host_resolver;
+  scoped_refptr<MockHostResolver> host_resolver;
   scoped_ptr<ProxyService> proxy_service;
   MockClientSocketFactory socket_factory;
 };
 
 ProxyService* CreateFixedProxyService(const std::string& proxy) {
   net::ProxyConfig proxy_config;
   proxy_config.proxy_rules.ParseFromString(proxy);
   return ProxyService::CreateFixed(proxy_config);
 }
 
@@ skipping 3288 matching lines @@
     TestCompletionCallback callback;
 
     // We do not complete this request, the dtor will clean the transaction up.
     EXPECT_EQ(ERR_IO_PENDING, trans->Start(&request, &callback));
     EXPECT_EQ(tests[i].expected_group_name,
               conn_pool->last_group_name_received());
   }
 }
 
 TEST_F(HttpNetworkTransactionTest, ReconsiderProxyAfterFailedConnection) {
-  scoped_refptr<RuleBasedHostMapper> host_mapper(new RuleBasedHostMapper());
-  ScopedHostMapper scoped_host_mapper(host_mapper.get());
-  host_mapper->AddSimulatedFailure("*");
-
   SessionDependencies session_deps(
       CreateFixedProxyService("myproxy:70;foobar:80"));
+
+  session_deps.host_resolver->rules()->AddSimulatedFailure("*");
+
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
           CreateSession(&session_deps),
           &session_deps.socket_factory));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
 
   TestCompletionCallback callback;
@@ skipping 80 matching lines @@
   EXPECT_EQ(ERR_FAILED, rv);
 
   // Check that the host resolution observer saw |referrer|.
   EXPECT_TRUE(resolution_observer.did_complete_with_expected_referrer());
 }
 
 // Make sure that when the load flags contain LOAD_BYPASS_CACHE, the resolver's
 // host cache is bypassed.
 TEST_F(HttpNetworkTransactionTest, BypassHostCacheOnRefresh) {
   SessionDependencies session_deps;
+
+  // Enable caching in the mock host resolver (it is off by default).
+  session_deps.host_resolver->Reset(NULL, 100, 60000);
+
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(&session_deps), &session_deps.socket_factory));
 
   // Warm up the host cache so it has an entry for "www.google.com" (by doing
   // a synchronous lookup.)
   AddressList addrlist;
   int rv = session_deps.host_resolver->Resolve(
     HostResolver::RequestInfo("www.google.com", 80), &addrlist, NULL, NULL);
   EXPECT_EQ(OK, rv);
 
   // Verify that it was added to host cache, by doing a subsequent async lookup
   // and confirming it completes synchronously.
   TestCompletionCallback resolve_callback;
   rv = session_deps.host_resolver->Resolve(
       HostResolver::RequestInfo("www.google.com", 80), &addrlist,
       &resolve_callback, NULL);
-  EXPECT_EQ(OK, rv);
+  ASSERT_EQ(OK, rv);
 
   // Inject a failure the next time that "www.google.com" is resolved. This way
   // we can tell if the next lookup hit the cache, or the "network".
   // (cache --> success, "network" --> failure).
-  scoped_refptr<RuleBasedHostMapper> host_mapper(new RuleBasedHostMapper());
-  ScopedHostMapper scoped_host_mapper(host_mapper.get());
-  host_mapper->AddSimulatedFailure("www.google.com");
+  session_deps.host_resolver->rules()->AddSimulatedFailure("www.google.com");
 
   // Connect up a mock socket which will fail with ERR_UNEXPECTED during the
   // first read -- this won't be reached as the host resolution will fail first.
   MockRead data_reads[] = { MockRead(false, ERR_UNEXPECTED) };
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   // Issue a request, asking to bypass the cache(s).
   HttpRequestInfo request;
   request.method = "GET";
   request.load_flags = LOAD_BYPASS_CACHE;
   request.url = GURL("http://www.google.com/");
 
   // Run the request.
   TestCompletionCallback callback;
   rv = trans->Start(&request, &callback);
   ASSERT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // If we bypassed the cache, we would have gotten a failure while resolving
   // "www.google.com".
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 }  // namespace net