Add a "LoadLog*" parameter to transactions, hostresolver, clientsocketpool.

net/base/host_resolver_impl_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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <ws2tcpip.h>
 #include <wspiapi.h>
 #elif defined(OS_POSIX)
@@ skipping 73 matching lines @@
   };
 
   ResolveRequest(net::HostResolver* resolver,
                  const std::string& hostname,
                  int port,
                  Delegate* delegate)
       : info_(hostname, port), resolver_(resolver), delegate_(delegate),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             callback_(this, &ResolveRequest::OnLookupFinished)) {
     // Start the request.
-    int err = resolver->Resolve(info_, &addrlist_, &callback_, &req_);
+    int err = resolver->Resolve(NULL, info_, &addrlist_, &callback_, &req_);
     EXPECT_EQ(net::ERR_IO_PENDING, err);
   }
 
   ResolveRequest(net::HostResolver* resolver,
                  const net::HostResolver::RequestInfo& info,
                  Delegate* delegate)
       : info_(info), resolver_(resolver), delegate_(delegate),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             callback_(this, &ResolveRequest::OnLookupFinished)) {
     // Start the request.
-    int err = resolver->Resolve(info, &addrlist_, &callback_, &req_);
+    int err = resolver->Resolve(NULL, info, &addrlist_, &callback_, &req_);
     EXPECT_EQ(net::ERR_IO_PENDING, err);
   }
 
   void Cancel() {
     resolver_->CancelRequest(req_);
   }
 
   const std::string& hostname() const {
     return info_.hostname();
   }
@@ skipping 64 matching lines @@
   const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_refptr<net::HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
 
   net::HostResolver::RequestInfo info("just.testing", kPortnum);
-  int err = host_resolver->Resolve(info, &adrlist, NULL, NULL);
+  int err = host_resolver->Resolve(NULL, info, &adrlist, NULL, NULL);
   EXPECT_EQ(net::OK, err);
 
   const struct addrinfo* ainfo = adrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
   EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen);
 
   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, AsynchronousLookup) {
   net::AddressList adrlist;
   const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   scoped_refptr<net::HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
 
   net::HostResolver::RequestInfo info("just.testing", kPortnum);
-  int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL);
+  int err = host_resolver->Resolve(NULL, info, &adrlist, &callback_, NULL);
   EXPECT_EQ(net::ERR_IO_PENDING, err);
 
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(callback_called_);
   ASSERT_EQ(net::OK, callback_result_);
 
   const struct addrinfo* ainfo = adrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
   EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen);
 
   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);
 
   {
     scoped_refptr<net::HostResolver> host_resolver(
         new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
     net::AddressList adrlist;
     const int kPortnum = 80;
 
     net::HostResolver::RequestInfo info("just.testing", kPortnum);
-    int err = host_resolver->Resolve(info, &adrlist, &callback_, NULL);
+    int err = host_resolver->Resolve(NULL, info, &adrlist, &callback_, NULL);
     EXPECT_EQ(net::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_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("*");
 
   scoped_refptr<net::HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
   net::AddressList adrlist;
   const int kPortnum = 5555;
   net::HostResolver::RequestInfo info("127.1.2.3", kPortnum);
-  int err = host_resolver->Resolve(info, &adrlist, NULL, NULL);
+  int err = host_resolver->Resolve(NULL, info, &adrlist, NULL, NULL);
   EXPECT_EQ(net::OK, err);
 
   const struct addrinfo* ainfo = adrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
   EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen);
 
   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(0x7f010203) == sa_in->sin_addr.s_addr);
 }
 
 TEST_F(HostResolverImplTest, NumericIPv6Address) {
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AllowDirectLookup("*");
 
   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
   // the caller should have removed them.
   scoped_refptr<net::HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
   net::AddressList adrlist;
   const int kPortnum = 5555;
   net::HostResolver::RequestInfo info("2001:db8::1", kPortnum);
-  int err = host_resolver->Resolve(info, &adrlist, NULL, NULL);
+  int err = host_resolver->Resolve(NULL, info, &adrlist, NULL, NULL);
   // On computers without IPv6 support, getaddrinfo cannot convert IPv6
   // address literals to addresses (getaddrinfo returns EAI_NONAME).  So this
   // test has to allow host_resolver->Resolve to fail.
   if (err == net::ERR_NAME_NOT_RESOLVED)
     return;
   EXPECT_EQ(net::OK, err);
 
   const struct addrinfo* ainfo = adrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
   EXPECT_EQ(sizeof(struct sockaddr_in6), ainfo->ai_addrlen);
@@ skipping 19 matching lines @@
 TEST_F(HostResolverImplTest, DISABLED_EmptyHost) {
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
       new RuleBasedHostResolverProc(NULL);
   resolver_proc->AllowDirectLookup("*");
 
   scoped_refptr<net::HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, kMaxCacheEntries, kMaxCacheAgeMs));
   net::AddressList adrlist;
   const int kPortnum = 5555;
   net::HostResolver::RequestInfo info("", kPortnum);
