base::Bind: Convert net/proxy.

net/proxy/proxy_resolver_v8_unittest.cc

 // Copyright (c) 2011 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"
@@ skipping 97 matching lines @@
     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),
-                        NULL);
+                        CompletionCallback());
   }
 };
 
 // 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(CapturingNetLog::kUnbounded);
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   log.bound());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, log.bound());
 
   EXPECT_EQ(OK, result);
   EXPECT_TRUE(proxy_info.is_direct());
 
   EXPECT_EQ(0U, resolver.mock_js_bindings()->alerts.size());
   EXPECT_EQ(0U, resolver.mock_js_bindings()->errors.size());
 
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   // No bindings were called, so no log entries.
   EXPECT_EQ(0u, entries.size());
 }
 
 TEST(ProxyResolverV8Test, ReturnEmptyString) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("return_empty_string.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_TRUE(proxy_info.is_direct());
 
   EXPECT_EQ(0U, resolver.mock_js_bindings()->alerts.size());
   EXPECT_EQ(0U, resolver.mock_js_bindings()->errors.size());
 }
 
 TEST(ProxyResolverV8Test, Basic) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("passthrough.js");
   EXPECT_EQ(OK, result);
 
   // The "FindProxyForURL" of this PAC script simply concatenates all of the
   // arguments into a pseudo-host. The purpose of this test is to verify that
   // the correct arguments are being passed to FindProxyForURL().
   {
     ProxyInfo proxy_info;
-    result = resolver.GetProxyForURL(GURL("http://query.com/path"),
-                                     &proxy_info, NULL, NULL, BoundNetLog());
+    result = resolver.GetProxyForURL(GURL("http://query.com/path"), &proxy_info,
+                                     CompletionCallback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, result);
     EXPECT_EQ("http.query.com.path.query.com:80",
               proxy_info.proxy_server().ToURI());
   }
   {
     ProxyInfo proxy_info;
-    int result = resolver.GetProxyForURL(GURL("ftp://query.com:90/path"),
-                                         &proxy_info, NULL, NULL,
-                                         BoundNetLog());
+    int result = resolver.GetProxyForURL(
+        GURL("ftp://query.com:90/path"), &proxy_info, CompletionCallback(),
+        NULL, BoundNetLog());
     EXPECT_EQ(OK, result);
     // Note that FindProxyForURL(url, host) does not expect |host| to contain
     // the port number.
     EXPECT_EQ("ftp.query.com.90.path.query.com:80",
               proxy_info.proxy_server().ToURI());
 
     EXPECT_EQ(0U, resolver.mock_js_bindings()->alerts.size());
     EXPECT_EQ(0U, resolver.mock_js_bindings()->errors.size());
   }
 
