Add an additional per-request DNS cache when executing FindProxyForURL() from...

net/proxy/proxy_resolver_js_bindings_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 "base/scoped_ptr.h"
 #include "net/base/address_list.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
+#include "net/proxy/proxy_resolver_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 // This is a HostResolver that synchronously resolves all hosts to the
 // following address list of length 3:
 //     192.168.1.1
 //     172.22.34.1
 //     200.100.1.2
@@ skipping 48 matching lines @@
     AddressList concatenated;
     concatenated.Copy(result.head(), true);
 
     // Restore |result| (so it is freed properly).
     result_head->ai_next = NULL;
 
     return concatenated;
   }
 };
 
+class MockFailingHostResolver : public HostResolver {
+ public:
+  MockFailingHostResolver() : count_(0) {}
+
+  // HostResolver methods:
+  virtual int Resolve(const RequestInfo& info,
+                      AddressList* addresses,
+                      CompletionCallback* callback,
+                      RequestHandle* out_req,
+                      const BoundNetLog& net_log) {
+    count_++;
+    return ERR_NAME_NOT_RESOLVED;
+  }
+
+  virtual void CancelRequest(RequestHandle req) {}
+  virtual void AddObserver(Observer* observer) {}
+  virtual void RemoveObserver(Observer* observer) {}
+  virtual void Shutdown() {}
+
+  // Returns the number of times Resolve() has been called.
+  int count() const { return count_; }
+  void ResetCount() { count_ = 0; }
+
+ private:
+  int count_;
+};
+
 TEST(ProxyResolverJSBindingsTest, DnsResolve) {
   scoped_refptr<MockHostResolver> host_resolver(new MockHostResolver);
 
   // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
   scoped_ptr<ProxyResolverJSBindings> bindings(
       ProxyResolverJSBindings::CreateDefault(host_resolver));
 
   // Empty string is not considered a valid host (even though on some systems
   // requesting this will resolve to localhost).
   host_resolver->rules()->AddSimulatedFailure("");
@@ skipping 88 matching lines @@
   scoped_ptr<ProxyResolverJSBindings> bindings(
       ProxyResolverJSBindings::CreateDefault(host_resolver));
 
   EXPECT_EQ("192.168.1.1;172.22.34.1;200.100.1.2",
             bindings->MyIpAddressEx());
 
   EXPECT_EQ("192.168.1.1;172.22.34.1;200.100.1.2",
             bindings->DnsResolveEx("FOO"));
 }
 
+TEST(ProxyResolverJSBindingsTest, PerRequestDNSCache) {
+  scoped_refptr<MockFailingHostResolver> host_resolver(
+      new MockFailingHostResolver);
+
+  // Get a hold of a DefaultJSBindings* (it is a hidden impl class).
+  scoped_ptr<ProxyResolverJSBindings> bindings(
+      ProxyResolverJSBindings::CreateDefault(host_resolver));
+
+  // Call DnsResolve() 4 times for the same hostname -- this should issue
+  // 4 separate calls to the underlying host resolver, since there is no
+  // current request context.
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ(4, host_resolver->count());
+
+  host_resolver->ResetCount();
+
+  // Now setup a per-request context, and try the same experiment -- we
+  // expect the underlying host resolver to receive only 1 request this time,
+  // since it will service the others from the per-request DNS cache.
+  HostCache cache(50,
+                  base::TimeDelta::FromMinutes(10),
+                  base::TimeDelta::FromMinutes(10));
+  ProxyResolverRequestContext context(NULL, NULL, &cache);
+  bindings->set_current_request_context(&context);
+
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ("", bindings->DnsResolve("foo"));
+  EXPECT_EQ(1, host_resolver->count());
+
+  host_resolver->ResetCount();
+
+  // The "Ex" version shares this same cache, however since the flags
+  // are different it won't reuse this particular entry.
+  EXPECT_EQ("", bindings->DnsResolveEx("foo"));
+  EXPECT_EQ(1, host_resolver->count());
+  EXPECT_EQ("", bindings->DnsResolveEx("foo"));
+  EXPECT_EQ("", bindings->DnsResolveEx("foo"));
+  EXPECT_EQ(1, host_resolver->count());
+
+  bindings->set_current_request_context(NULL);
+}
+
 }  // namespace
 }  // namespace net