Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(491)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/proxy/proxy_service_unittest.cc

Issue 1684123004: Bypass the DataReductionProxy for all POST requests (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix Rebase issue Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/proxy/proxy_service_mojo_unittest.cc ('k') | net/url_request/url_request_ftp_job.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/proxy/proxy_service_unittest.cc
diff --git a/net/proxy/proxy_service_unittest.cc b/net/proxy/proxy_service_unittest.cc
index a9cb9ed5acf5a12d6e73ca1a269ecb8daae1eb12..c595f4564c1c55de78547a80c7337883158518e7 100644
--- a/net/proxy/proxy_service_unittest.cc
+++ b/net/proxy/proxy_service_unittest.cc
@@ -1,17 +1,18 @@
// 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 "net/proxy/proxy_service.h"
#include <cstdarg>
+#include <string>
#include <vector>
#include "base/format_macros.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/base/proxy_delegate.h"
@@ -164,37 +165,41 @@ class MockProxyConfigService: public ProxyConfigService {
// A test network delegate that exercises the OnResolveProxy callback.
class TestResolveProxyDelegate : public ProxyDelegate {
public:
TestResolveProxyDelegate()
: on_resolve_proxy_called_(false),
add_proxy_(false),
remove_proxy_(false),
proxy_service_(nullptr) {}
void OnResolveProxy(const GURL& url,
+ const std::string& method,
int load_flags,
const ProxyService& proxy_service,
ProxyInfo* result) override {
+ method_ = method;
on_resolve_proxy_called_ = true;
proxy_service_ = &proxy_service;
DCHECK(!add_proxy_ || !remove_proxy_);
if (add_proxy_) {
result->UseNamedProxy("delegate_proxy.com");
} else if (remove_proxy_) {
result->UseDirect();
}
}
bool on_resolve_proxy_called() const {
return on_resolve_proxy_called_;
}
+ const std::string& method() const { return method_; }
+
void set_add_proxy(bool add_proxy) {
add_proxy_ = add_proxy;
}
void set_remove_proxy(bool remove_proxy) {
remove_proxy_ = remove_proxy;
}
const ProxyService* proxy_service() const {
return proxy_service_;
@@ -214,31 +219,33 @@ class TestResolveProxyDelegate : public ProxyDelegate {
const HostPortPair& proxy_server,
const HttpResponseHeaders& response_headers) override {}
bool IsTrustedSpdyProxy(const net::ProxyServer& proxy_server) override {
return true;
}
private:
bool on_resolve_proxy_called_;
bool add_proxy_;
bool remove_proxy_;
+ std::string method_;
const ProxyService* proxy_service_;
};
// A test network delegate that exercises the OnProxyFallback callback.
class TestProxyFallbackProxyDelegate : public ProxyDelegate {
public:
TestProxyFallbackProxyDelegate()
: on_proxy_fallback_called_(false), proxy_fallback_net_error_(OK) {}
// ProxyDelegate implementation:
void OnResolveProxy(const GURL& url,
+ const std::string& method,
int load_flags,
const ProxyService& proxy_service,
ProxyInfo* result) override {}
void OnTunnelConnectCompleted(const HostPortPair& endpoint,
const HostPortPair& proxy_server,
int net_error) override {}
void OnFallback(const ProxyServer& bad_proxy, int net_error) override {
proxy_server_ = bad_proxy;
proxy_fallback_net_error_ = net_error;
on_proxy_fallback_called_ = true;
@@ -340,29 +347,30 @@ RequestMap GetCancelledRequestsForURLs(const MockAsyncProxyResolver& resolver,
return GetRequestsForURLs(resolver.cancelled_requests(), urls);
}
} // namespace
TEST_F(ProxyServiceTest, Direct) {
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(
make_scoped_ptr(new MockProxyConfigService(ProxyConfig::CreateDirect())),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback;
BoundTestNetLog log;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, log.bound());
+ int rv =
+ service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr, log.bound());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(factory->pending_requests().empty());
EXPECT_TRUE(info.is_direct());
EXPECT_TRUE(info.proxy_resolve_start_time().is_null());
EXPECT_TRUE(info.proxy_resolve_end_time().is_null());
// Check the NetLog was filled correctly.
TestNetLogEntry::List entries;
log.GetEntries(&entries);
@@ -377,130 +385,136 @@ TEST_F(ProxyServiceTest, Direct) {
entries, 2, NetLog::TYPE_PROXY_SERVICE));
}
TEST_F(ProxyServiceTest, OnResolveProxyCallbackAddProxy) {
ProxyConfig config;
config.proxy_rules().ParseFromString("foopy1:8080");
config.set_auto_detect(false);
config.proxy_rules().bypass_rules.ParseFromString("*.org");
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL url("http://www.google.com/");
GURL bypass_url("http://internet.org");
ProxyInfo info;
TestCompletionCallback callback;
BoundTestNetLog log;
// First, warm up the ProxyService.
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, log.bound());
+ int rv =
+ service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr, log.bound());
EXPECT_EQ(OK, rv);
// Verify that network delegate is invoked.
TestResolveProxyDelegate delegate;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
- &delegate, log.bound());
+ rv = service.ResolveProxy(url, "GET", LOAD_NORMAL, &info, callback.callback(),
+ nullptr, &delegate, log.bound());
EXPECT_TRUE(delegate.on_resolve_proxy_called());
EXPECT_EQ(&service, delegate.proxy_service());
+ EXPECT_EQ(delegate.method(), "GET");
// Verify that the ProxyDelegate's behavior is stateless across
// invocations of ResolveProxy. Start by having the callback add a proxy
// and checking that subsequent requests are not affected.
delegate.set_add_proxy(true);
// Callback should interpose:
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
- &delegate, log.bound());
+ rv = service.ResolveProxy(url, "GET", LOAD_NORMAL, &info, callback.callback(),
+ nullptr, &delegate, log.bound());
EXPECT_FALSE(info.is_direct());
EXPECT_EQ(info.proxy_server().host_port_pair().host(), "delegate_proxy.com");
delegate.set_add_proxy(false);
// Check non-bypassed URL:
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
- &delegate, log.bound());
+ rv = service.ResolveProxy(url, "GET", LOAD_NORMAL, &info, callback.callback(),
+ nullptr, &delegate, log.bound());
EXPECT_FALSE(info.is_direct());
EXPECT_EQ(info.proxy_server().host_port_pair().host(), "foopy1");
// Check bypassed URL:
- rv = service.ResolveProxy(bypass_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, &delegate, log.bound());
+ rv = service.ResolveProxy(bypass_url, "GET", LOAD_NORMAL, &info,
+ callback.callback(), nullptr, &delegate,
+ log.bound());
EXPECT_TRUE(info.is_direct());
}
TEST_F(ProxyServiceTest, OnResolveProxyCallbackRemoveProxy) {
// Same as OnResolveProxyCallbackAddProxy, but verify that the
// ProxyDelegate's behavior is stateless across invocations after it
// *removes* a proxy.
ProxyConfig config;
config.proxy_rules().ParseFromString("foopy1:8080");
config.set_auto_detect(false);
config.proxy_rules().bypass_rules.ParseFromString("*.org");
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL url("http://www.google.com/");
GURL bypass_url("http://internet.org");
ProxyInfo info;
TestCompletionCallback callback;
BoundTestNetLog log;
// First, warm up the ProxyService.
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, log.bound());
+ int rv =
+ service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr, log.bound());
EXPECT_EQ(OK, rv);
TestResolveProxyDelegate delegate;
delegate.set_remove_proxy(true);
// Callback should interpose:
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
- &delegate, log.bound());
+ rv = service.ResolveProxy(url, "GET", LOAD_NORMAL, &info, callback.callback(),
+ nullptr, &delegate, log.bound());
EXPECT_TRUE(info.is_direct());
delegate.set_remove_proxy(false);
// Check non-bypassed URL:
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
- &delegate, log.bound());
+ rv = service.ResolveProxy(url, "GET", LOAD_NORMAL, &info, callback.callback(),
+ nullptr, &delegate, log.bound());
EXPECT_FALSE(info.is_direct());
EXPECT_EQ(info.proxy_server().host_port_pair().host(), "foopy1");
// Check bypassed URL:
- rv = service.ResolveProxy(bypass_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, &delegate, log.bound());
+ rv = service.ResolveProxy(bypass_url, "GET", LOAD_NORMAL, &info,
+ callback.callback(), nullptr, &delegate,
+ log.bound());
EXPECT_TRUE(info.is_direct());
}
TEST_F(ProxyServiceTest, PAC) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback;
ProxyService::PacRequest* request;
BoundTestNetLog log;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- &request, NULL, log.bound());
+ int rv =
+ service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), &request, nullptr, log.bound());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request));
ASSERT_EQ(1u, factory->pending_requests().size());
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
@@ -538,28 +552,29 @@ TEST_F(ProxyServiceTest, PAC) {
// or its reference section.
TEST_F(ProxyServiceTest, PAC_NoIdentityOrHash) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://username:password@www.google.com/?ref#hash#hash");
ProxyInfo info;
TestCompletionCallback callback;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
// The URL should have been simplified, stripping the username/password/hash.
EXPECT_EQ(GURL("http://www.google.com/?ref"),
resolver.pending_requests()[0]->url());
@@ -569,28 +584,29 @@ TEST_F(ProxyServiceTest, PAC_NoIdentityOrHash) {
}
TEST_F(ProxyServiceTest, PAC_FailoverWithoutDirect) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Set the result in proxy resolver.
@@ -606,45 +622,46 @@ TEST_F(ProxyServiceTest, PAC_FailoverWithoutDirect) {
EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
// Now, imagine that connecting to foopy:8080 fails: there is nothing
// left to fallback to, since our proxy list was NOT terminated by
// DIRECT.
TestResolveProxyDelegate proxy_delegate;
TestCompletionCallback callback2;
ProxyServer expected_proxy_server = info.proxy_server();
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback2.callback(), NULL, &proxy_delegate, BoundNetLog());
+ url, "GET", LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback2.callback(), nullptr, &proxy_delegate, BoundNetLog());
// ReconsiderProxyAfterError returns error indicating nothing left.
EXPECT_EQ(ERR_FAILED, rv);
EXPECT_TRUE(info.is_empty());
}
// Test that if the execution of the PAC script fails (i.e. javascript runtime
// error), and the PAC settings are non-mandatory, that we fall-back to direct.
TEST_F(ProxyServiceTest, PAC_RuntimeError) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://this-causes-js-error/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Simulate a failure in the PAC executor.
@@ -681,104 +698,106 @@ TEST_F(ProxyServiceTest, PAC_RuntimeError) {
// The important check of this test is to make sure that DIRECT is not somehow
// cached as being a bad proxy.
TEST_F(ProxyServiceTest, PAC_FailoverAfterDirect) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Set the result in proxy resolver.
resolver.pending_requests()[0]->results()->UsePacString(
"DIRECT ; PROXY foobar:10 ; DIRECT ; PROXY foobar:20");
resolver.pending_requests()[0]->CompleteNow(OK);
EXPECT_EQ(OK, callback1.WaitForResult());
EXPECT_TRUE(info.is_direct());
// Fallback 1.
TestCompletionCallback callback2;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback2.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foobar:10", info.proxy_server().ToURI());
// Fallback 2.
TestResolveProxyDelegate proxy_delegate;
ProxyServer expected_proxy_server3 = info.proxy_server();
TestCompletionCallback callback3;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback3.callback(), NULL, &proxy_delegate, BoundNetLog());
+ url, "GET", LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback3.callback(), nullptr, &proxy_delegate, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(info.is_direct());
// Fallback 3.
ProxyServer expected_proxy_server4 = info.proxy_server();
TestCompletionCallback callback4;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback4.callback(), NULL, &proxy_delegate, BoundNetLog());
+ url, "GET", LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback4.callback(), nullptr, &proxy_delegate, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foobar:20", info.proxy_server().ToURI());
// Fallback 4 -- Nothing to fall back to!
ProxyServer expected_proxy_server5 = info.proxy_server();
TestCompletionCallback callback5;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback5.callback(), NULL, &proxy_delegate, BoundNetLog());
+ url, "GET", LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback5.callback(), nullptr, &proxy_delegate, BoundNetLog());
EXPECT_EQ(ERR_FAILED, rv);
EXPECT_TRUE(info.is_empty());
}
TEST_F(ProxyServiceTest, PAC_ConfigSourcePropagates) {
// Test whether the ProxyConfigSource set by the ProxyConfigService is applied
// to ProxyInfo after the proxy is resolved via a PAC script.
ProxyConfig config =
ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
config.set_source(PROXY_CONFIG_SOURCE_TEST);
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
// Resolve something.
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
ASSERT_EQ(ERR_IO_PENDING, rv);
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
// Set the result in proxy resolver.
resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
resolver.pending_requests()[0]->CompleteNow(OK);
EXPECT_EQ(OK, callback.WaitForResult());
EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
@@ -795,28 +814,29 @@ TEST_F(ProxyServiceTest, ProxyResolverFails) {
// javascript runtime error while calling FindProxyForURL().
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
// Start first resolve request.
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Fail the first resolve request in MockAsyncProxyResolver.
@@ -828,22 +848,23 @@ TEST_F(ProxyServiceTest, ProxyResolverFails) {
EXPECT_TRUE(info.is_direct());
// Failed PAC executions still have proxy resolution times.
EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
// The second resolve request will try to run through the proxy resolver,
// regardless of whether the first request failed in it.
TestCompletionCallback callback2;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback2.callback(), NULL,
- NULL, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// This time we will have the resolver succeed (perhaps the PAC script has
// a dependency on the current time).
resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -863,23 +884,23 @@ TEST_F(ProxyServiceTest, ProxyResolverTerminatedDuringRequest) {
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
make_scoped_ptr(factory), nullptr);
// Start first resolve request.
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(url, net::LOAD_NORMAL, &info, callback1.callback(),
- nullptr, nullptr, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), net::LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, factory->pending_requests().size());
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
@@ -894,22 +915,23 @@ TEST_F(ProxyServiceTest, ProxyResolverTerminatedDuringRequest) {
// Failed PAC executions still have proxy resolution times.
EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
// With no other requests, the ProxyService waits for a new request before
// initializing a new ProxyResolver.
EXPECT_TRUE(factory->pending_requests().empty());
TestCompletionCallback callback2;
- rv = service.ResolveProxy(url, net::LOAD_NORMAL, &info, callback2.callback(),
- nullptr, nullptr, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), net::LOAD_NORMAL, &info,
+ callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, factory->pending_requests().size());
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
@@ -935,27 +957,28 @@ TEST_F(ProxyServiceTest,
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
make_scoped_ptr(factory), nullptr);
// Start two resolve requests.
GURL url1("http://www.google.com/");
GURL url2("https://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(url1, net::LOAD_NORMAL, &info, callback1.callback(),
- nullptr, nullptr, BoundNetLog());
+ int rv = service.ResolveProxy(url1, std::string(), net::LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
TestCompletionCallback callback2;
- rv = service.ResolveProxy(url2, net::LOAD_NORMAL, &info, callback2.callback(),
- nullptr, nullptr, BoundNetLog());
+ rv = service.ResolveProxy(url2, std::string(), net::LOAD_NORMAL, &info,
+ callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, factory->pending_requests().size());
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2);
// Fail the first resolve request in MockAsyncProxyResolver.
@@ -999,77 +1022,80 @@ TEST_F(ProxyServiceTest, ProxyScriptFetcherFailsDownloadingMandatoryPac) {
ProxyConfig config(
ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
config.set_pac_mandatory(true);
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
// Start first resolve request.
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNow(ERR_FAILED, nullptr);
ASSERT_EQ(0u, factory->pending_requests().size());
// As the proxy resolver factory failed the request and is configured for a
// mandatory PAC script, ProxyService must not implicitly fall-back to DIRECT.
EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
callback1.WaitForResult());
EXPECT_FALSE(info.is_direct());
// As the proxy resolver factory failed the request and is configured for a
// mandatory PAC script, ProxyService must not implicitly fall-back to DIRECT.
TestCompletionCallback callback2;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback2.callback(), NULL,
- NULL, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED, rv);
EXPECT_FALSE(info.is_direct());
}
TEST_F(ProxyServiceTest, ProxyResolverFailsParsingJavaScriptMandatoryPac) {
// Test what happens when the ProxyResolver fails that is configured to use a
// mandatory PAC script. The download of the PAC script has already
// succeeded but the PAC script contains no valid javascript.
ProxyConfig config(
ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
config.set_pac_mandatory(true);
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start resolve request.
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that nothing has been sent to the proxy resolver factory yet.
ASSERT_EQ(0u, factory->pending_requests().size());
// Downloading the PAC script succeeds.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
@@ -1094,28 +1120,29 @@ TEST_F(ProxyServiceTest, ProxyResolverFailsInJavaScriptMandatoryPac) {
ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
config.set_pac_mandatory(true);
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
// Start first resolve request.
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Fail the first resolve request in MockAsyncProxyResolver.
@@ -1123,22 +1150,23 @@ TEST_F(ProxyServiceTest, ProxyResolverFailsInJavaScriptMandatoryPac) {
// As the proxy resolver failed the request and is configured for a mandatory
// PAC script, ProxyService must not implicitly fall-back to DIRECT.
EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
callback1.WaitForResult());
EXPECT_FALSE(info.is_direct());
// The second resolve request will try to run through the proxy resolver,
// regardless of whether the first request failed in it.
TestCompletionCallback callback2;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback2.callback(), NULL,
- NULL, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// This time we will have the resolver succeed (perhaps the PAC script has
// a dependency on the current time).
resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -1152,29 +1180,30 @@ TEST_F(ProxyServiceTest, ProxyFallback) {
// are bad.
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
// Get the proxy information.
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Set the result in proxy resolver.
@@ -1189,41 +1218,42 @@ TEST_F(ProxyServiceTest, ProxyFallback) {
EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
base::TimeTicks proxy_resolve_start_time = info.proxy_resolve_start_time();
base::TimeTicks proxy_resolve_end_time = info.proxy_resolve_end_time();
// Fake an error on the proxy.
TestCompletionCallback callback2;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback2.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
// Proxy times should not have been modified by fallback.
EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
// The second proxy should be specified.
EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
// Report back that the second proxy worked. This will globally mark the
// first proxy as bad.
TestProxyFallbackProxyDelegate test_delegate;
service.ReportSuccess(info, &test_delegate);
EXPECT_EQ("foopy1:8080", test_delegate.proxy_server().ToURI());
EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED,
test_delegate.proxy_fallback_net_error());
TestCompletionCallback callback3;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback3.callback(), NULL,
- NULL, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback3.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Set the result in proxy resolver -- the second result is already known
// to be bad, so we will not try to use it initially.
resolver.pending_requests()[0]->results()->UseNamedProxy(
"foopy3:7070;foopy1:8080;foopy2:9090");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -1236,53 +1266,54 @@ TEST_F(ProxyServiceTest, ProxyFallback) {
EXPECT_LE(proxy_resolve_end_time, info.proxy_resolve_start_time());
EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
proxy_resolve_start_time = info.proxy_resolve_start_time();
proxy_resolve_end_time = info.proxy_resolve_end_time();
// We fake another error. It should now try the third one.
TestCompletionCallback callback4;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback4.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback4.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
// We fake another error. At this point we have tried all of the
// proxy servers we thought were valid; next we try the proxy server
// that was in our bad proxies map (foopy1:8080).
TestCompletionCallback callback5;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback5.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback5.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
// Fake another error, the last proxy is gone, the list should now be empty,
// so there is nothing left to try.
TestCompletionCallback callback6;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback6.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback6.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_FAILED, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_TRUE(info.is_empty());
// Proxy times should not have been modified by fallback.
EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
// Look up proxies again
TestCompletionCallback callback7;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback7.callback(), NULL,
- NULL, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback7.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// This time, the first 3 results have been found to be bad, but only the
// first proxy has been confirmed ...
resolver.pending_requests()[0]->results()->UseNamedProxy(
"foopy1:8080;foopy3:7070;foopy2:9090;foopy4:9091");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -1302,29 +1333,30 @@ TEST_F(ProxyServiceTest, ProxyFallback) {
// fallback choice to DIRECT.
TEST_F(ProxyServiceTest, ProxyFallbackToDirect) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
// Get the proxy information.
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Set the result in proxy resolver.
@@ -1333,71 +1365,72 @@ TEST_F(ProxyServiceTest, ProxyFallbackToDirect) {
resolver.pending_requests()[0]->CompleteNow(OK);
// Get the first result.
EXPECT_EQ(OK, callback1.WaitForResult());
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
// Fake an error on the proxy.
TestCompletionCallback callback2;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback2.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
// Now we get back the second proxy.
EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
// Fake an error on this proxy as well.
TestCompletionCallback callback3;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback3.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback3.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
// Finally, we get back DIRECT.
EXPECT_TRUE(info.is_direct());
EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
// Now we tell the proxy service that even DIRECT failed.
TestCompletionCallback callback4;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback4.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback4.callback(), nullptr, nullptr, BoundNetLog());
// There was nothing left to try after DIRECT, so we are out of
// choices.
EXPECT_EQ(ERR_FAILED, rv);
}
TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
// Test proxy failover when new settings are available.
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
// Get the proxy information.
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// Set the result in proxy resolver.
@@ -1409,57 +1442,57 @@ TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
EXPECT_EQ(OK, callback1.WaitForResult());
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
// Fake an error on the proxy, and also a new configuration on the proxy.
config_service->SetConfig(
ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy-new/proxy.pac")));
TestCompletionCallback callback2;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback2.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy-new/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
resolver.pending_requests()[0]->results()->UseNamedProxy(
"foopy1:8080;foopy2:9090");
resolver.pending_requests()[0]->CompleteNow(OK);
// The first proxy is still there since the configuration changed.
EXPECT_EQ(OK, callback2.WaitForResult());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
// We fake another error. It should now ignore the first one.
TestCompletionCallback callback3;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback3.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback3.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
// We simulate a new configuration.
config_service->SetConfig(
ProxyConfig::CreateFromCustomPacURL(
GURL("http://foopy-new2/proxy.pac")));
// We fake another error. It should go back to the first proxy.
TestCompletionCallback callback4;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback4.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback4.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy-new2/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
resolver.pending_requests()[0]->results()->UseNamedProxy(
@@ -1478,84 +1511,86 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfig) {
// Test proxy failover when the configuration is bad.
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
// Get the proxy information.
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
resolver.pending_requests()[0]->results()->UseNamedProxy(
"foopy1:8080;foopy2:9090");
resolver.pending_requests()[0]->CompleteNow(OK);
// The first item is valid.
EXPECT_EQ(OK, callback1.WaitForResult());
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
// Fake a proxy error.
TestCompletionCallback callback2;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback2.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
// The first proxy is ignored, and the second one is selected.
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
// Fake a PAC failure.
ProxyInfo info2;
TestCompletionCallback callback3;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info2, callback3.callback(),
- NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info2,
+ callback3.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// This simulates a javascript runtime error in the PAC script.
resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
// Although the resolver failed, the ProxyService will implicitly fall-back
// to a DIRECT connection.
EXPECT_EQ(OK, callback3.WaitForResult());
EXPECT_TRUE(info2.is_direct());
EXPECT_FALSE(info2.is_empty());
// The PAC script will work properly next time and successfully return a
// proxy list. Since we have not marked the configuration as bad, it should
// "just work" the next time we call it.
ProxyInfo info3;
TestCompletionCallback callback4;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info3,
- callback4.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info3,
+ callback4.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
resolver.pending_requests()[0]->results()->UseNamedProxy(
"foopy1:8080;foopy2:9090");
resolver.pending_requests()[0]->CompleteNow(OK);
// The first proxy is not there since the it was added to the bad proxies
@@ -1576,62 +1611,64 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfigMandatory) {
ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac")));
config.set_pac_mandatory(true);
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
// Get the proxy information.
ProxyInfo info;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
resolver.pending_requests()[0]->results()->UseNamedProxy(
"foopy1:8080;foopy2:9090");
resolver.pending_requests()[0]->CompleteNow(OK);
// The first item is valid.
EXPECT_EQ(OK, callback1.WaitForResult());
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
// Fake a proxy error.
TestCompletionCallback callback2;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
+ callback2.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
// The first proxy is ignored, and the second one is selected.
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
// Fake a PAC failure.
ProxyInfo info2;
TestCompletionCallback callback3;
- rv = service.ResolveProxy(url, LOAD_NORMAL, &info2, callback3.callback(),
- NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info2,
+ callback3.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
// This simulates a javascript runtime error in the PAC script.
resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
// Although the resolver failed, the ProxyService will NOT fall-back
// to a DIRECT connection as it is configured as mandatory.
@@ -1639,22 +1676,22 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfigMandatory) {
callback3.WaitForResult());
EXPECT_FALSE(info2.is_direct());
EXPECT_TRUE(info2.is_empty());
// The PAC script will work properly next time and successfully return a
// proxy list. Since we have not marked the configuration as bad, it should
// "just work" the next time we call it.
ProxyInfo info3;
TestCompletionCallback callback4;
rv = service.ReconsiderProxyAfterError(
- url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info3,
- callback4.callback(), NULL, NULL, BoundNetLog());
+ url, std::string(), LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info3,
+ callback4.callback(), nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(url, resolver.pending_requests()[0]->url());
resolver.pending_requests()[0]->results()->UseNamedProxy(
"foopy1:8080;foopy2:9090");
resolver.pending_requests()[0]->CompleteNow(OK);
// The first proxy is not there since the it was added to the bad proxies
@@ -1668,35 +1705,37 @@ TEST_F(ProxyServiceTest, ProxyBypassList) {
// Test that the proxy bypass rules are consulted.
TestCompletionCallback callback[2];
ProxyInfo info[2];
ProxyConfig config;
config.proxy_rules().ParseFromString("foopy1:8080;foopy2:9090");
config.set_auto_detect(false);
config.proxy_rules().bypass_rules.ParseFromString("*.org");
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
int rv;
GURL url1("http://www.webkit.org");
GURL url2("http://www.webkit.com");
// Request for a .org domain should bypass proxy.
- rv = service.ResolveProxy(url1, LOAD_NORMAL, &info[0], callback[0].callback(),
- NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url1, std::string(), LOAD_NORMAL, &info[0],
+ callback[0].callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(info[0].is_direct());
// Request for a .com domain hits the proxy.
- rv = service.ResolveProxy(url2, LOAD_NORMAL, &info[1], callback[1].callback(),
- NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url2, std::string(), LOAD_NORMAL, &info[1],
+ callback[1].callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_EQ("foopy1:8080", info[1].proxy_server().ToURI());
}
TEST_F(ProxyServiceTest, MarkProxiesAsBadTests) {
ProxyConfig config;
config.proxy_rules().ParseFromString(
"http=foopy1:8080;http=foopy2:8080;http=foopy3.8080;http=foopy4:8080");
config.set_auto_detect(false);
@@ -1707,253 +1746,256 @@ TEST_F(ProxyServiceTest, MarkProxiesAsBadTests) {
proxy_list.AddProxyServer(proxy_server);
if (proxy_server == config.proxy_rules().proxies_for_http.Get())
continue;
additional_bad_proxies.push_back(proxy_server);
}
EXPECT_EQ(3u, additional_bad_proxies.size());
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
ProxyInfo proxy_info;
proxy_info.UseProxyList(proxy_list);
const ProxyRetryInfoMap& retry_info = service.proxy_retry_info();
service.MarkProxiesAsBadUntil(proxy_info, base::TimeDelta::FromSeconds(1),
additional_bad_proxies, BoundNetLog());
ASSERT_EQ(4u, retry_info.size());
for (const ProxyServer& proxy_server :
config.proxy_rules().proxies_for_http.GetAll()) {
ProxyRetryInfoMap::const_iterator i =
retry_info.find(proxy_server.host_port_pair().ToString());
ASSERT_TRUE(i != retry_info.end());
}
}
TEST_F(ProxyServiceTest, PerProtocolProxyTests) {
ProxyConfig config;
config.proxy_rules().ParseFromString("http=foopy1:8080;https=foopy2:8080");
config.set_auto_detect(false);
{
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("http://www.msn.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
}
{
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("ftp://ftp.google.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(info.is_direct());
EXPECT_EQ("direct://", info.proxy_server().ToURI());
}
{
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("https://webbranch.techcu.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
}
{
config.proxy_rules().ParseFromString("foopy1:8080");
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("http://www.microsoft.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
}
}
TEST_F(ProxyServiceTest, ProxyConfigSourcePropagates) {
// Test that the proxy config source is set correctly when resolving proxies
// using manual proxy rules. Namely, the config source should only be set if
// any of the rules were applied.
{
ProxyConfig config;
config.set_source(PROXY_CONFIG_SOURCE_TEST);
config.proxy_rules().ParseFromString("https=foopy2:8080");
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("http://www.google.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
ASSERT_EQ(OK, rv);
// Should be SOURCE_TEST, even if there are no HTTP proxies configured.
EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
}
{
ProxyConfig config;
config.set_source(PROXY_CONFIG_SOURCE_TEST);
config.proxy_rules().ParseFromString("https=foopy2:8080");
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("https://www.google.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
ASSERT_EQ(OK, rv);
// Used the HTTPS proxy. So source should be TEST.
EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
}
{
ProxyConfig config;
config.set_source(PROXY_CONFIG_SOURCE_TEST);
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("http://www.google.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
ASSERT_EQ(OK, rv);
// ProxyConfig is empty. Source should still be TEST.
EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
}
}
// If only HTTP and a SOCKS proxy are specified, check if ftp/https queries
// fall back to the SOCKS proxy.
TEST_F(ProxyServiceTest, DefaultProxyFallbackToSOCKS) {
ProxyConfig config;
config.proxy_rules().ParseFromString("http=foopy1:8080;socks=foopy2:1080");
config.set_auto_detect(false);
EXPECT_EQ(ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME,
config.proxy_rules().type);
{
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("http://www.msn.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
}
{
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("ftp://ftp.google.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
}
{
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("https://webbranch.techcu.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
}
{
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- nullptr, NULL);
+ nullptr, nullptr);
GURL test_url("unknown://www.microsoft.com");
ProxyInfo info;
TestCompletionCallback callback;
- int rv =
- service.ResolveProxy(test_url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(test_url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("socks4://foopy2:1080", info.proxy_server().ToURI());
}
}
// Test cancellation of an in-progress request.
TEST_F(ProxyServiceTest, CancelInProgressRequest) {
const GURL url1("http://request1");
const GURL url2("http://request2");
const GURL url3("http://request3");
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
// Start 3 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url1, LOAD_NORMAL, &info1, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url1, std::string(), LOAD_NORMAL, &info1,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Successfully initialize the PAC script.
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
GetPendingRequestsForURLs(resolver, url1);
ProxyInfo info2;
TestCompletionCallback callback2;
ProxyService::PacRequest* request2;
- rv = service.ResolveProxy(url2, LOAD_NORMAL, &info2, callback2.callback(),
- &request2, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url2, std::string(), LOAD_NORMAL, &info2,
+ callback2.callback(), &request2, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
GetPendingRequestsForURLs(resolver, url1, url2);
ProxyInfo info3;
TestCompletionCallback callback3;
- rv = service.ResolveProxy(url3, LOAD_NORMAL, &info3, callback3.callback(),
- NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url3, std::string(), LOAD_NORMAL, &info3,
+ callback3.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
GetPendingRequestsForURLs(resolver, url1, url2, url3);
// Cancel the second request
service.CancelPacRequest(request2);
RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url3);
// Complete the two un-cancelled requests.
// We complete the last one first, just to mix it up a bit.
@@ -1980,51 +2022,54 @@ TEST_F(ProxyServiceTest, InitialPACScriptDownload) {
const GURL url2("http://request2");
const GURL url3("http://request3");
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 3 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
ProxyService::PacRequest* request1;
- int rv = service.ResolveProxy(url1, LOAD_NORMAL, &info1, callback1.callback(),
- &request1, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url1, std::string(), LOAD_NORMAL, &info1,
+ callback1.callback(), &request1, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
ProxyInfo info2;
TestCompletionCallback callback2;
ProxyService::PacRequest* request2;
- rv = service.ResolveProxy(url2, LOAD_NORMAL, &info2, callback2.callback(),
- &request2, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url2, std::string(), LOAD_NORMAL, &info2,
+ callback2.callback(), &request2, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ProxyInfo info3;
TestCompletionCallback callback3;
ProxyService::PacRequest* request3;
- rv = service.ResolveProxy(url3, LOAD_NORMAL, &info3, callback3.callback(),
- &request3, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url3, std::string(), LOAD_NORMAL, &info3,
+ callback3.callback(), &request3, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
service.GetLoadState(request1));
EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
service.GetLoadState(request2));
EXPECT_EQ(LOAD_STATE_DOWNLOADING_PROXY_SCRIPT,
@@ -2083,42 +2128,44 @@ TEST_F(ProxyServiceTest, ChangeScriptFetcherWhilePACDownloadInProgress) {
const GURL url1("http://request1");
const GURL url2("http://request2");
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 2 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url1, LOAD_NORMAL, &info1, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url1, std::string(), LOAD_NORMAL, &info1,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(url2, LOAD_NORMAL, &info2, callback2.callback(),
- NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url2, std::string(), LOAD_NORMAL, &info2,
+ callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// At this point the ProxyService should be waiting for the
// ProxyScriptFetcher to invoke its completion callback, notifying it of
// PAC script download completion.
// We now change out the ProxyService's script fetcher. We should restart
// the initialization with the new fetcher.
fetcher = new MockProxyScriptFetcher;
@@ -2142,52 +2189,53 @@ TEST_F(ProxyServiceTest, ChangeScriptFetcherWhilePACDownloadInProgress) {
// Test cancellation of a request, while the PAC script is being fetched.
TEST_F(ProxyServiceTest, CancelWhilePACFetching) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 3 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
ProxyService::PacRequest* request1;
BoundTestNetLog log1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), &request1, NULL, log1.bound());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ &request1, nullptr, log1.bound());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
ProxyInfo info2;
TestCompletionCallback callback2;
ProxyService::PacRequest* request2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), &request2, NULL,
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), &request2, nullptr,
BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ProxyInfo info3;
TestCompletionCallback callback3;
- rv = service.ResolveProxy(GURL("http://request3"), LOAD_NORMAL, &info3,
- callback3.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request3"), std::string(), LOAD_NORMAL,
+ &info3, callback3.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
// Cancel the first 2 requests.
service.CancelPacRequest(request1);
service.CancelPacRequest(request2);
// At this point the ProxyService should be waiting for the
@@ -2240,39 +2288,41 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac) {
ProxyConfig config;
config.set_auto_detect(true);
config.set_pac_url(GURL("http://foopy/proxy.pac"));
config.proxy_rules().ParseFromString("http=foopy:80"); // Won't be used.
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 2 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url1, LOAD_NORMAL, &info1, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url1, std::string(), LOAD_NORMAL, &info1,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ProxyInfo info2;
TestCompletionCallback callback2;
ProxyService::PacRequest* request2;
- rv = service.ResolveProxy(url2, LOAD_NORMAL, &info2, callback2.callback(),
- &request2, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url2, std::string(), LOAD_NORMAL, &info2,
+ callback2.callback(), &request2, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that nothing has been sent to the proxy resolver factory yet.
ASSERT_EQ(0u, factory->pending_requests().size());
// It should be trying to auto-detect first -- FAIL the autodetect during
// the script download.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
@@ -2319,39 +2369,41 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac2) {
ProxyConfig config;
config.set_auto_detect(true);
config.set_pac_url(GURL("http://foopy/proxy.pac"));
config.proxy_rules().ParseFromString("http=foopy:80"); // Won't be used.
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 2 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv = service.ResolveProxy(url1, LOAD_NORMAL, &info1, callback1.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url1, std::string(), LOAD_NORMAL, &info1,
+ callback1.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ProxyInfo info2;
TestCompletionCallback callback2;
ProxyService::PacRequest* request2;
- rv = service.ResolveProxy(url2, LOAD_NORMAL, &info2, callback2.callback(),
- &request2, NULL, BoundNetLog());
+ rv = service.ResolveProxy(url2, std::string(), LOAD_NORMAL, &info2,
+ callback2.callback(), &request2, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that nothing has been sent to the proxy resolver factory yet.
ASSERT_EQ(0u, factory->pending_requests().size());
// It should be trying to auto-detect first -- succeed the download.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
fetcher->NotifyFetchCompletion(OK, "invalid-script-contents");
@@ -2391,40 +2443,40 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac2) {
TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) {
ProxyConfig config;
config.set_auto_detect(true);
config.set_pac_url(GURL("http://foopy/proxy.pac"));
config.proxy_rules().ParseFromString("http=foopy:80");
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 2 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ProxyInfo info2;
TestCompletionCallback callback2;
ProxyService::PacRequest* request2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), &request2, NULL,
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), &request2, nullptr,
BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that nothing has been sent to the proxy resolver factory yet.
ASSERT_EQ(0u, factory->pending_requests().size());
// It should be trying to auto-detect first -- fail the download.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
@@ -2453,33 +2505,33 @@ TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
config.set_auto_detect(true);
config.set_pac_url(GURL("http://foopy/proxy.pac"));
config.proxy_rules().ParseFromString("http=foopy:80"); // Not used.
config.proxy_rules().bypass_rules.ParseFromString("www.google.com");
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 1 requests.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://www.google.com"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that nothing has been sent to the proxy resolver factory yet.
ASSERT_EQ(0u, factory->pending_requests().size());
// It should be trying to auto-detect first -- succeed the download.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
@@ -2495,22 +2547,23 @@ TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
resolver.pending_requests()[0]->CompleteNow(OK);
// Verify that request ran as expected.
EXPECT_EQ(OK, callback1.WaitForResult());
EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
// Start another request, it should pickup the bypass item.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://www.google.com"), std::string(),
+ LOAD_NORMAL, &info2, callback2.callback(), nullptr,
+ nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(GURL("http://www.google.com"),
resolver.pending_requests()[0]->url());
// Complete the pending request.
resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -2523,33 +2576,33 @@ TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
// have any memory errors (used to be that the ProxyScriptFetcher was
// being deleted prior to the InitProxyResolver).
TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingFetch) {
ProxyConfig config =
ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy/proxy.pac"));
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://www.google.com"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that nothing has been sent to the proxy resolver factory yet.
ASSERT_EQ(0u, factory->pending_requests().size());
// InitProxyResolver should have issued a request to the ProxyScriptFetcher
// and be waiting on that to complete.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
}
@@ -2559,80 +2612,82 @@ TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingFetch) {
// have any memory errors (used to be that the ProxyResolver was
// being deleted prior to the InitProxyResolver).
TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingSet) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
ProxyInfo info;
TestCompletionCallback callback;
- int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
- NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(url, std::string(), LOAD_NORMAL, &info,
+ callback.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(GURL("http://foopy/proxy.pac"),
factory->pending_requests()[0]->script_data()->url());
}
TEST_F(ProxyServiceTest, ResetProxyConfigService) {
ProxyConfig config1;
config1.proxy_rules().ParseFromString("foopy1:8080");
config1.set_auto_detect(false);
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config1)),
- nullptr, NULL);
+ nullptr, nullptr);
ProxyInfo info;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
ProxyConfig config2;
config2.proxy_rules().ParseFromString("foopy2:8080");
config2.set_auto_detect(false);
service.ResetConfigService(
make_scoped_ptr(new MockProxyConfigService(config2)));
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info, callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_EQ("foopy2:8080", info.proxy_server().ToURI());
}
// Test that when going from a configuration that required PAC to one
// that does NOT, we unset the variable |should_use_proxy_resolver_|.
TEST_F(ProxyServiceTest, UpdateConfigFromPACToDirect) {
ProxyConfig config = ProxyConfig::CreateAutoDetect();
MockProxyConfigService* config_service = new MockProxyConfigService(config);
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://www.google.com"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Successfully set the autodetect script.
EXPECT_EQ(ProxyResolverScriptData::TYPE_AUTO_DETECT,
factory->pending_requests()[0]->script_data()->type());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
// Complete the pending request.
ASSERT_EQ(1u, resolver.pending_requests().size());
resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
@@ -2645,22 +2700,23 @@ TEST_F(ProxyServiceTest, UpdateConfigFromPACToDirect) {
// Force the ProxyService to pull down a new proxy configuration.
// (Even though the configuration isn't old/bad).
//
// This new configuration no longer has auto_detect set, so
// requests should complete synchronously now as direct-connect.
config_service->SetConfig(ProxyConfig::CreateDirect());
// Start another request -- the effective configuration has changed.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://www.google.com"), std::string(),
+ LOAD_NORMAL, &info2, callback2.callback(), nullptr,
+ nullptr, BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(info2.is_direct());
}
TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
@@ -2677,23 +2733,23 @@ TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Disable the "wait after IP address changes" hack, so this unit-test can
// complete quickly.
service.set_stall_proxy_auto_config_delay(base::TimeDelta());
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered initial download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
// At this point the ProxyService should be waiting for the
@@ -2720,22 +2776,23 @@ TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
// Now simluate a change in the network. The ProxyConfigService is still
// going to return the same PAC URL as before, but this URL needs to be
// refetched on the new network.
NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
base::MessageLoop::current()->RunUntilIdle(); // Notification happens async.
// Start a second request.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// This second request should have triggered the re-download of the PAC
// script (since we marked the network as having changed).
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
@@ -2784,33 +2841,33 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) {
ProxyService::set_pac_script_poll_policy(&poll_policy);
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered initial download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
// At this point the ProxyService should be waiting for the
@@ -2855,22 +2912,23 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) {
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
// At this point the ProxyService should have re-configured itself to use the
// PAC script (thereby recovering from the initial fetch failure). We will
// verify that the next Resolve request uses the resolver rather than
// DIRECT.
// Start a second request.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that it was sent to the resolver.
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
// Complete the pending second request.
resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -2890,33 +2948,33 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentChange) {
ProxyService::set_pac_script_poll_policy(&poll_policy);
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered initial download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
// At this point the ProxyService should be waiting for the
@@ -2967,22 +3025,23 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentChange) {
EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
factory->pending_requests()[0]->script_data()->utf16());
factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
// At this point the ProxyService should have re-configured itself to use the
// new PAC script.
// Start a second request.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that it was sent to the resolver.
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
// Complete the pending second request.
resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -3002,33 +3061,33 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
ProxyService::set_pac_script_poll_policy(&poll_policy);
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered initial download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
// At this point the ProxyService should be waiting for the
@@ -3076,22 +3135,23 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
ASSERT_TRUE(factory->pending_requests().empty());
ASSERT_TRUE(resolver.pending_requests().empty());
// At this point the ProxyService is still running the same PAC script as
// before.
// Start a second request.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Check that it was sent to the resolver.
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
// Complete the pending second request.
resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
resolver.pending_requests()[0]->CompleteNow(OK);
@@ -3111,33 +3171,33 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterSuccess) {
ProxyService::set_pac_script_poll_policy(&poll_policy);
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered initial download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
// At this point the ProxyService should be waiting for the
@@ -3182,22 +3242,23 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterSuccess) {
fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
base::MessageLoop::current()->RunUntilIdle();
// At this point the ProxyService should have re-configured itself to use
// DIRECT connections rather than the given proxy resolver.
// Start a second request.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(info2.is_direct());
}
// Tests that the code which decides at what times to poll the PAC
// script follows the expected policy.
TEST_F(ProxyServiceTest, PACScriptPollingPolicy) {
// Retrieve the internal polling policy implementation used by ProxyService.
scoped_ptr<ProxyService::PacPollPolicy> policy =
ProxyService::CreateDefaultPacPollPolicy();
@@ -3265,33 +3326,33 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
ProxyService::set_pac_script_poll_policy(&poll_policy);
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolver resolver;
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(true);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
service.SetProxyScriptFetchers(
fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
// Start 1 request.
ProxyInfo info1;
TestCompletionCallback callback1;
- int rv =
- service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
- callback1.callback(), NULL, NULL, BoundNetLog());
+ int rv = service.ResolveProxy(GURL("http://request1"), std::string(),
+ LOAD_NORMAL, &info1, callback1.callback(),
+ nullptr, nullptr, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// The first request should have triggered initial download of PAC script.
EXPECT_TRUE(fetcher->has_pending_request());
EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
// Nothing has been sent to the factory yet.
EXPECT_TRUE(factory->pending_requests().empty());
// At this point the ProxyService should be waiting for the
@@ -3320,22 +3381,23 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
// Our PAC poller is set to update ONLY in response to network activity,
// (i.e. another call to ResolveProxy()).
ASSERT_FALSE(fetcher->has_pending_request());
ASSERT_TRUE(factory->pending_requests().empty());
ASSERT_TRUE(resolver.pending_requests().empty());
// Start a second request.
ProxyInfo info2;
TestCompletionCallback callback2;
- rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
- callback2.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request2"), std::string(), LOAD_NORMAL,
+ &info2, callback2.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// This request should have sent work to the resolver; complete it.
ASSERT_EQ(1u, resolver.pending_requests().size());
EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
resolver.pending_requests()[0]->CompleteNow(OK);
EXPECT_EQ(OK, callback2.WaitForResult());
EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
@@ -3350,70 +3412,71 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
// Drain the message loop, so ProxyService is notified of the change
// and has a chance to re-configure itself.
base::MessageLoop::current()->RunUntilIdle();
// Start a third request -- this time we expect to get a direct connection
// since the PAC script poller experienced a failure.
ProxyInfo info3;
TestCompletionCallback callback3;
- rv = service.ResolveProxy(GURL("http://request3"), LOAD_NORMAL, &info3,
- callback3.callback(), NULL, NULL, BoundNetLog());
+ rv = service.ResolveProxy(GURL("http://request3"), std::string(), LOAD_NORMAL,
+ &info3, callback3.callback(), nullptr, nullptr,
+ BoundNetLog());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(info3.is_direct());
}
// Test that the synchronous resolution fails when a PAC script is active.
TEST_F(ProxyServiceTest, SynchronousWithPAC) {
MockProxyConfigService* config_service =
new MockProxyConfigService("http://foopy/proxy.pac");
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(config_service),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
ProxyInfo info;
info.UseDirect();
BoundTestNetLog log;
bool synchronous_success = service.TryResolveProxySynchronously(
- url, LOAD_NORMAL, &info, NULL, log.bound());
+ url, std::string(), LOAD_NORMAL, &info, nullptr, log.bound());
EXPECT_FALSE(synchronous_success);
// |info| should not have been modified.
EXPECT_TRUE(info.is_direct());
}
// Test that synchronous results are returned correctly if a fixed proxy
// configuration is active.
TEST_F(ProxyServiceTest, SynchronousWithFixedConfiguration) {
ProxyConfig config;
config.proxy_rules().ParseFromString("foopy1:8080");
config.set_auto_detect(false);
MockAsyncProxyResolverFactory* factory =
new MockAsyncProxyResolverFactory(false);
ProxyService service(make_scoped_ptr(new MockProxyConfigService(config)),
- make_scoped_ptr(factory), NULL);
+ make_scoped_ptr(factory), nullptr);
GURL url("http://www.google.com/");
ProxyInfo info;
BoundTestNetLog log;
bool synchronous_success = service.TryResolveProxySynchronously(
- url, LOAD_NORMAL, &info, NULL, log.bound());
+ url, std::string(), LOAD_NORMAL, &info, nullptr, log.bound());
EXPECT_TRUE(synchronous_success);
EXPECT_FALSE(info.is_direct());
EXPECT_EQ("foopy1", info.proxy_server().host_port_pair().host());
// No request should have been queued.
EXPECT_EQ(0u, factory->pending_requests().size());
}
} // namespace net
« no previous file with comments | « net/proxy/proxy_service_mojo_unittest.cc ('k') | net/url_request/url_request_ftp_job.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698