-  int err = host_resolver->Resolve(info, &adrlist, NULL, NULL);
+  int err = host_resolver->Resolve(NULL, info, &adrlist, NULL, NULL);
   EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, err);
 }
 
 // Helper class used by HostResolverImplTest.DeDupeRequests. It receives request
 // completion notifications for all the resolves, so it can tally up and
 // determine when we are done.
 class DeDupeRequestsVerifier : public ResolveRequest::Delegate {
  public:
   explicit DeDupeRequestsVerifier(CapturingHostResolverProc* resolver_proc)
       : count_a_(0), count_b_(0), resolver_proc_(resolver_proc) {}
@@ skipping 330 matching lines @@
       // Since caching is enabled, this should complete synchronously.
 
       // Note that |junk_callback| shouldn't be used since we are going to
       // complete synchronously. We can't specify NULL though since that would
       // mean synchronous mode so we give it a value of 1.
       net::CompletionCallback* junk_callback =
           reinterpret_cast<net::CompletionCallback*> (1);
       net::AddressList addrlist;
 
       net::HostResolver::RequestInfo info("a", 70);
-      int error = resolver->Resolve(info, &addrlist, junk_callback, NULL);
+      int error = resolver->Resolve(NULL, info, &addrlist, junk_callback, NULL);
       EXPECT_EQ(net::OK, error);
 
       // Ok good. Now make sure that if we ask to bypass the cache, it can no
       // longer service the request synchronously.
       info = net::HostResolver::RequestInfo("a", 71);
       info.set_allow_cached_response(false);
       final_request_.reset(new ResolveRequest(resolver, info, this));
     } else if (71 == resolve->port()) {
       // Test is done.
       MessageLoop::current()->Quit();
@@ skipping 96 matching lines @@
       new HostResolverImpl(NULL, kMaxCacheEntries, kMaxCacheAgeMs));
 
   CapturingObserver observer;
 
   host_resolver->AddObserver(&observer);
 
   net::AddressList addrlist;
 
   // Resolve "host1".
   net::HostResolver::RequestInfo info1("host1", 70);
