* Move the global "DnsResolutionObserver" code depended on by DNS prefetcher,...

net/base/host_resolver_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.h"
 
 #if defined(OS_WIN)
 #include <ws2tcpip.h>
 #include <wspiapi.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #endif
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
+#include "net/base/dns_resolution_observer.h"
 #include "net/base/host_resolver_unittest.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::RuleBasedHostMapper;
 using net::ScopedHostMapper;
 using net::WaitingHostMapper;
 
 // TODO(eroman):
 //  - Test mixing async with sync (in particular how does sync update the
@@ skipping 44 matching lines @@
   class Delegate {
    public:
     virtual ~Delegate() {}
     virtual void OnCompleted(ResolveRequest* resolve) = 0;
   };
 
   ResolveRequest(net::HostResolver* resolver,
                  const std::string& hostname,
                  int port,
                  Delegate* delegate)
-      : hostname_(hostname), port_(port), resolver_(resolver),
-        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(hostname, port, &addrlist_, &callback_, &req_);
+    int err = resolver->Resolve(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_);
     EXPECT_EQ(net::ERR_IO_PENDING, err);
   }
 
   void Cancel() {
     resolver_->CancelRequest(req_);
   }
 
   const std::string& hostname() const {
-    return hostname_;
+    return info_.hostname();
   }
 
   int port() const {
-    return port_;
+    return info_.port();
   }
 
   int result() const {
     return result_;
   }
 
   const net::AddressList& addrlist() const {
     return addrlist_;
   }
 
   net::HostResolver* resolver() const {
     return resolver_;
   }
 
  private:
   void OnLookupFinished(int result) {
     result_ = result;
     delegate_->OnCompleted(this);
   }
 
   // The request details.
-  std::string hostname_;
-  int port_;
+  net::HostResolver::RequestInfo info_;
   net::HostResolver::Request* req_;
 
   // The result of the resolve.
   int result_;
   net::AddressList addrlist_;
 
   net::HostResolver* resolver_;
 
   Delegate* delegate_;
   net::CompletionCallbackImpl<ResolveRequest> callback_;