@@ skipping 17 matching lines @@
       // TODO(eroman): Should 'null' be considered equivalent to "DIRECT" ?
       "return_null.js"
   };
 
   for (size_t i = 0; i < arraysize(filenames); ++i) {
     ProxyResolverV8WithMockBindings resolver;
     int result = resolver.SetPacScriptFromDisk(filenames[i]);
     EXPECT_EQ(OK, result);
 
     ProxyInfo proxy_info;
-    result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                     BoundNetLog());
+    result = resolver.GetProxyForURL(
+        kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
     EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, result);
 
     MockJSBindings* bindings = resolver.mock_js_bindings();
     EXPECT_EQ(0U, bindings->alerts.size());
     ASSERT_EQ(1U, bindings->errors.size());
     EXPECT_EQ("FindProxyForURL() did not return a string.",
               bindings->errors[0]);
     EXPECT_EQ(-1, bindings->errors_line_number[0]);
   }
 }
 
 // Try using a PAC script which defines no "FindProxyForURL" function.
 TEST(ProxyResolverV8Test, NoEntryPoint) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("no_entrypoint.js");
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(ERR_FAILED, result);
 }
 
 // Try loading a malformed PAC script.
 TEST(ProxyResolverV8Test, ParseError) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("missing_close_brace.js");
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(ERR_FAILED, result);
 
   MockJSBindings* bindings = resolver.mock_js_bindings();
   EXPECT_EQ(0U, bindings->alerts.size());
 
   // We get one error during compilation.
   ASSERT_EQ(1U, bindings->errors.size());
 
   EXPECT_EQ("Uncaught SyntaxError: Unexpected end of input",
             bindings->errors[0]);
   EXPECT_EQ(0, bindings->errors_line_number[0]);
 }
 
 // Run a PAC script several times, which has side-effects.
 TEST(ProxyResolverV8Test, SideEffects) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("side_effects.js");
 
   // The PAC script increments a counter each time we invoke it.
   for (int i = 0; i < 3; ++i) {
     ProxyInfo proxy_info;
-    result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                     BoundNetLog());
+    result = resolver.GetProxyForURL(
+        kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, result);
     EXPECT_EQ(base::StringPrintf("sideffect_%d:80", i),
               proxy_info.proxy_server().ToURI());
   }
 
   // Reload the script -- the javascript environment should be reset, hence
   // the counter starts over.
   result = resolver.SetPacScriptFromDisk("side_effects.js");
   EXPECT_EQ(OK, result);
 
   for (int i = 0; i < 3; ++i) {
     ProxyInfo proxy_info;
-    result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                     BoundNetLog());
+    result = resolver.GetProxyForURL(
+        kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
     EXPECT_EQ(OK, result);
     EXPECT_EQ(base::StringPrintf("sideffect_%d:80", i),
               proxy_info.proxy_server().ToURI());
   }
 }
 
 // Execute a PAC script which throws an exception in FindProxyForURL.
 TEST(ProxyResolverV8Test, UnhandledException) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("unhandled_exception.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, result);
 
   MockJSBindings* bindings = resolver.mock_js_bindings();
   EXPECT_EQ(0U, bindings->alerts.size());
   ASSERT_EQ(1U, bindings->errors.size());
   EXPECT_EQ("Uncaught ReferenceError: undefined_variable is not defined",
             bindings->errors[0]);
   EXPECT_EQ(3, bindings->errors_line_number[0]);
 }
 
 TEST(ProxyResolverV8Test, ReturnUnicode) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("return_unicode.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   // The result from this resolve was unparseable, because it
   // wasn't ASCII.
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, result);
 }
 