-  int rv = host_resolver->Resolve(info1, &addrlist, NULL, NULL);
+  int rv = host_resolver->Resolve(NULL, info1, &addrlist, NULL, NULL);
   EXPECT_EQ(net::OK, rv);
 
   EXPECT_EQ(1U, observer.start_log.size());
   EXPECT_EQ(1U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
   EXPECT_TRUE(observer.start_log[0] ==
               CapturingObserver::StartOrCancelEntry(0, info1));
   EXPECT_TRUE(observer.finish_log[0] ==
               CapturingObserver::FinishEntry(0, true, info1));
 
   // Resolve "host1" again -- this time it  will be served from cache, but it
   // should still notify of completion.
   TestCompletionCallback callback;
-  rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL);
+  rv = host_resolver->Resolve(NULL, info1, &addrlist, &callback, NULL);
   ASSERT_EQ(net::OK, rv);  // Should complete synchronously.
 
   EXPECT_EQ(2U, observer.start_log.size());
   EXPECT_EQ(2U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
   EXPECT_TRUE(observer.start_log[1] ==
               CapturingObserver::StartOrCancelEntry(1, info1));
   EXPECT_TRUE(observer.finish_log[1] ==
               CapturingObserver::FinishEntry(1, true, info1));
 
   // Resolve "host2", setting referrer to "http://foobar.com"
   net::HostResolver::RequestInfo info2("host2", 70);
   info2.set_referrer(GURL("http://foobar.com"));
-  rv = host_resolver->Resolve(info2, &addrlist, NULL, NULL);
+  rv = host_resolver->Resolve(NULL, info2, &addrlist, NULL, NULL);
   EXPECT_EQ(net::OK, rv);
 
   EXPECT_EQ(3U, observer.start_log.size());
   EXPECT_EQ(3U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
   EXPECT_TRUE(observer.start_log[2] ==
               CapturingObserver::StartOrCancelEntry(2, info2));
   EXPECT_TRUE(observer.finish_log[2] ==
               CapturingObserver::FinishEntry(2, true, info2));
 
   // Unregister the observer.
   host_resolver->RemoveObserver(&observer);
 
   // Resolve "host3"
   net::HostResolver::RequestInfo info3("host3", 70);
-  host_resolver->Resolve(info3, &addrlist, NULL, NULL);
+  host_resolver->Resolve(NULL, info3, &addrlist, NULL, NULL);
 
   // No effect this time, since observer was removed.
   EXPECT_EQ(3U, observer.start_log.size());
   EXPECT_EQ(3U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
 }
 
 // Tests that observers are sent OnCancelResolution() whenever a request is
 // cancelled. There are two ways to cancel a request:
 //  (1) Delete the HostResolver while job is outstanding.
 //  (2) Call HostResolver::CancelRequest() while a request is outstanding.
 TEST_F(HostResolverImplTest, CancellationObserver) {
   CapturingObserver observer;
   {
     // Create a host resolver and attach an observer.
     scoped_refptr<net::HostResolver> host_resolver(
         new HostResolverImpl(NULL, kMaxCacheEntries, kMaxCacheAgeMs));
     host_resolver->AddObserver(&observer);
 
     TestCompletionCallback callback;
 
     EXPECT_EQ(0U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(0U, observer.cancel_log.size());
 
     // Start an async resolve for (host1:70).
     net::HostResolver::RequestInfo info1("host1", 70);
     net::HostResolver::RequestHandle req = NULL;
     net::AddressList addrlist;
-    int rv = host_resolver->Resolve(info1, &addrlist, &callback, &req);
+    int rv = host_resolver->Resolve(NULL, info1, &addrlist, &callback, &req);
     EXPECT_EQ(net::ERR_IO_PENDING, rv);
     EXPECT_TRUE(NULL != req);
 
     EXPECT_EQ(1U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(0U, observer.cancel_log.size());
 
     EXPECT_TRUE(observer.start_log[0] ==
                 CapturingObserver::StartOrCancelEntry(0, info1));
 
     // Cancel the request.
     host_resolver->CancelRequest(req);
 
     EXPECT_EQ(1U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(1U, observer.cancel_log.size());
 
     EXPECT_TRUE(observer.cancel_log[0] ==
                 CapturingObserver::StartOrCancelEntry(0, info1));
 
     // Start an async request for (host2:60)
     net::HostResolver::RequestInfo info2("host2", 60);
-    rv = host_resolver->Resolve(info2, &addrlist, &callback, NULL);
+    rv = host_resolver->Resolve(NULL, info2, &addrlist, &callback, NULL);
     EXPECT_EQ(net::ERR_IO_PENDING, rv);
     EXPECT_TRUE(NULL != req);
 
     EXPECT_EQ(2U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(1U, observer.cancel_log.size());
 
     EXPECT_TRUE(observer.start_log[1] ==
                 CapturingObserver::StartOrCancelEntry(1, info2));
 
     // Upon exiting this scope, HostResolver is destroyed, so all requests are
     // implicitly cancelled.
   }
 
   // Check that destroying the HostResolver sent a notification for
   // cancellation of host2:60 request.
 
   EXPECT_EQ(2U, observer.start_log.size());
   EXPECT_EQ(0U, observer.finish_log.size());
   EXPECT_EQ(2U, observer.cancel_log.size());
 
   net::HostResolver::RequestInfo info("host2", 60);
   EXPECT_TRUE(observer.cancel_log[1] ==
               CapturingObserver::StartOrCancelEntry(1, info));
 }
 
 }  // namespace