Improve performance of proxy resolver by tracing DNS dependencies.

net/proxy/proxy_resolver_v8_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 "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/proxy/proxy_info.h"
-#include "net/proxy/proxy_resolver_js_bindings.h"
 #include "net/proxy/proxy_resolver_v8.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 // Javascript bindings for ProxyResolverV8, which returns mock values.
 // Each time one of the bindings is called into, we push the input into a
 // list, for later verification.
-class MockJSBindings : public ProxyResolverJSBindings {
+class MockJSBindings : public ProxyResolverV8::JSBindings {
  public:
   MockJSBindings() : my_ip_address_count(0), my_ip_address_ex_count(0) {}
 
   virtual void Alert(const string16& message) OVERRIDE {
     VLOG(1) << "PAC-alert: " << message;  // Helpful when debugging.
     alerts.push_back(UTF16ToUTF8(message));
   }
 
-  virtual bool MyIpAddress(std::string* ip_address) OVERRIDE {
-    my_ip_address_count++;
-    *ip_address = my_ip_address_result;
-    return !my_ip_address_result.empty();
-  }
+  virtual bool ResolveDns(const std::string& host,
+                          ResolveDnsOperation op,
+                          std::string* output) OVERRIDE {
+    if (op == MY_IP_ADDRESS) {
+      my_ip_address_count++;
+      *output = my_ip_address_result;
+      return !my_ip_address_result.empty();
+    }
 
-  virtual bool MyIpAddressEx(std::string* ip_address_list) OVERRIDE {
-    my_ip_address_ex_count++;
-    *ip_address_list = my_ip_address_ex_result;
-    return !my_ip_address_ex_result.empty();
-  }
+    if (op == MY_IP_ADDRESS_EX) {
+      my_ip_address_ex_count++;
+      *output = my_ip_address_ex_result;
+      return !my_ip_address_ex_result.empty();
+    }
 
-  virtual bool DnsResolve(const std::string& host, std::string* ip_address)
-      OVERRIDE {
-    dns_resolves.push_back(host);
-    *ip_address = dns_resolve_result;
-    return !dns_resolve_result.empty();
-  }
+    if (op == DNS_RESOLVE) {
+      dns_resolves.push_back(host);
+      *output = dns_resolve_result;
+      return !dns_resolve_result.empty();
+    }
 
-  virtual bool DnsResolveEx(const std::string& host,
-                            std::string* ip_address_list) OVERRIDE {
-    dns_resolves_ex.push_back(host);
-    *ip_address_list = dns_resolve_ex_result;
-    return !dns_resolve_ex_result.empty();
+    if (op == DNS_RESOLVE_EX) {
+      dns_resolves_ex.push_back(host);
+      *output = dns_resolve_ex_result;
+      return !dns_resolve_ex_result.empty();
+    }
+
+    CHECK(false);
+    return false;
   }
 
   virtual void OnError(int line_number, const string16& message) OVERRIDE {
     // Helpful when debugging.
     VLOG(1) << "PAC-error: [" << line_number << "] " << message;
 
     errors.push_back(UTF16ToUTF8(message));
     errors_line_number.push_back(line_number);
   }
 
-  virtual void Shutdown() OVERRIDE {}
-
   // Mock values to return.
   std::string my_ip_address_result;
   std::string my_ip_address_ex_result;
   std::string dns_resolve_result;
   std::string dns_resolve_ex_result;
 
   // Inputs we got called with.
   std::vector<std::string> alerts;
   std::vector<std::string> errors;
   std::vector<int> errors_line_number;
   std::vector<std::string> dns_resolves;
   std::vector<std::string> dns_resolves_ex;
   int my_ip_address_count;
   int my_ip_address_ex_count;
 };
 
 // This is the same as ProxyResolverV8, but it uses mock bindings in place of
 // the default bindings, and has a helper function to load PAC scripts from
 // disk.
 class ProxyResolverV8WithMockBindings : public ProxyResolverV8 {
  public:
-  ProxyResolverV8WithMockBindings() : ProxyResolverV8(new MockJSBindings()) {}
+  ProxyResolverV8WithMockBindings() {
+    set_js_bindings(&mock_js_bindings_);
+  }
 
-  MockJSBindings* mock_js_bindings() const {
-    return reinterpret_cast<MockJSBindings*>(js_bindings());
+  MockJSBindings* mock_js_bindings() {
+    return &mock_js_bindings_;
   }
 
   // Initialize with the PAC script data at |filename|.
   int SetPacScriptFromDisk(const char* filename) {
     FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     path = path.AppendASCII("net");
     path = path.AppendASCII("data");
     path = path.AppendASCII("proxy_resolver_v8_unittest");
     path = path.AppendASCII(filename);
 
     // Try to read the file from disk.
     std::string file_contents;
     bool ok = file_util::ReadFileToString(path, &file_contents);
 
     // If we can't load the file from disk, something is misconfigured.
     if (!ok) {
       LOG(ERROR) << "Failed to read file: " << path.value();
       return ERR_UNEXPECTED;
     }
 
     // Load the PAC script into the ProxyResolver.
     return SetPacScript(ProxyResolverScriptData::FromUTF8(file_contents),
                         CompletionCallback());
   }
+
+ private:
+  MockJSBindings mock_js_bindings_;
 };
 
 // Doesn't really matter what these values are for many of the tests.
 const GURL kQueryUrl("http://www.google.com");
 const GURL kPacUrl;
 
-
 TEST(ProxyResolverV8Test, Direct) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("direct.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
   CapturingBoundNetLog log;
   result = resolver.GetProxyForURL(
       kQueryUrl, &proxy_info, CompletionCallback(), NULL, log.bound());
 
@@ skipping 425 matching lines @@
   EXPECT_TRUE(proxy_info.is_direct());
 
   // We called dnsResolveEx() exactly once, by passing through the "host"
   // argument to FindProxyForURL(). The brackets should have been stripped.
   ASSERT_EQ(1U, resolver.mock_js_bindings()->dns_resolves_ex.size());
   EXPECT_EQ("abcd::efff", resolver.mock_js_bindings()->dns_resolves_ex[0]);
 }
 
 }  // namespace
 }  // namespace net