Clang format slam.

net/proxy/proxy_resolver_perftest.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/base_paths.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/test/perf_time_logger.h"
@@ skipping 25 matching lines @@
 struct PacPerfTest {
   const char* pac_name;
   PacQuery queries[100];
 
   // Returns the actual number of entries in |queries| (assumes NULL sentinel).
   int NumQueries() const;
 };
 
 // List of performance tests.
 static PacPerfTest kPerfTests[] = {
-  // This test uses an ad-blocker PAC script. This script is very heavily
-  // regular expression oriented, and has no dependencies on the current
-  // IP address, or DNS resolving of hosts.
-  { "no-ads.pac",
-    { // queries:
+    // This test uses an ad-blocker PAC script. This script is very heavily
+    // regular expression oriented, and has no dependencies on the current
+    // IP address, or DNS resolving of hosts.
+    {
+     "no-ads.pac",
+     {// queries:
       {"http://www.google.com", "DIRECT"},
       {"http://www.imdb.com/photos/cmsicons/x", "PROXY 0.0.0.0:3421"},
       {"http://www.imdb.com/x", "DIRECT"},
       {"http://www.staples.com/", "DIRECT"},
       {"http://www.staples.com/pixeltracker/x", "PROXY 0.0.0.0:3421"},
       {"http://www.staples.com/pixel/x", "DIRECT"},
       {"http://www.foobar.com", "DIRECT"},
       {"http://www.foobarbaz.com/x/y/z", "DIRECT"},
       {"http://www.testurl1.com/index.html", "DIRECT"},
       {"http://www.testurl2.com", "DIRECT"},
       {"https://www.sample/pirate/arrrrrr", "DIRECT"},
-      {NULL, NULL}
+      {NULL, NULL}},
     },
-  },
 };
 
 int PacPerfTest::NumQueries() const {
   for (size_t i = 0; i < arraysize(queries); ++i) {
     if (queries[i].query_url == NULL)
       return i;
   }
   NOTREACHED();  // Bad definition.
   return 0;
 }
 
 // The number of URLs to resolve when testing a PAC script.
 const int kNumIterations = 500;
 
 // Helper class to run through all the performance tests using the specified
 // proxy resolver implementation.
 class PacPerfSuiteRunner {
  public:
   // |resolver_name| is the label used when logging the results.
   PacPerfSuiteRunner(net::ProxyResolver* resolver,
                      const std::string& resolver_name)
       : resolver_(resolver),
         resolver_name_(resolver_name),
-        test_server_(
-            net::SpawnedTestServer::TYPE_HTTP,
-            net::SpawnedTestServer::kLocalhost,
-            base::FilePath(
-                FILE_PATH_LITERAL("net/data/proxy_resolver_perftest"))) {
-  }
+        test_server_(net::SpawnedTestServer::TYPE_HTTP,
+                     net::SpawnedTestServer::kLocalhost,
+                     base::FilePath(FILE_PATH_LITERAL(
+                         "net/data/proxy_resolver_perftest"))) {}
 
   void RunAllTests() {
     ASSERT_TRUE(test_server_.Start());
     for (size_t i = 0; i < arraysize(kPerfTests); ++i) {
       const PacPerfTest& test_data = kPerfTests[i];
-      RunTest(test_data.pac_name,
-              test_data.queries,
-              test_data.NumQueries());
+      RunTest(test_data.pac_name, test_data.queries, test_data.NumQueries());
     }
   }
 
  private:
   void RunTest(const std::string& script_name,
                const PacQuery* queries,
                int queries_len) {
     if (!resolver_->expects_pac_bytes()) {
-      GURL pac_url =
-          test_server_.GetURL(std::string("files/") + script_name);
+      GURL pac_url = test_server_.GetURL(std::string("files/") + script_name);
       int rv = resolver_->SetPacScript(
           net::ProxyResolverScriptData::FromURL(pac_url),
           net::CompletionCallback());
       EXPECT_EQ(net::OK, rv);
     } else {
       LoadPacScriptIntoResolver(script_name);
     }
 
     // Do a query to warm things up. In the case of internal-fetch proxy
     // resolvers, the first resolve will be slow since it has to download
     // the PAC script.
     {
       net::ProxyInfo proxy_info;
-      int result = resolver_->GetProxyForURL(
-          GURL("http://www.warmup.com"), &proxy_info, net::CompletionCallback(),
-          NULL, net::BoundNetLog());
+      int result = resolver_->GetProxyForURL(GURL("http://www.warmup.com"),
+                                             &proxy_info,
+                                             net::CompletionCallback(),
+                                             NULL,
+                                             net::BoundNetLog());
       ASSERT_EQ(net::OK, result);
     }
 
     // Start the perf timer.
     std::string perf_test_name = resolver_name_ + "_" + script_name;
     base::PerfTimeLogger timer(perf_test_name.c_str());
 
     for (int i = 0; i < kNumIterations; ++i) {
       // Round-robin between URLs to resolve.
       const PacQuery& query = queries[i % queries_len];
 
       // Resolve.
       net::ProxyInfo proxy_info;
-      int result = resolver_->GetProxyForURL(
-          GURL(query.query_url), &proxy_info, net::CompletionCallback(), NULL,
-          net::BoundNetLog());
+      int result = resolver_->GetProxyForURL(GURL(query.query_url),
+                                             &proxy_info,
+                                             net::CompletionCallback(),
+                                             NULL,
+                                             net::BoundNetLog());
 
       // Check that the result was correct. Note that ToPacString() and
       // ASSERT_EQ() are fast, so they won't skew the results.
       ASSERT_EQ(net::OK, result);
       ASSERT_EQ(query.expected_result, proxy_info.ToPacString());
     }
 
     // Print how long the test ran for.
     timer.Done();
   }
@@ skipping 38 matching lines @@
   net::ProxyResolverMac resolver;
   PacPerfSuiteRunner runner(&resolver, "ProxyResolverMac");
   runner.RunAllTests();
 }
 #endif
 
 class MockJSBindings : public net::ProxyResolverV8::JSBindings {
  public:
   MockJSBindings() {}
 
-  virtual void Alert(const base::string16& message) OVERRIDE {
-    CHECK(false);
-  }
+  virtual void Alert(const base::string16& message) OVERRIDE { CHECK(false); }
 
   virtual bool ResolveDns(const std::string& host,
                           ResolveDnsOperation op,
                           std::string* output,
                           bool* terminate) OVERRIDE {
     CHECK(false);
     return false;
   }
 
   virtual void OnError(int line_number,
                        const base::string16& message) OVERRIDE {
     CHECK(false);
   }
 };
 
 TEST(ProxyResolverPerfTest, ProxyResolverV8) {
   net::ProxyResolverV8::EnsureIsolateCreated();
 
   MockJSBindings js_bindings;
   net::ProxyResolverV8 resolver;
   resolver.set_js_bindings(&js_bindings);
   PacPerfSuiteRunner runner(&resolver, "ProxyResolverV8");
   runner.RunAllTests();
 }