Adds HostResolveImpl Requests and Jobs to log.

net/base/host_resolver_impl_unittest.cc

 // Copyright (c) 2010 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/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 20 matching lines @@
 HostCache* CreateDefaultCache() {
   return new HostCache(
       100,  // max cache entries.
       base::TimeDelta::FromMinutes(1),
       base::TimeDelta::FromSeconds(0));
 }
 
 static const size_t kMaxJobs = 10u;
 
 HostResolverImpl* CreateHostResolverImpl(HostResolverProc* resolver_proc) {
-  return new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs);
+  return new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs,
+                              NULL);
 }
 
 // Helper to create a HostResolver::RequestInfo.
 HostResolver::RequestInfo CreateResolverRequest(
     const std::string& hostname,
     RequestPriority priority) {
   HostResolver::RequestInfo info(hostname, 80);
   info.set_priority(priority);
   return info;
 }
@@ skipping 270 matching lines @@
   const struct sockaddr* sa = ainfo->ai_addr;
   const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
   EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port);
   EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr);
 }
 
 TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc =
       new WaitingHostResolverProc(NULL);
 
+  CapturingNetLog net_log(CapturingNetLog::kUnbounded);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   {
     scoped_refptr<HostResolver> host_resolver(
-        CreateHostResolverImpl(resolver_proc));
+        new HostResolverImpl(resolver_proc,
+                             CreateDefaultCache(),
+                             kMaxJobs,
+                             &net_log));
     AddressList adrlist;
     const int kPortnum = 80;
 
     HostResolver::RequestInfo info("just.testing", kPortnum);
     int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL,
                                      log.bound());
     EXPECT_EQ(ERR_IO_PENDING, err);
 
     // Make sure we will exit the queue even when callback is not called.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                             new MessageLoop::QuitTask(),
                                             1000);
     MessageLoop::current()->Run();
   }
 
   resolver_proc->Signal();
 
-  EXPECT_EQ(3u, log.entries().size());
+  EXPECT_EQ(2u, log.entries().size());
   EXPECT_TRUE(LogContainsBeginEvent(
       log.entries(), 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
-  EXPECT_TRUE(LogContainsEvent(
-      log.entries(), 1, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEndEvent(
-      log.entries(), 2, NetLog::TYPE_HOST_RESOLVER_IMPL));
+      log.entries(), 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
+
+  int pos = net::ExpectLogContainsSomewhereAfter(net_log.entries(), 0,
+      net::NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
+      net::NetLog::PHASE_BEGIN);
+  pos = net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+      net::NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
+      net::NetLog::PHASE_BEGIN);
+  // Both Job and Request need to be cancelled.
+  pos = net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+      net::NetLog::TYPE_CANCELLED,
+      net::NetLog::PHASE_NONE);
+  // Don't care about order in which they end, or when the other one is
+  // cancelled.
+  net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+      net::NetLog::TYPE_CANCELLED,
+      net::NetLog::PHASE_NONE);
+  net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+      net::NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
+      net::NetLog::PHASE_END);
+  net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
+      net::NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
+      net::NetLog::PHASE_END);
 
   EXPECT_FALSE(callback_called_);
 }
 
 TEST_F(HostResolverImplTest, NumericIPv4Address) {
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AllowDirectLookup("*");
@@ skipping 376 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_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, NULL, kMaxJobs));
+      new HostResolverImpl(resolver_proc, NULL, kMaxJobs, 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, "a", 80, &verifier);
   ResolveRequest req2(host_resolver, "a", 81, &verifier);
@@ skipping 276 matching lines @@
   EXPECT_EQ(2U, observer.cancel_log.size());
 
   HostResolver::RequestInfo info("host2", 60);
   EXPECT_TRUE(observer.cancel_log[1] ==
               CapturingObserver::StartOrCancelEntry(1, info));
 }
 
 // Test that IP address changes flush the cache.
 TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(NULL, CreateDefaultCache(), kMaxJobs));