@@ skipping 24 matching lines @@
 
 TEST_F(HostResolverTest, SynchronousLookup) {
   net::HostResolver host_resolver;
   net::AddressList adrlist;
   const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostMapper> mapper = new RuleBasedHostMapper();
   mapper->AddRule("just.testing", "192.168.1.42");
   ScopedHostMapper scoped_mapper(mapper.get());
 
-  int err = host_resolver.Resolve("just.testing", kPortnum, &adrlist, NULL,
-                                  NULL);
+  net::HostResolver::RequestInfo info("just.testing", kPortnum);
+  int err = host_resolver.Resolve(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(HostResolverTest, AsynchronousLookup) {
   net::HostResolver host_resolver;
   net::AddressList adrlist;
   const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostMapper> mapper = new RuleBasedHostMapper();
   mapper->AddRule("just.testing", "192.168.1.42");
   ScopedHostMapper scoped_mapper(mapper.get());
 
-  int err = host_resolver.Resolve("just.testing", kPortnum, &adrlist,
-                                  &callback_, NULL);
+  net::HostResolver::RequestInfo info("just.testing", kPortnum);
+  int err = host_resolver.Resolve(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(HostResolverTest, CanceledAsynchronousLookup) {
   scoped_refptr<WaitingHostMapper> mapper = new WaitingHostMapper();
   ScopedHostMapper scoped_mapper(mapper.get());
 
   {
     net::HostResolver host_resolver;
     net::AddressList adrlist;
     const int kPortnum = 80;
 
-    int err = host_resolver.Resolve("just.testing", kPortnum, &adrlist,
-                                    &callback_, NULL);
+    net::HostResolver::RequestInfo info("just.testing", kPortnum);
+    int err = host_resolver.Resolve(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();
   }
 
   mapper->Signal();
 
   EXPECT_FALSE(callback_called_);
 }
 
 TEST_F(HostResolverTest, NumericIPv4Address) {
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
 
   scoped_refptr<RuleBasedHostMapper> mapper = new RuleBasedHostMapper();
   mapper->AllowDirectLookup("*");
   ScopedHostMapper scoped_mapper(mapper.get());
 
   net::HostResolver host_resolver;
   net::AddressList adrlist;
   const int kPortnum = 5555;
-  int err = host_resolver.Resolve("127.1.2.3", kPortnum, &adrlist, NULL, NULL);
+  net::HostResolver::RequestInfo info("127.1.2.3", kPortnum);
+  int err = host_resolver.Resolve(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(HostResolverTest, NumericIPv6Address) {
   scoped_refptr<RuleBasedHostMapper> mapper = new RuleBasedHostMapper();
   mapper->AllowDirectLookup("*");
   ScopedHostMapper scoped_mapper(mapper.get());
 
   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
   // the caller should have removed them.
   net::HostResolver host_resolver;
   net::AddressList adrlist;
   const int kPortnum = 5555;
-  int err = host_resolver.Resolve("2001:db8::1", kPortnum, &adrlist, NULL,
-                                  NULL);
+  net::HostResolver::RequestInfo info("2001:db8::1", kPortnum);
+  int err = host_resolver.Resolve(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 12 matching lines @@
 }
 
 TEST_F(HostResolverTest, EmptyHost) {
   scoped_refptr<RuleBasedHostMapper> mapper = new RuleBasedHostMapper();
   mapper->AllowDirectLookup("*");
   ScopedHostMapper scoped_mapper(mapper.get());
 
   net::HostResolver host_resolver;
   net::AddressList adrlist;
   const int kPortnum = 5555;
-  int err = host_resolver.Resolve("", kPortnum, &adrlist, NULL, NULL);
+  net::HostResolver::RequestInfo info("", kPortnum);
+  int err = host_resolver.Resolve(info, &adrlist, NULL, NULL);
   EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, err);
 }
 
 // Helper class used by HostResolverTest.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(CapturingHostMapper* mapper)
       : count_a_(0), count_b_(0), mapper_(mapper) {}
@@ skipping 134 matching lines @@
     // in the job and start another request.
     if (80 == resolve->port()) {
       EXPECT_EQ("a", resolve->hostname());
 
       req_to_cancel1_->Cancel();
       req_to_cancel2_->Cancel();
 
       // Start a request (so we can make sure the canceled requests don't
       // complete before "finalrequest" finishes.
       final_request_.reset(new ResolveRequest(
-        resolve->resolver(), "finalrequest", 70, this));
+          resolve->resolver(), "finalrequest", 70, this));
 
     } else if (83 == resolve->port()) {
       EXPECT_EQ("a", resolve->hostname());
     } else if (resolve->hostname() == "finalrequest") {
       EXPECT_EQ(70, resolve->addrlist().GetPort());
 
       // End this test, we are done.
       MessageLoop::current()->Quit();
     } else {
       FAIL() << "Unexpected completion: " << resolve->hostname() << ", "
@@ skipping 140 matching lines @@
   ResolveRequest req3(&host_resolver, "a", 82, &verifier);
   ResolveRequest req4(&host_resolver, "a", 83, &verifier);
 
   // Ready, Set, GO!!!
   mapper->Signal();
 
   // |verifier| will send quit message once all the requests have finished.
   MessageLoop::current()->Run();
 }
 
+// Helper class used by HostResolverTest.BypassCache.
+class BypassCacheVerifier : public ResolveRequest::Delegate {
+ public:
+  BypassCacheVerifier() {}
+
+  virtual void OnCompleted(ResolveRequest* resolve) {
+    EXPECT_EQ("a", resolve->hostname());
+    net::HostResolver* resolver = resolve->resolver();
+
+    if (80 == resolve->port()) {
+      // On completing the first request, start another request for "a".
+      // 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);
+      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();
+    } else {
+      FAIL() << "Unexpected port number";
+    }
+  }
+
+ private:
+  scoped_ptr<ResolveRequest> final_request_;
+  DISALLOW_COPY_AND_ASSIGN(BypassCacheVerifier);
+};
+
+TEST_F(HostResolverTest, BypassCache) {
+  net::HostResolver host_resolver;
+
+  // The class will receive callbacks for when each resolve completes. It
+  // checks that the right things happened.
+  BypassCacheVerifier verifier;
+
+  // Start a request.
+  ResolveRequest req1(&host_resolver, "a", 80, &verifier);
+
+  // |verifier| will send quit message once all the requests have finished.
+  MessageLoop::current()->Run();
+}
+
+bool operator==(const net::HostResolver::RequestInfo& a,
+                const net::HostResolver::RequestInfo& b) {
+   return a.hostname() == b.hostname() &&
+          a.port() == b.port() &&
+          a.allow_cached_response() == b.allow_cached_response() &&
+          a.is_speculative() == b.is_speculative() &&
+          a.referrer() == b.referrer();
+}
+
+// Observer that just makes note of how it was called. The test code can then
+// inspect to make sure it was called with the right parameters.
+class CapturingObserver : public net::DnsResolutionObserver {
+ public:
+  // DnsResolutionObserver methods:
+  virtual void OnStartResolution(int id,
+                                 const net::HostResolver::RequestInfo& info) {
+    start_log.push_back(StartEntry(id, info));
+  }
+
+  virtual void OnFinishResolutionWithStatus(
+      int id,
+      bool was_resolved,
+      const net::HostResolver::RequestInfo& info) {
+    finish_log.push_back(FinishEntry(id, was_resolved, info));
+  }
+
+  // Tuple (id, info).
+  struct StartEntry {
+    StartEntry(int id, const net::HostResolver::RequestInfo& info)
+        : id(id), info(info) {}
+
+    bool operator==(const StartEntry& other) const {
+      return id == other.id && info == other.info;
+    }
+
+    int id;
+    net::HostResolver::RequestInfo info;
+  };
+
+  // Tuple (id, was_resolved, info).
+  struct FinishEntry {
+    FinishEntry(int id, bool was_resolved,
+                const net::HostResolver::RequestInfo& info)
+        : id(id), was_resolved(was_resolved), info(info) {}
+
+    bool operator==(const FinishEntry& other) const {
+      return id == other.id &&
+             was_resolved == other.was_resolved &&
+             info == other.info;
+    }
+
+    int id;
+    bool was_resolved;
+    net::HostResolver::RequestInfo info;
+  };
+
+  std::vector<StartEntry> start_log;
+  std::vector<FinishEntry> finish_log;
+};
+
+// Test that registering, unregistering, and notifying of observers works.
+TEST_F(HostResolverTest, Observers) {
+  net::HostResolver host_resolver;
+
+  CapturingObserver observer;
+
+  host_resolver.AddObserver(&observer);
+
+  net::AddressList addrlist;
+
+  // Resolve "host1".
+  net::HostResolver::RequestInfo info1("host1", 70);
+  host_resolver.Resolve(info1, &addrlist, NULL, NULL);
+
+  EXPECT_EQ(1U, observer.start_log.size());
+  EXPECT_EQ(1U, observer.finish_log.size());
+  EXPECT_TRUE(
+      observer.start_log[0] == CapturingObserver::StartEntry(0, info1));
+  EXPECT_TRUE(
+      observer.finish_log[0] == CapturingObserver::FinishEntry(0, true, info1));
+
+  // Resolve "host2", setting referrer to "http://foobar.com"
+  net::HostResolver::RequestInfo info2("host2", 70);
+  info2.set_referrer(GURL("http://foobar.com"));
+  host_resolver.Resolve(info2, &addrlist, NULL, NULL);
+
+  EXPECT_EQ(2U, observer.start_log.size());
+  EXPECT_EQ(2U, observer.finish_log.size());
+  EXPECT_TRUE(observer.start_log[1] == CapturingObserver::StartEntry(1, info2));
+  EXPECT_TRUE(observer.finish_log[1] == CapturingObserver::FinishEntry(
+      1, true, info2));
+
+  // Unregister the observer.
+  host_resolver.RemoveObserver(&observer);
+
+  // Resolve "host3"
+  net::HostResolver::RequestInfo info3("host3", 70);
+  host_resolver.Resolve(info3, &addrlist, NULL, NULL);
+
+  // No effect this time, since observer was removed.
+  EXPECT_EQ(2U, observer.start_log.size());
+  EXPECT_EQ(2U, observer.finish_log.size());
+}
+
 }  // namespace