Clang format slam.

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/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.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_v8.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.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 ProxyResolverV8::JSBindings {
  public:
-  MockJSBindings() : my_ip_address_count(0), my_ip_address_ex_count(0),
-                     should_terminate(false) {}
+  MockJSBindings()
+      : my_ip_address_count(0),
+        my_ip_address_ex_count(0),
+        should_terminate(false) {}
 
   virtual void Alert(const base::string16& message) OVERRIDE {
     VLOG(1) << "PAC-alert: " << message;  // Helpful when debugging.
     alerts.push_back(base::UTF16ToUTF8(message));
   }
 
   virtual bool ResolveDns(const std::string& host,
                           ResolveDnsOperation op,
                           std::string* output,
                           bool* terminate) OVERRIDE {
@@ skipping 53 matching lines @@
 
   // Whether ResolveDns() should terminate script execution.
   bool should_terminate;
 };
 
 // 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() {
-    set_js_bindings(&mock_js_bindings_);
-  }
+  ProxyResolverV8WithMockBindings() { set_js_bindings(&mock_js_bindings_); }
 
-  virtual ~ProxyResolverV8WithMockBindings() {
-  }
+  virtual ~ProxyResolverV8WithMockBindings() {}
 
-  MockJSBindings* mock_js_bindings() {
-    return &mock_js_bindings_;
-  }
+  MockJSBindings* mock_js_bindings() { return &mock_js_bindings_; }
 
   // Initialize with the PAC script data at |filename|.
   int SetPacScriptFromDisk(const char* filename) {
     base::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);
 
@@ skipping 61 matching lines @@
 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,
-                                     CompletionCallback(), 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, CompletionCallback(),
-        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());
   }
 }
 
 TEST(ProxyResolverV8Test, BadReturnType) {
   // These are the filenames of PAC scripts which each return a non-string
   // types for FindProxyForURL(). They should all fail with
   // ERR_PAC_SCRIPT_FAILED.
   static const char* const filenames[] = {
-      "return_undefined.js",
-      "return_integer.js",
-      "return_function.js",
+      "return_undefined.js", "return_integer.js", "return_function.js",
       "return_object.js",
       // TODO(eroman): Should 'null' be considered equivalent to "DIRECT" ?
-      "return_null.js"
-  };
+      "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, CompletionCallback(), NULL, BoundNetLog());
 
@@ skipping 141 matching lines @@
   // Initialize it.
   result = resolver.SetPacScriptFromDisk("direct.js");
   EXPECT_EQ(OK, result);
 
   // Resolve should now succeed.
   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(base::string16()),
-      CompletionCallback());
+  resolver.SetPacScript(ProxyResolverScriptData::FromUTF16(base::string16()),
+                        CompletionCallback());
 
   // Resolve should fail again now.
   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(
@@ skipping 93 matching lines @@
   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");
+  int result =
+      resolver.SetPacScriptFromDisk("ends_with_statement_no_semicolon.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
   result = resolver.GetProxyForURL(
       kQueryUrl, &proxy_info, CompletionCallback(), NULL, BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_FALSE(proxy_info.is_direct());
   EXPECT_EQ("success:3", proxy_info.proxy_server().ToURI());
 }
@@ skipping 43 matching lines @@
 // Test that when resolving a URL which contains an IPv6 string literal, the
 // brackets are removed from the host before passing it down to the PAC script.
 // If we don't do this, then subsequent calls to dnsResolveEx(host) will be
 // doomed to fail since it won't correspond with a valid name.
 TEST(ProxyResolverV8Test, IPv6HostnamesNotBracketed) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("resolve_host.js");
   EXPECT_EQ(OK, result);
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(
-      GURL("http://[abcd::efff]:99/watsupdawg"), &proxy_info,
-      CompletionCallback(), NULL, BoundNetLog());
+  result = resolver.GetProxyForURL(GURL("http://[abcd::efff]:99/watsupdawg"),
+                                   &proxy_info,
+                                   CompletionCallback(),
+                                   NULL,
+                                   BoundNetLog());
 
   EXPECT_EQ(OK, result);
   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]);
 }
 
 // Test that terminating a script within DnsResolve() leads to eventual
 // termination of the script. Also test that repeatedly calling terminate is
 // safe, and running the script again after termination still works.
 TEST(ProxyResolverV8Test, Terminate) {
   ProxyResolverV8WithMockBindings resolver;
   int result = resolver.SetPacScriptFromDisk("terminate.js");
   EXPECT_EQ(OK, result);
 
   MockJSBindings* bindings = resolver.mock_js_bindings();
 
   // Terminate script execution upon reaching dnsResolve(). Note that
   // termination may not take effect right away (so the subsequent dnsResolve()
   // and alert() may be run).
   bindings->should_terminate = true;
 
   ProxyInfo proxy_info;
-  result = resolver.GetProxyForURL(
-      GURL("http://hang/"), &proxy_info,
-      CompletionCallback(), NULL, BoundNetLog());
+  result = resolver.GetProxyForURL(GURL("http://hang/"),
+                                   &proxy_info,
+                                   CompletionCallback(),
+                                   NULL,
+                                   BoundNetLog());
 
   // The script execution was terminated.
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, result);
 
   EXPECT_EQ(1U, resolver.mock_js_bindings()->dns_resolves.size());
   EXPECT_GE(2U, resolver.mock_js_bindings()->dns_resolves_ex.size());
   EXPECT_GE(1U, bindings->alerts.size());
 
   EXPECT_EQ(1U, bindings->errors.size());
 
   // Termination shows up as an uncaught exception without any message.
   EXPECT_EQ("", bindings->errors[0]);
 
   bindings->errors.clear();
 
   // Try running the script again, this time with a different input which won't
   // cause a termination+hang.
-  result = resolver.GetProxyForURL(
-      GURL("http://kittens/"), &proxy_info,
-      CompletionCallback(), NULL, BoundNetLog());
+  result = resolver.GetProxyForURL(GURL("http://kittens/"),
+                                   &proxy_info,
+                                   CompletionCallback(),
+                                   NULL,
+                                   BoundNetLog());
 
   EXPECT_EQ(OK, result);
   EXPECT_EQ(0u, bindings->errors.size());
   EXPECT_EQ("kittens:88", proxy_info.proxy_server().ToURI());
 }
 
 }  // namespace
 }  // namespace net