+      new HostResolverImpl(NULL, CreateDefaultCache(), kMaxJobs, NULL));
 
   AddressList addrlist;
 
   // Resolve "host1".
   HostResolver::RequestInfo info1("host1", 70);
   TestCompletionCallback callback;
   int rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ skipping 16 matching lines @@
 
 // Tests that when the maximum threads is set to 1, requests are dequeued
 // in order of priority.
 TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   size_t kMaxJobs = 1u;
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs,
+                           NULL));
 
   CapturingObserver observer;
   host_resolver->AddObserver(&observer);
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
   HostResolver::RequestInfo req[] = {
       CreateResolverRequest("req0", LOW),
       CreateResolverRequest("req1", MEDIUM),
@@ skipping 63 matching lines @@
 }
 
 // Try cancelling a request which has not been attached to a job yet.
 TEST_F(HostResolverImplTest, CancelPendingRequest) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxJobs = 1u;
   scoped_refptr<HostResolver> host_resolver(
-      new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs));
+      new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs,
+                           NULL));
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
   HostResolver::RequestInfo req[] = {
       CreateResolverRequest("req0", LOWEST),
       CreateResolverRequest("req1", HIGHEST),  // Will cancel.
       CreateResolverRequest("req2", MEDIUM),
       CreateResolverRequest("req3", LOW),
       CreateResolverRequest("req4", HIGHEST),   // Will cancel.
@@ skipping 41 matching lines @@
 }
 
 // Test that when too many requests are enqueued, old ones start to be aborted.
 TEST_F(HostResolverImplTest, QueueOverflow) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(NULL);
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
   scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
-      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   // Only allow up to 3 requests to be enqueued at a time.
   const size_t kMaxPendingRequests = 3u;
   host_resolver->SetPoolConstraints(HostResolverImpl::POOL_NORMAL,
                                     kMaxOutstandingJobs,
                                     kMaxPendingRequests);
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
@@ skipping 57 matching lines @@
 
 // Tests that after changing the default AddressFamily to IPV4, requests
 // with UNSPECIFIED address family map to IPV4.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(new EchoingHostResolverProc);
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
   scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
-      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
   HostResolver::RequestInfo req[] = {
       CreateResolverRequestForAddressFamily("h1", MEDIUM,
                                             ADDRESS_FAMILY_UNSPECIFIED),
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV4),
@@ skipping 47 matching lines @@
 // This is the exact same test as SetDefaultAddressFamily_IPv4, except the order
 // of requests 0 and 1 is flipped, and the default is set to IPv6 in place of
 // IPv4.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(new EchoingHostResolverProc);
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
   scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
-      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV6);
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
   HostResolver::RequestInfo req[] = {
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV6),
       CreateResolverRequestForAddressFamily("h1", MEDIUM,
                                             ADDRESS_FAMILY_UNSPECIFIED),
@@ skipping 45 matching lines @@
 }
 
 // This tests that the default address family is respected for synchronous
 // resolutions.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_Synchronous) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc =
       new CapturingHostResolverProc(new EchoingHostResolverProc);
 
   const size_t kMaxOutstandingJobs = 10u;
   scoped_refptr<HostResolverImpl> host_resolver(new HostResolverImpl(
-      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs));
+      resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   // Unblock the resolver thread so the requests can run.
   resolver_proc->Signal();
 
   HostResolver::RequestInfo req[] = {
       CreateResolverRequestForAddressFamily("b", MEDIUM,
                                             ADDRESS_FAMILY_UNSPECIFIED),
       CreateResolverRequestForAddressFamily("b", MEDIUM, ADDRESS_FAMILY_IPV6),
@@ skipping 31 matching lines @@
   EXPECT_EQ("192.1.98.2", NetAddressToString(addrlist[1].head()));
   EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[2].head()));
   EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[3].head()));
 }
 
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
 }  // namespace
 
 }  // namespace net