[net] HostResolverImpl + DnsTransaction + DnsConfigService = Asynchronous DNS ready for experiments.

net/base/host_resolver_impl_unittest.cc

 // Copyright (c) 2012 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/base/host_resolver_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 32 matching lines @@
 HostResolverImpl::ProcTaskParams DefaultParams(
     HostResolverProc* resolver_proc) {
   return HostResolverImpl::ProcTaskParams(resolver_proc,
                                           kMaxRetryAttempts);
 }
 
 HostResolverImpl* CreateHostResolverImpl(HostResolverProc* resolver_proc) {
   return new HostResolverImpl(
       HostCache::CreateDefaultCache(),
       DefaultLimits(),
+      DefaultLimits(),
       DefaultParams(resolver_proc),
+      scoped_ptr<DnsConfigService>(NULL),
       NULL);
 }
 
 // This HostResolverImpl will only allow 1 outstanding resolve at a time.
 HostResolverImpl* CreateSerialHostResolverImpl(
     HostResolverProc* resolver_proc) {
   HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc);
   params.max_retry_attempts = 0u;
 
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
 
   return new HostResolverImpl(HostCache::CreateDefaultCache(),
                               limits,
+                              limits,
                               params,
+                              scoped_ptr<DnsConfigService>(NULL),
                               NULL);
 }
 
 // Helper to create a HostResolver::RequestInfo.
 HostResolver::RequestInfo CreateResolverRequest(
     const std::string& hostname,
     RequestPriority priority) {
   HostResolver::RequestInfo info(HostPortPair(hostname, 80));
   info.set_priority(priority);
   return info;
@@ skipping 432 matching lines @@
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
       new WaitingHostResolverProc(NULL));
 
   CapturingNetLog net_log(CapturingNetLog::kUnbounded);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   {
     // This resolver will be destroyed while a lookup is running on WorkerPool.
     scoped_ptr<HostResolver> host_resolver(
         new HostResolverImpl(HostCache::CreateDefaultCache(),
                              DefaultLimits(),
+                             DefaultLimits(),
                              DefaultParams(resolver_proc),
+                             scoped_ptr<DnsConfigService>(NULL),
                              &net_log));
     AddressList addrlist;
     const int kPortnum = 80;
 
     HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
     int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                      log.bound());
     EXPECT_EQ(ERR_IO_PENDING, err);
 
     resolver_proc->Wait();
@@ skipping 435 matching lines @@
 
 TEST_F(HostResolverImplTest, StartWithinCallback) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
   scoped_refptr<CapturingHostResolverProc> resolver_proc(
       new CapturingHostResolverProc(NULL));
 
   // Turn off caching for this host resolver.
   scoped_ptr<HostResolver> host_resolver(new HostResolverImpl(
-      NULL, DefaultLimits(), DefaultParams(resolver_proc), NULL));
+      NULL,
+      DefaultLimits(),
+      DefaultLimits(),
+      DefaultParams(resolver_proc),
+      scoped_ptr<DnsConfigService>(NULL),
+      NULL));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   StartWithinCallbackVerifier verifier;
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
 
   ResolveRequest req1(host_resolver.get(), "a", 80, &verifier);
   ResolveRequest req2(host_resolver.get(), "a", 81, &verifier);
@@ skipping 591 matching lines @@
   HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc);
 
   // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so
   // that unit test runs faster. For example, this test finishes in 1.5 secs
   // (500ms * 3).
   params.unresponsive_delay = TimeDelta::FromMilliseconds(500);
 
   scoped_ptr<HostResolverImpl> host_resolver(
       new HostResolverImpl(HostCache::CreateDefaultCache(),
                            DefaultLimits(),
+                           DefaultLimits(),
                            params,
+                           scoped_ptr<DnsConfigService>(NULL),
                            NULL));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   TestCompletionCallback callback;
   AddressList addrlist;
   int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, callback.WaitForResult());
 
   resolver_proc->WaitForAllAttemptsToFinish(TimeDelta::FromMilliseconds(60000));
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts);
   EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve);
 }
 
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
 }  // namespace net