blob: 0e3b2377311ace47635803c4ec4e4934e9c59f9c [file] [log] [blame]
// Copyright 2014 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 "components/data_reduction_proxy/browser/data_reduction_proxy_protocol.h"
#include <utility>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/metrics/field_trial.h"
#include "base/run_loop.h"
#include "base/strings/stringprintf.h"
#include "components/data_reduction_proxy/browser/data_reduction_proxy_params_test_utils.h"
#include "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
#include "net/base/completion_callback.h"
#include "net/base/host_port_pair.h"
#include "net/base/load_flags.h"
#include "net/base/network_delegate.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_transaction_test_util.h"
#include "net/proxy/proxy_service.h"
#include "net/socket/socket_test_util.h"
#include "net/url_request/static_http_user_agent_settings.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_test_util.h"
#include "testing/gtest/include/gtest/gtest.h"
using net::HttpResponseHeaders;
using net::HostPortPair;
using net::MockRead;
using net::MockWrite;
using net::ProxyRetryInfoMap;
using net::ProxyService;
using net::StaticSocketDataProvider;
using net::TestDelegate;
using net::URLRequest;
using net::TestURLRequestContext;
namespace {
// Transform "normal"-looking headers (\n-separated) to the appropriate
// input format for ParseRawHeaders (\0-separated).
void HeadersToRaw(std::string* headers) {
std::replace(headers->begin(), headers->end(), '\n', '\0');
if (!headers->empty())
*headers += '\0';
}
} // namespace
namespace data_reduction_proxy {
// A test network delegate that exercises the bypass logic of the data
// reduction proxy.
class TestDataReductionProxyNetworkDelegate : public net::NetworkDelegate {
public:
TestDataReductionProxyNetworkDelegate(
TestDataReductionProxyParams* test_params,
DataReductionProxyBypassType* bypass_type)
: net::NetworkDelegate(),
test_data_reduction_proxy_params_(test_params),
bypass_type_(bypass_type) {
}
virtual int OnHeadersReceived(
URLRequest* request,
const net::CompletionCallback& callback,
const HttpResponseHeaders* original_response_headers,
scoped_refptr<HttpResponseHeaders>* override_response_headers,
GURL* allowed_unsafe_redirect_url) OVERRIDE {
data_reduction_proxy::MaybeBypassProxyAndPrepareToRetry(
test_data_reduction_proxy_params_,
request,
original_response_headers,
override_response_headers,
bypass_type_);
return net::OK;
}
TestDataReductionProxyParams* test_data_reduction_proxy_params_;
DataReductionProxyBypassType* bypass_type_;
};
// Constructs a |TestURLRequestContext| that uses a |MockSocketFactory| to
// simulate requests and responses.
class DataReductionProxyProtocolTest : public testing::Test {
public:
DataReductionProxyProtocolTest() : http_user_agent_settings_("", "") {
proxy_params_.reset(
new TestDataReductionProxyParams(
DataReductionProxyParams::kAllowed |
DataReductionProxyParams::kFallbackAllowed |
DataReductionProxyParams::kPromoAllowed,
TestDataReductionProxyParams::HAS_EVERYTHING &
~TestDataReductionProxyParams::HAS_DEV_ORIGIN));
}
// Sets up the |TestURLRequestContext| with the provided |ProxyService| and
// |bypass_type| to store bypass reasons.
void ConfigureTestDependencies(ProxyService* proxy_service,
DataReductionProxyBypassType* bypass_type) {
// Create a context with delayed initialization.
context_.reset(new TestURLRequestContext(true));
proxy_service_.reset(proxy_service);
network_delegate_.reset(new TestDataReductionProxyNetworkDelegate(
proxy_params_.get(), bypass_type));
context_->set_client_socket_factory(&mock_socket_factory_);
context_->set_proxy_service(proxy_service_.get());
context_->set_network_delegate(network_delegate_.get());
// This is needed to prevent the test context from adding language headers
// to requests.
context_->set_http_user_agent_settings(&http_user_agent_settings_);
context_->Init();
}
// Simulates a request to a data reduction proxy that may result in bypassing
// the proxy and retrying the the request.
// Runs a test with the given request |method| that expects the first response
// from the server to be |first_response|. If |expected_retry|, the test
// will expect a retry of the request. A response body will be expected
// if |expect_response_body|.
void TestProxyFallback(const char* method,
const char* first_response,
bool expected_retry,
bool expect_response_body) {
std::string payload1 =
(expected_retry ? "Bypass message" : "content");
MockRead data_reads[] = {
MockRead(first_response),
MockRead(payload1.c_str()),
MockRead(net::SYNCHRONOUS, net::OK),
};
std::string m(method);
std::string trailer =
(m == "HEAD" || m == "PUT" || m == "POST") ?
"Content-Length: 0\r\n" : "";
std::string request1 =
base::StringPrintf("%s http://www.google.com/ HTTP/1.1\r\n"
"Host: www.google.com\r\n"
"Proxy-Connection: keep-alive\r\n%s"
"User-Agent:\r\n"
"Accept-Encoding: gzip,deflate\r\n\r\n",
method, trailer.c_str());
MockWrite data_writes[] = {
MockWrite(request1.c_str()),
};
StaticSocketDataProvider data1(data_reads, arraysize(data_reads),
data_writes, arraysize(data_writes));
mock_socket_factory_.AddSocketDataProvider(&data1);
MockRead data_reads2[] = {
MockRead("HTTP/1.0 200 OK\r\n"
"Server: not-proxy\r\n\r\n"),
MockRead("content"),
MockRead(net::SYNCHRONOUS, net::OK),
};
std::string request2 =
base::StringPrintf("%s / HTTP/1.1\r\n"
"Host: www.google.com\r\n"
"Connection: keep-alive\r\n%s"
"User-Agent:\r\n"
"Accept-Encoding: gzip,deflate\r\n\r\n",
method, trailer.c_str());
MockWrite data_writes2[] = {
MockWrite(request2.c_str()),
};
StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
data_writes2, arraysize(data_writes2));
if (expected_retry) {
mock_socket_factory_.AddSocketDataProvider(&data2);
}
// Expect that we get "content" and not "Bypass message", and that there's
// a "not-proxy" "Server:" header in the final response.
ExecuteRequestExpectingContentAndHeader(
method,
(expect_response_body ? "content" : ""),
"server",
(expected_retry == 0 ? "proxy" : "not-proxy"),
expected_retry);
}
// Starts a request with the given |method| and checks that the response
// contains |content| and the the header |header|: |value|, if |header| is
// non-empty. Verifies that the request's URL chain is the right length
// depending on whether or not a retry was expected (|expected_retry|).
void ExecuteRequestExpectingContentAndHeader(const std::string& method,
const std::string& content,
const std::string& header,
const std::string& value,
bool expected_retry) {
TestDelegate d;
scoped_ptr<URLRequest> r(context_->CreateRequest(
GURL("http://www.google.com/"),
net::DEFAULT_PRIORITY,
&d,
NULL));
r->set_method(method);
r->SetLoadFlags(net::LOAD_NORMAL);
r->Start();
base::RunLoop().Run();
EXPECT_EQ(net::URLRequestStatus::SUCCESS, r->status().status());
EXPECT_EQ(net::OK, r->status().error());
if (expected_retry)
EXPECT_EQ(2U, r->url_chain().size());
else
EXPECT_EQ(1U, r->url_chain().size());
if (!header.empty()) {
// We also have a server header here that isn't set by the proxy.
EXPECT_TRUE(r->response_headers()->HasHeaderValue(header, value));
}
EXPECT_EQ(content, d.data_received());
}
// Returns the key to the |ProxyRetryInfoMap|.
std::string GetProxyKey(std::string proxy) {
GURL gurl(proxy);
std::string host_port = HostPortPair::FromURL(GURL(proxy)).ToString();
if (gurl.SchemeIs("https"))
return "https://" + host_port;
return host_port;
}
// Checks that |expected_num_bad_proxies| proxies are on the proxy retry list.
// If the list has one proxy, it should match |bad_proxy|. If it has two
// proxies, it should match |bad_proxy| and |bad_proxy2|. Checks also that
// the current delay associated with each bad proxy is |duration_seconds|.
void TestBadProxies(unsigned int expected_num_bad_proxies,
int duration_seconds,
const std::string& bad_proxy,
const std::string& bad_proxy2) {
const ProxyRetryInfoMap& retry_info = proxy_service_->proxy_retry_info();
ASSERT_EQ(expected_num_bad_proxies, retry_info.size());
base::TimeDelta expected_min_duration;
base::TimeDelta expected_max_duration;
if (duration_seconds == 0) {
expected_min_duration = base::TimeDelta::FromMinutes(1);
expected_max_duration = base::TimeDelta::FromMinutes(5);
} else {
expected_min_duration = base::TimeDelta::FromSeconds(duration_seconds);
expected_max_duration = base::TimeDelta::FromSeconds(duration_seconds);
}
if (expected_num_bad_proxies >= 1u) {
ProxyRetryInfoMap::const_iterator i =
retry_info.find(GetProxyKey(bad_proxy));
ASSERT_TRUE(i != retry_info.end());
EXPECT_TRUE(expected_min_duration <= (*i).second.current_delay);
EXPECT_TRUE((*i).second.current_delay <= expected_max_duration);
}
if (expected_num_bad_proxies == 2u) {
ProxyRetryInfoMap::const_iterator i =
retry_info.find(GetProxyKey(bad_proxy2));
ASSERT_TRUE(i != retry_info.end());
EXPECT_TRUE(expected_min_duration <= (*i).second.current_delay);
EXPECT_TRUE((*i).second.current_delay <= expected_max_duration);
}
}
protected:
base::MessageLoopForIO loop_;
net::MockClientSocketFactory mock_socket_factory_;
scoped_ptr<ProxyService> proxy_service_;
scoped_ptr<TestDataReductionProxyParams> proxy_params_;
scoped_ptr<TestDataReductionProxyNetworkDelegate> network_delegate_;
net::StaticHttpUserAgentSettings http_user_agent_settings_;
scoped_ptr<TestURLRequestContext> context_;
};
// Tests that request are deemed idempotent or not according to the method used.
TEST_F(DataReductionProxyProtocolTest, TestIdempotency) {
net::TestURLRequestContext context;
const struct {
const char* method;
bool expected_result;
} tests[] = {
{ "GET", true },
{ "OPTIONS", true },
{ "HEAD", true },
{ "PUT", true },
{ "DELETE", true },
{ "TRACE", true },
{ "POST", false },
{ "CONNECT", false },
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
net::TestURLRequest request(GURL("http://www.google.com/"),
net::DEFAULT_PRIORITY,
NULL,
&context);
request.set_method(tests[i].method);
EXPECT_EQ(tests[i].expected_result, IsRequestIdempotent(&request));
}
}
// Tests that the response is correctly overwritten as a redirect.
TEST_F(DataReductionProxyProtocolTest, OverrideResponseAsRedirect) {
net::TestURLRequestContext context;
const struct {
const char* headers;
const char* expected_headers;
} tests[] = {
{ "HTTP/1.1 200 0K\n"
"Chrome-Proxy: block=1\n"
"Via: 1.1 Chrome-Compression-Proxy\n",
"HTTP/1.1 302 Found\n"
"Chrome-Proxy: block=1\n"
"Via: 1.1 Chrome-Compression-Proxy\n"
"Location: http://www.google.com/\n"
},
{ "HTTP/1.1 200 0K\n"
"Chrome-Proxy: block-once\n"
"Via: 1.1 Chrome-Compression-Proxy\n",
"HTTP/1.1 302 Found\n"
"Chrome-Proxy: block-once\n"
"Via: 1.1 Chrome-Compression-Proxy\n"
"Location: http://www.google.com/\n"
},
{ "HTTP/1.1 302 Found\n"
"Location: http://foo.com/\n",
"HTTP/1.1 302 Found\n"
"Location: http://www.google.com/\n"
},
};
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
std::string headers(tests[i].headers);
HeadersToRaw(&headers);
scoped_refptr<HttpResponseHeaders> original_response_headers(
new HttpResponseHeaders(headers));
scoped_refptr<HttpResponseHeaders> override_response_headers;
TestDelegate test_delegate;
net::TestURLRequest request(GURL("http://www.google.com/"),
net::DEFAULT_PRIORITY,
NULL,
&context);
OverrideResponseAsRedirect(
&request, original_response_headers.get(), &override_response_headers);
int expected_flags = net::LOAD_DISABLE_CACHE | net::LOAD_BYPASS_PROXY;
EXPECT_EQ(expected_flags, request.load_flags());
std::string override_headers;
override_response_headers->GetNormalizedHeaders(&override_headers);
EXPECT_EQ(std::string(tests[i].expected_headers), override_headers);
}
}
// After each test, the proxy retry info will contain zero, one, or two of the
// data reduction proxies depending on whether no bypass was indicated by the
// initial response, a single proxy bypass was indicated, or a double bypass
// was indicated. In both the single and double bypass cases, if the request
// was idempotent, it will be retried over a direct connection.
TEST_F(DataReductionProxyProtocolTest, BypassLogic) {
const struct {
const char* method;
const char* first_response;
bool expected_retry;
size_t expected_bad_proxy_count;
bool expect_response_body;
int expected_duration;
DataReductionProxyBypassType expected_bypass_type;
} tests[] = {
// Valid data reduction proxy response with no bypass message.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
false,
0u,
true,
-1,
BYPASS_EVENT_TYPE_MAX,
},
// Valid data reduction proxy response with older, but still valid via
// header.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Via: 1.1 Chrome Compression Proxy\r\n\r\n",
false,
0u,
true,
-1,
BYPASS_EVENT_TYPE_MAX
},
// Valid data reduction proxy response with chained via header,
// no bypass message.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Via: 1.1 Chrome-Compression-Proxy, 1.0 some-other-proxy\r\n\r\n",
false,
0u,
true,
-1,
BYPASS_EVENT_TYPE_MAX
},
// Valid data reduction proxy response with a bypass message.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=0\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_MEDIUM
},
// Valid data reduction proxy response with a bypass message.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=1\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
1,
BYPASS_EVENT_TYPE_SHORT
},
// Same as above with the OPTIONS method, which is idempotent.
{ "OPTIONS",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=0\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_MEDIUM
},
// Same as above with the HEAD method, which is idempotent.
{ "HEAD",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=0\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
false,
0,
BYPASS_EVENT_TYPE_MEDIUM
},
// Same as above with the PUT method, which is idempotent.
{ "PUT",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=0\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_MEDIUM
},
// Same as above with the DELETE method, which is idempotent.
{ "DELETE",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=0\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_MEDIUM
},
// Same as above with the TRACE method, which is idempotent.
{ "TRACE",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=0\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_MEDIUM
},
// 500 responses should be bypassed.
{ "GET",
"HTTP/1.1 500 Internal Server Error\r\n"
"Server: proxy\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_STATUS_500_HTTP_INTERNAL_SERVER_ERROR
},
// 502 responses should be bypassed.
{ "GET",
"HTTP/1.1 502 Internal Server Error\r\n"
"Server: proxy\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_STATUS_502_HTTP_BAD_GATEWAY
},
// 503 responses should be bypassed.
{ "GET",
"HTTP/1.1 503 Internal Server Error\r\n"
"Server: proxy\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_STATUS_503_HTTP_SERVICE_UNAVAILABLE
},
// Invalid data reduction proxy response. Missing Via header.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_MISSING_VIA_HEADER_OTHER
},
// Invalid data reduction proxy response. Wrong Via header.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Via: 1.0 some-other-proxy\r\n\r\n",
true,
1u,
true,
0,
BYPASS_EVENT_TYPE_MISSING_VIA_HEADER_OTHER
},
// Valid data reduction proxy response. 304 missing Via header.
{ "GET",
"HTTP/1.1 304 Not Modified\r\n"
"Server: proxy\r\n\r\n",
false,
0u,
false,
0,
BYPASS_EVENT_TYPE_MAX
},
// Valid data reduction proxy response with a bypass message. It will
// not be retried because the request is non-idempotent.
{ "POST",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=0\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
false,
1u,
true,
0,
BYPASS_EVENT_TYPE_MEDIUM
},
// Valid data reduction proxy response with block message. Both proxies
// should be on the retry list when it completes.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block=1\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
2u,
true,
1,
BYPASS_EVENT_TYPE_SHORT
},
// Valid data reduction proxy response with a block-once message. It will be
// retried, and there will be no proxies on the retry list since block-once
// only affects the current request.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
0u,
true,
0,
BYPASS_EVENT_TYPE_CURRENT
},
// Same as above with the OPTIONS method, which is idempotent.
{ "OPTIONS",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
0u,
true,
0,
BYPASS_EVENT_TYPE_CURRENT
},
// Same as above with the HEAD method, which is idempotent.
{ "HEAD",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
0u,
false,
0,
BYPASS_EVENT_TYPE_CURRENT
},
// Same as above with the PUT method, which is idempotent.
{ "PUT",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
0u,
true,
0,
BYPASS_EVENT_TYPE_CURRENT
},
// Same as above with the DELETE method, which is idempotent.
{ "DELETE",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
0u,
true,
0,
BYPASS_EVENT_TYPE_CURRENT
},
// Same as above with the TRACE method, which is idempotent.
{ "TRACE",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
0u,
true,
0,
BYPASS_EVENT_TYPE_CURRENT
},
// Valid data reduction proxy response with a block-once message. It will
// not be retried because the request is non-idempotent, and there will be
// no proxies on the retry list since block-once only affects the current
// request.
{ "POST",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
false,
0u,
true,
0,
BYPASS_EVENT_TYPE_CURRENT
},
// Valid data reduction proxy response with block and block-once messages.
// The block message will override the block-once message, so both proxies
// should be on the retry list when it completes.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: block=1, block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
2u,
true,
1,
BYPASS_EVENT_TYPE_SHORT
},
// Valid data reduction proxy response with bypass and block-once messages.
// The bypass message will override the block-once message, so one proxy
// should be on the retry list when it completes.
{ "GET",
"HTTP/1.1 200 OK\r\n"
"Server: proxy\r\n"
"Chrome-Proxy: bypass=1, block-once\r\n"
"Via: 1.1 Chrome-Compression-Proxy\r\n\r\n",
true,
1u,
true,
1,
BYPASS_EVENT_TYPE_SHORT
},
};
std::string primary = proxy_params_->DefaultOrigin();
std::string fallback = proxy_params_->DefaultFallbackOrigin();
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
DataReductionProxyBypassType bypass_type;
ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult(
"PROXY " +
HostPortPair::FromURL(GURL(primary)).ToString() + "; PROXY " +
HostPortPair::FromURL(GURL(fallback)).ToString() + "; DIRECT"),
&bypass_type);
TestProxyFallback(tests[i].method,
tests[i].first_response,
tests[i].expected_retry,
tests[i].expect_response_body);
EXPECT_EQ(tests[i].expected_bypass_type, bypass_type);
// We should also observe the bad proxy in the retry list.
TestBadProxies(tests[i].expected_bad_proxy_count,
tests[i].expected_duration,
primary, fallback);
}
}
TEST_F(DataReductionProxyProtocolTest,
ProxyBypassIgnoredOnDirectConnection) {
// Verify that a Chrome-Proxy header is ignored when returned from a directly
// connected origin server.
ConfigureTestDependencies(ProxyService::CreateFixedFromPacResult("DIRECT"),
NULL);
MockRead data_reads[] = {
MockRead("HTTP/1.1 200 OK\r\n"
"Chrome-Proxy: bypass=0\r\n\r\n"),
MockRead("Bypass message"),
MockRead(net::SYNCHRONOUS, net::OK),
};
MockWrite data_writes[] = {
MockWrite("GET / HTTP/1.1\r\n"
"Host: www.google.com\r\n"
"Connection: keep-alive\r\n"
"User-Agent:\r\n"
"Accept-Encoding: gzip,deflate\r\n\r\n"),
};
StaticSocketDataProvider data1(data_reads, arraysize(data_reads),
data_writes, arraysize(data_writes));
mock_socket_factory_.AddSocketDataProvider(&data1);
TestDelegate d;
scoped_ptr<URLRequest> r(context_->CreateRequest(
GURL("http://www.google.com/"),
net::DEFAULT_PRIORITY,
&d,
NULL));
r->set_method("GET");
r->SetLoadFlags(net::LOAD_NORMAL);
r->Start();
base::RunLoop().Run();
EXPECT_EQ(net::URLRequestStatus::SUCCESS, r->status().status());
EXPECT_EQ(net::OK, r->status().error());
EXPECT_EQ("Bypass message", d.data_received());
// We should have no entries in our bad proxy list.
TestBadProxies(0, -1, "", "");
}
class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
public:
virtual ~BadEntropyProvider() {}
virtual double GetEntropyForTrial(const std::string& trial_name,
uint32 randomization_seed) const OVERRIDE {
return 0.5;
}
};
TEST_F(DataReductionProxyProtocolTest, OnResolveProxyHandler) {
int load_flags = net::LOAD_NORMAL;
GURL url("http://www.google.com/");
TestDataReductionProxyParams test_params(
DataReductionProxyParams::kAllowed |
DataReductionProxyParams::kFallbackAllowed |
DataReductionProxyParams::kPromoAllowed,
TestDataReductionProxyParams::HAS_EVERYTHING &
~TestDataReductionProxyParams::HAS_DEV_ORIGIN);
// Data reduction proxy info
net::ProxyInfo data_reduction_proxy_info;
std::string data_reduction_proxy;
base::TrimString(test_params.DefaultOrigin(), "/", &data_reduction_proxy);
data_reduction_proxy_info.UseNamedProxy(data_reduction_proxy);
EXPECT_FALSE(data_reduction_proxy_info.is_empty());
// Data reduction proxy config
net::ProxyConfig data_reduction_proxy_config;
data_reduction_proxy_config.proxy_rules().ParseFromString(
"http=" + data_reduction_proxy + ",direct://;");
data_reduction_proxy_config.set_id(1);
// Other proxy info
net::ProxyInfo other_proxy_info;
other_proxy_info.UseNamedProxy("proxy.com");
EXPECT_FALSE(other_proxy_info.is_empty());
// Direct
net::ProxyInfo direct_proxy_info;
direct_proxy_info.UseDirect();
EXPECT_TRUE(direct_proxy_info.is_direct());
// Empty retry info map
net::ProxyRetryInfoMap empty_proxy_retry_info;
// Retry info map with the data reduction proxy;
net::ProxyRetryInfoMap data_reduction_proxy_retry_info;
net::ProxyRetryInfo retry_info;
retry_info.current_delay = base::TimeDelta::FromSeconds(1000);
retry_info.bad_until = base::TimeTicks().Now() + retry_info.current_delay;
retry_info.try_while_bad = false;
data_reduction_proxy_retry_info[
data_reduction_proxy_info.proxy_server().ToURI()] = retry_info;
net::ProxyInfo result;
// The data reduction proxy is used. It should be used afterwards.
result.Use(data_reduction_proxy_info);
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params, &result);
EXPECT_EQ(data_reduction_proxy_info.proxy_server(), result.proxy_server());
// Another proxy is used. It should be used afterwards.
result.Use(other_proxy_info);
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params, &result);
EXPECT_EQ(other_proxy_info.proxy_server(), result.proxy_server());
// A direct connection is used. The data reduction proxy should be used
// afterwards.
// Another proxy is used. It should be used afterwards.
result.Use(direct_proxy_info);
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params, &result);
EXPECT_EQ(data_reduction_proxy_info.proxy_server(), result.proxy_server());
// A direct connection is used, but the data reduction proxy is on the retry
// list. A direct connection should be used afterwards.
result.Use(direct_proxy_info);
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
data_reduction_proxy_retry_info, &test_params,
&result);
EXPECT_TRUE(result.proxy_server().is_direct());
// Without DataCompressionProxyCriticalBypass Finch trial set, should never
// bypass.
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&data_reduction_proxy_info);
EXPECT_FALSE(data_reduction_proxy_info.is_direct());
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&other_proxy_info);
EXPECT_FALSE(other_proxy_info.is_direct());
load_flags |= net::LOAD_BYPASS_DATA_REDUCTION_PROXY;
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&data_reduction_proxy_info);
EXPECT_FALSE(data_reduction_proxy_info.is_direct());
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&other_proxy_info);
EXPECT_FALSE(other_proxy_info.is_direct());
// With Finch trial set, should only bypass if LOAD flag is set and the
// effective proxy is the data compression proxy.
base::FieldTrialList field_trial_list(new BadEntropyProvider());
base::FieldTrialList::CreateFieldTrial("DataCompressionProxyRollout",
"Enabled");
base::FieldTrialList::CreateFieldTrial("DataCompressionProxyCriticalBypass",
"Enabled");
EXPECT_TRUE(
DataReductionProxyParams::IsIncludedInCriticalPathBypassFieldTrial());
load_flags = net::LOAD_NORMAL;
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&data_reduction_proxy_info);
EXPECT_FALSE(data_reduction_proxy_info.is_direct());
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&other_proxy_info);
EXPECT_FALSE(other_proxy_info.is_direct());
load_flags |= net::LOAD_BYPASS_DATA_REDUCTION_PROXY;
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&other_proxy_info);
EXPECT_FALSE(other_proxy_info.is_direct());
OnResolveProxyHandler(url, load_flags, data_reduction_proxy_config,
empty_proxy_retry_info, &test_params,
&data_reduction_proxy_info);
EXPECT_TRUE(data_reduction_proxy_info.is_direct());
}
} // namespace data_reduction_proxy