-// Test the PAC library functions that we expose in the JS environmnet.
+// Test the PAC library functions that we expose in the JS environment.
 TEST(ProxyResolverV8Test, JavascriptLibrary) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("pac_library_unittest.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   // If the javascript side of this unit-test fails, it will throw a javascript
   // exception. Otherwise it will return "PROXY success:80".
   EXPECT_EQ(OK, result);
   EXPECT_EQ("success:80", proxy_info.proxy_server().ToURI());
 
   EXPECT_EQ(0U, resolver.mock_js_bindings()->alerts.size());
   EXPECT_EQ(0U, resolver.mock_js_bindings()->errors.size());
 }
 
 // Try resolving when SetPacScriptByData() has not been called.
 TEST(ProxyResolverV8Test, NoSetPacScript) {
   ProxyResolverV8WithMockBindings resolver;
 
   ProxyInfo proxy_info;
 
   // Resolve should fail, as we are not yet initialized with a script.
-  int result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                       BoundNetLog());
+  int result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_FAILED, result);
 
   // Initialize it.
   result = resolver.SetPacScriptFromDisk("direct.js");
   EXPECT_EQ(OK, result);
 
   // Resolve should now succeed.
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, result);
 
   // Clear it, by initializing with an empty string.
   resolver.SetPacScript(
-      ProxyResolverScriptData::FromUTF16(string16()), NULL);
+      ProxyResolverScriptData::FromUTF16(string16()), CompletionCallback());
 
   // Resolve should fail again now.
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_FAILED, result);
 
   // Load a good script once more.
   result = resolver.SetPacScriptFromDisk("direct.js");
   EXPECT_EQ(OK, result);
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
   EXPECT_EQ(OK, result);
 
   EXPECT_EQ(0U, resolver.mock_js_bindings()->alerts.size());
   EXPECT_EQ(0U, resolver.mock_js_bindings()->errors.size());
 }
 
 // Test marshalling/un-marshalling of values between C++/V8.
 TEST(ProxyResolverV8Test, V8Bindings) {
   ProxyResolverV8WithMockBindings resolver;
   MockJSBindings* bindings = resolver.mock_js_bindings();
   bindings->dns_resolve_result = "127.0.0.1";
   int result = resolver.SetPacScriptFromDisk("bindings.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_TRUE(proxy_info.is_direct());
 
   EXPECT_EQ(0U, resolver.mock_js_bindings()->errors.size());
 
   // Alert was called 5 times.
   ASSERT_EQ(5U, bindings->alerts.size());
   EXPECT_EQ("undefined", bindings->alerts[0]);
   EXPECT_EQ("null", bindings->alerts[1]);
@@ skipping 26 matching lines @@
 
   int result = resolver.SetPacScriptFromDisk("binding_from_global.js");
   EXPECT_EQ(OK, result);
 
   MockJSBindings* bindings = resolver.mock_js_bindings();
 
   // myIpAddress() got called during initialization of the script.
   EXPECT_EQ(1, bindings->my_ip_address_count);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_FALSE(proxy_info.is_direct());
   EXPECT_EQ("127.0.0.1:80", proxy_info.proxy_server().ToURI());
 
   // Check that no other bindings were called.
   EXPECT_EQ(0U, bindings->errors.size());
   ASSERT_EQ(0U, bindings->alerts.size());
   ASSERT_EQ(0U, bindings->dns_resolves.size());
   EXPECT_EQ(0, bindings->my_ip_address_ex_count);
   ASSERT_EQ(0U, bindings->dns_resolves_ex.size());
 }
 
 // Try loading a PAC script that ends with a comment and has no terminal
 // newline. This should not cause problems with the PAC utility functions
 // that we add to the script's environment.
 // http://crbug.com/22864
 TEST(ProxyResolverV8Test, EndsWithCommentNoNewline) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("ends_with_comment.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   log.bound());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, log.bound());
 
   EXPECT_EQ(OK, result);
   EXPECT_FALSE(proxy_info.is_direct());
   EXPECT_EQ("success:80", proxy_info.proxy_server().ToURI());
 }
 
 // Try loading a PAC script that ends with a statement and has no terminal
 // newline. This should not cause problems with the PAC utility functions
 // that we add to the script's environment.
 // http://crbug.com/22864
 TEST(ProxyResolverV8Test, EndsWithStatementNoNewline) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk(
       "ends_with_statement_no_semicolon.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   log.bound());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, log.bound());
 
   EXPECT_EQ(OK, result);
   EXPECT_FALSE(proxy_info.is_direct());
   EXPECT_EQ("success:3", proxy_info.proxy_server().ToURI());
 }
 
 // Test the return values from myIpAddress(), myIpAddressEx(), dnsResolve(),
 // dnsResolveEx(), isResolvable(), isResolvableEx(), when the the binding
 // returns empty string (failure). This simulates the return values from
 // those functions when the underlying DNS resolution fails.
 TEST(ProxyResolverV8Test, DNSResolutionFailure) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("dns_fail.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_FALSE(proxy_info.is_direct());
   EXPECT_EQ("success:80", proxy_info.proxy_server().ToURI());
 }
 
 TEST(ProxyResolverV8Test, DNSResolutionOfInternationDomainName) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("international_domain_names.js");
   EXPECT_EQ(OK, result);
 
   // Execute FindProxyForURL().
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(kQueryUrl, &proxy_info, NULL, NULL,
-                                   BoundNetLog());
+  result = resolver.GetProxyForURL(
+      kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_TRUE(proxy_info.is_direct());
 
   // Check that the international domain name was converted to punycode
   // before passing it onto the bindings layer.
   MockJSBindings* bindings = resolver.mock_js_bindings();
 
   ASSERT_EQ(1u, bindings->dns_resolves.size());
   EXPECT_EQ("xn--bcher-kva.ch", bindings->dns_resolves[0]);
 
   ASSERT_EQ(1u, bindings->dns_resolves_ex.size());
   EXPECT_EQ("xn--bcher-kva.ch", bindings->dns_resolves_ex[0]);
 }
 
 }  // namespace
 }  // namespace net