blob: 6b0b68fb71b14fb23327ff89e45ca4be63c59df3 [file] [log] [blame]
// 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"
#include "net/base/net_errors.h"
#include "net/dns/mock_host_resolver.h"
#include "net/proxy/proxy_info.h"
#include "net/proxy/proxy_resolver_v8.h"
#include "net/test/spawned_test_server/spawned_test_server.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
// 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(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"))) {
}
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) {
if (!resolver_->expects_pac_bytes()) {
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());
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());
// 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();
}
// Read the PAC script from disk and initialize the proxy resolver with it.
void LoadPacScriptIntoResolver(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();
ASSERT_TRUE(ok);
// Load the PAC script into the ProxyResolver.
int rv = resolver_->SetPacScript(
net::ProxyResolverScriptData::FromUTF8(file_contents),
net::CompletionCallback());
EXPECT_EQ(net::OK, rv);
}
net::ProxyResolver* resolver_;
std::string resolver_name_;
net::SpawnedTestServer test_server_;
};
#if defined(OS_WIN)
TEST(ProxyResolverPerfTest, ProxyResolverWinHttp) {
net::ProxyResolverWinHttp resolver;
PacPerfSuiteRunner runner(&resolver, "ProxyResolverWinHttp");
runner.RunAllTests();
}
#elif defined(OS_MACOSX)
TEST(ProxyResolverPerfTest, ProxyResolverMac) {
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 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();
}