Delete proxy_resolver_perftest.cc

net/proxy/proxy_resolver_perftest.cc

Index: net/proxy/proxy_resolver_perftest.cc
diff --git a/net/proxy/proxy_resolver_perftest.cc b/net/proxy/proxy_resolver_perftest.cc
deleted file mode 100644
index a910d45d4b792d93dde7491fddad2cf9a04eb4ee..0000000000000000000000000000000000000000
--- a/net/proxy/proxy_resolver_perftest.cc
+++ /dev/null
@@ -1,286 +0,0 @@
-// 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 <utility>
-
-#include "base/base_paths.h"
-#include "base/compiler_specific.h"
-#include "base/files/file_util.h"
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/path_service.h"
-#include "base/strings/string_util.h"
-#include "base/test/perf_time_logger.h"
-#include "net/base/net_errors.h"
-#include "net/dns/mock_host_resolver.h"
-#include "net/log/net_log_with_source.h"
-#include "net/proxy/proxy_info.h"
-#include "net/proxy/proxy_resolver.h"
-#include "net/proxy/proxy_resolver_factory.h"
-#include "net/proxy/proxy_resolver_v8.h"
-#include "net/test/embedded_test_server/embedded_test_server.h"
-#include "net/test/gtest_util.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-#if defined(OS_WIN)
-#include "net/proxy/proxy_resolver_winhttp.h"
-#elif defined(OS_MACOSX)
-#include "net/proxy/proxy_resolver_mac.h"
-#endif
-
-using net::test::IsOk;
-
-namespace net {
-
-namespace {
-
-// This class holds the URL to use for resolving, and the expected result.
-// We track the expected result in order to make sure the performance
-// test is actually resolving URLs properly, otherwise the perf numbers
-// are meaningless :-)
-struct PacQuery {
-  const char* query_url;
-  const char* expected_result;
-};
-
-// Entry listing which PAC scripts to load, and which URLs to try resolving.
-// |queries| should be terminated by {NULL, NULL}. A sentinel is used
-// rather than a length, to simplify using initializer lists.
-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:
-      {"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}
-    },
-  },
-};
-
-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(ProxyResolverFactory* factory,
-                     const std::string& resolver_name)
-      : factory_(factory), resolver_name_(resolver_name) {
-    test_server_.ServeFilesFromSourceDirectory(
-        "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());
-    }
-  }
-
- private:
-  void RunTest(const std::string& script_name,
-               const PacQuery* queries,
-               int queries_len) {
-    std::unique_ptr<ProxyResolver> resolver;
-    if (!factory_->expects_pac_bytes()) {
-      GURL pac_url = test_server_.GetURL(std::string("/") + script_name);
-      int rv = factory_->CreateProxyResolver(
-          ProxyResolverScriptData::FromURL(pac_url), &resolver,
-          CompletionCallback(), nullptr);
-      EXPECT_THAT(rv, IsOk());
-    } else {
-      resolver = LoadPacScriptAndCreateResolver(script_name);
-    }
-    ASSERT_TRUE(resolver);
-
-    // 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.
-    {
-      ProxyInfo proxy_info;
-      int result = resolver->GetProxyForURL(GURL("http://www.warmup.com"),
-                                            &proxy_info, CompletionCallback(),
-                                            NULL, NetLogWithSource());
-      ASSERT_THAT(result, IsOk());
-    }
-
-    // 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.
-      ProxyInfo proxy_info;
-      int result = resolver->GetProxyForURL(GURL(query.query_url), &proxy_info,
-                                            CompletionCallback(), NULL,
-                                            NetLogWithSource());
-
-      // Check that the result was correct. Note that ToPacString() and
-      // ASSERT_EQ() are fast, so they won't skew the results.
-      ASSERT_THAT(result, IsOk());
-      ASSERT_EQ(query.expected_result, proxy_info.ToPacString());
-    }
-
-    // Print how long the test ran for.
-    timer.Done();
-  }
-
-  // Read the PAC script from disk and initialize the proxy resolver with it.
-  std::unique_ptr<ProxyResolver> LoadPacScriptAndCreateResolver(
-      const std::string& script_name) {
-    base::FilePath path;
-    PathService::Get(base::DIR_SOURCE_ROOT, &path);
-    path = path.AppendASCII("net");
-    path = path.AppendASCII("data");
-    path = path.AppendASCII("proxy_resolver_perftest");
-    path = path.AppendASCII(script_name);
-
-    // Try to read the file from disk.
-    std::string file_contents;
-    bool ok = base::ReadFileToString(path, &file_contents);
-
-    // If we can't load the file from disk, something is misconfigured.
-    LOG_IF(ERROR, !ok) << "Failed to read file: " << path.value();
-    if (!ok)
-      return nullptr;
-
-    // Load the PAC script into the ProxyResolver.
-    std::unique_ptr<ProxyResolver> resolver;
-    int rv = factory_->CreateProxyResolver(
-        ProxyResolverScriptData::FromUTF8(file_contents), &resolver,
-        CompletionCallback(), nullptr);
-    EXPECT_THAT(rv, IsOk());
-    return resolver;
-  }
-
-  ProxyResolverFactory* factory_;
-  std::string resolver_name_;
-  EmbeddedTestServer test_server_;
-};
-
-#if defined(OS_WIN)
-TEST(ProxyResolverPerfTest, ProxyResolverWinHttp) {
-  ProxyResolverFactoryWinHttp factory;
-  PacPerfSuiteRunner runner(&factory, "ProxyResolverWinHttp");
-  runner.RunAllTests();
-}
-#elif defined(OS_MACOSX)
-TEST(ProxyResolverPerfTest, ProxyResolverMac) {
-  ProxyResolverFactoryMac factory;
-  PacPerfSuiteRunner runner(&factory, "ProxyResolverMac");
-  runner.RunAllTests();
-}
-#endif
-
-class MockJSBindings : public ProxyResolverV8::JSBindings {
- public:
-  MockJSBindings() {}
-
-  void Alert(const base::string16& message) override { CHECK(false); }
-
-  bool ResolveDns(const std::string& host,
-                  ResolveDnsOperation op,
-                  std::string* output,
-                  bool* terminate) override {
-    CHECK(false);
-    return false;
-  }
-
-  void OnError(int line_number, const base::string16& message) override {
-    CHECK(false);
-  }
-};
-
-class ProxyResolverV8Wrapper : public ProxyResolver {
- public:
-  ProxyResolverV8Wrapper(std::unique_ptr<ProxyResolverV8> resolver,
-                         std::unique_ptr<MockJSBindings> bindings)
-      : resolver_(std::move(resolver)), bindings_(std::move(bindings)) {}
-
-  int GetProxyForURL(const GURL& url,
-                     ProxyInfo* results,
-                     const CompletionCallback& /*callback*/,
-                     std::unique_ptr<Request>* /*request*/,
-                     const NetLogWithSource& net_log) override {
-    return resolver_->GetProxyForURL(url, results, bindings_.get());
-  }
-
- private:
-  std::unique_ptr<ProxyResolverV8> resolver_;
-  std::unique_ptr<MockJSBindings> bindings_;
-
-  DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8Wrapper);
-};
-
-class ProxyResolverV8Factory : public ProxyResolverFactory {
- public:
-  ProxyResolverV8Factory() : ProxyResolverFactory(true) {}
-  int CreateProxyResolver(
-      const scoped_refptr<ProxyResolverScriptData>& pac_script,
-      std::unique_ptr<ProxyResolver>* resolver,
-      const net::CompletionCallback& callback,
-      std::unique_ptr<Request>* request) override {
-    std::unique_ptr<ProxyResolverV8> v8_resolver;
-    std::unique_ptr<MockJSBindings> js_bindings_(new MockJSBindings);
-    int result =
-        ProxyResolverV8::Create(pac_script, js_bindings_.get(), &v8_resolver);
-    if (result == OK) {
-      resolver->reset(new ProxyResolverV8Wrapper(std::move(v8_resolver),
-                                                 std::move(js_bindings_)));
-    }
-    return result;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8Factory);
-};
-
-TEST(ProxyResolverPerfTest, ProxyResolverV8) {
-  base::MessageLoop message_loop;
-  ProxyResolverV8Factory factory;
-  PacPerfSuiteRunner runner(&factory, "ProxyResolverV8");
-  runner.RunAllTests();
-}
-
-}  // namespace
-
-}  // namespace net