blob: e025824b74841395655faed4afbdb285cac098b6 [file] [log] [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/url_request/url_request_test_util.h"
#include <memory>
#include <utility>
#include "base/check_op.h"
#include "base/compiler_specific.h"
#include "base/location.h"
#include "base/run_loop.h"
#include "base/supports_user_data.h"
#include "base/task/single_thread_task_runner.h"
#include "base/threading/thread.h"
#include "net/base/host_port_pair.h"
#include "net/cert/cert_verifier.h"
#include "net/cert/do_nothing_ct_verifier.h"
#include "net/cookies/cookie_setting_override.h"
#include "net/dns/mock_host_resolver.h"
#include "net/http/http_network_session.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_server_properties.h"
#include "net/http/transport_security_state.h"
#include "net/proxy_resolution/configured_proxy_resolution_service.h"
#include "net/proxy_resolution/proxy_retry_info.h"
#include "net/quic/quic_context.h"
#include "net/url_request/static_http_user_agent_settings.h"
#include "net/url_request/url_request_context_builder.h"
#include "net/url_request/url_request_filter.h"
#include "net/url_request/url_request_job.h"
#include "net/url_request/url_request_job_factory.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
// These constants put the NetworkDelegate events of TestNetworkDelegate
// into an order. They are used in conjunction with
// |TestNetworkDelegate::next_states_| to check that we do not send
// events in the wrong order.
const int kStageBeforeURLRequest = 1 << 0;
const int kStageBeforeStartTransaction = 1 << 1;
const int kStageHeadersReceived = 1 << 2;
const int kStageBeforeRedirect = 1 << 3;
const int kStageResponseStarted = 1 << 4;
const int kStageCompletedSuccess = 1 << 5;
const int kStageCompletedError = 1 << 6;
const int kStageURLRequestDestroyed = 1 << 7;
const int kStageDestruction = 1 << 8;
const char kTestNetworkDelegateRequestIdKey[] =
"TestNetworkDelegateRequestIdKey";
class TestRequestId : public base::SupportsUserData::Data {
public:
explicit TestRequestId(int id) : id_(id) {}
~TestRequestId() override = default;
int id() const { return id_; }
private:
const int id_;
};
} // namespace
std::unique_ptr<URLRequestContextBuilder> CreateTestURLRequestContextBuilder() {
auto builder = std::make_unique<URLRequestContextBuilder>();
builder->set_host_resolver(std::make_unique<MockCachingHostResolver>(
/*cache_invalidation_num=*/0,
/*default_result=*/MockHostResolverBase::RuleResolver::
GetLocalhostResult()));
builder->set_proxy_resolution_service(
ConfiguredProxyResolutionService::CreateDirect());
builder->SetCertVerifier(
CertVerifier::CreateDefault(/*cert_net_fetcher=*/nullptr));
builder->set_ssl_config_service(std::make_unique<SSLConfigServiceDefaults>());
builder->SetHttpAuthHandlerFactory(HttpAuthHandlerFactory::CreateDefault());
builder->SetHttpServerProperties(std::make_unique<HttpServerProperties>());
builder->set_quic_context(std::make_unique<QuicContext>());
builder->SetCookieStore(std::make_unique<CookieMonster>(/*store=*/nullptr,
/*netlog=*/nullptr));
builder->set_http_user_agent_settings(
std::make_unique<StaticHttpUserAgentSettings>("en-us,fr", std::string()));
return builder;
}
TestURLRequestContextGetter::TestURLRequestContextGetter(
const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner)
: network_task_runner_(network_task_runner) {
DCHECK(network_task_runner_.get());
}
TestURLRequestContextGetter::TestURLRequestContextGetter(
const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
std::unique_ptr<URLRequestContext> context)
: network_task_runner_(network_task_runner), context_(std::move(context)) {
DCHECK(network_task_runner_.get());
}
TestURLRequestContextGetter::~TestURLRequestContextGetter() = default;
URLRequestContext* TestURLRequestContextGetter::GetURLRequestContext() {
if (is_shut_down_)
return nullptr;
if (!context_.get())
context_ = CreateTestURLRequestContextBuilder()->Build();
return context_.get();
}
void TestURLRequestContextGetter::NotifyContextShuttingDown() {
// This should happen before call to base NotifyContextShuttingDown() per that
// method's doc comments.
is_shut_down_ = true;
URLRequestContextGetter::NotifyContextShuttingDown();
context_ = nullptr;
}
scoped_refptr<base::SingleThreadTaskRunner>
TestURLRequestContextGetter::GetNetworkTaskRunner() const {
return network_task_runner_;
}
const int TestDelegate::kBufferSize;
TestDelegate::TestDelegate()
: buf_(base::MakeRefCounted<IOBufferWithSize>(kBufferSize)) {}
TestDelegate::~TestDelegate() = default;
void TestDelegate::RunUntilComplete() {
base::RunLoop run_loop;
on_complete_ = run_loop.QuitClosure();
run_loop.Run();
}
void TestDelegate::RunUntilRedirect() {
base::RunLoop run_loop;
on_redirect_ = run_loop.QuitClosure();
run_loop.Run();
}
void TestDelegate::RunUntilAuthRequired() {
base::RunLoop run_loop;
on_auth_required_ = run_loop.QuitClosure();
run_loop.Run();
}
int TestDelegate::OnConnected(URLRequest* request,
const TransportInfo& info,
CompletionOnceCallback callback) {
transports_.push_back(info);
if (on_connected_run_callback_) {
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), on_connected_result_));
return net::ERR_IO_PENDING;
}
return on_connected_result_;
}
void TestDelegate::OnReceivedRedirect(URLRequest* request,
const RedirectInfo& redirect_info,
bool* defer_redirect) {
EXPECT_TRUE(request->is_redirecting());
redirect_info_ = redirect_info;
received_redirect_count_++;
if (on_redirect_) {
*defer_redirect = true;
std::move(on_redirect_).Run();
} else if (cancel_in_rr_) {
request->Cancel();
}
}
void TestDelegate::OnAuthRequired(URLRequest* request,
const AuthChallengeInfo& auth_info) {
auth_required_ = true;
if (on_auth_required_) {
std::move(on_auth_required_).Run();
return;
}
if (!credentials_.Empty()) {
request->SetAuth(credentials_);
} else {
request->CancelAuth();
}
}
void TestDelegate::OnSSLCertificateError(URLRequest* request,
int net_error,
const SSLInfo& ssl_info,
bool fatal) {
// The caller can control whether it needs all SSL requests to go through,
// independent of any possible errors, or whether it wants SSL errors to
// cancel the request.
have_certificate_errors_ = true;
certificate_errors_are_fatal_ = fatal;
certificate_net_error_ = net_error;
if (allow_certificate_errors_)
request->ContinueDespiteLastError();
else
request->Cancel();
}
void TestDelegate::OnResponseStarted(URLRequest* request, int net_error) {
// It doesn't make sense for the request to have IO pending at this point.
DCHECK_NE(ERR_IO_PENDING, net_error);
EXPECT_FALSE(request->is_redirecting());
response_started_count_++;
request_status_ = net_error;
if (cancel_in_rs_) {
request_status_ = request->Cancel();
// Canceling |request| will cause OnResponseCompleted() to be called.
} else if (net_error != OK) {
request_failed_ = true;
OnResponseCompleted(request);
} else {
// Initiate the first read.
int bytes_read = request->Read(buf_.get(), kBufferSize);
if (bytes_read >= 0)
OnReadCompleted(request, bytes_read);
else if (bytes_read != ERR_IO_PENDING)
OnResponseCompleted(request);
}
}
void TestDelegate::OnReadCompleted(URLRequest* request, int bytes_read) {
// It doesn't make sense for the request to have IO pending at this point.
DCHECK_NE(bytes_read, ERR_IO_PENDING);
// If you've reached this, you've either called "RunUntilComplete"
// If this DCHECK fails, that probably means you've run
// "RunUntilRedirect" or "RunUntilAuthRequired" and haven't
// redirected/auth-challenged
DCHECK(on_complete_);
// If the request was cancelled in a redirect, it should not signal
// OnReadCompleted. Note that |cancel_in_rs_| may be true due to
// https://crbug.com/564848.
EXPECT_FALSE(cancel_in_rr_);
if (response_started_count_ == 0)
received_data_before_response_ = true;
if (bytes_read >= 0) {
// There is data to read.
received_bytes_count_ += bytes_read;
// Consume the data.
data_received_.append(buf_->data(), bytes_read);
if (cancel_in_rd_) {
request_status_ = request->Cancel();
// If bytes_read is 0, won't get a notification on cancelation.
if (bytes_read == 0) {
std::move(on_complete_).Run();
}
return;
}
}
// If it was not end of stream, request to read more.
while (bytes_read > 0) {
bytes_read = request->Read(buf_.get(), kBufferSize);
if (bytes_read > 0) {
data_received_.append(buf_->data(), bytes_read);
received_bytes_count_ += bytes_read;
}
}
request_status_ = bytes_read;
if (request_status_ != ERR_IO_PENDING)
OnResponseCompleted(request);
else if (cancel_in_rd_pending_)
request_status_ = request->Cancel();
}
void TestDelegate::OnResponseCompleted(URLRequest* request) {
response_completed_ = true;
std::move(on_complete_).Run();
}
TestNetworkDelegate::TestNetworkDelegate() = default;
TestNetworkDelegate::~TestNetworkDelegate() {
for (auto i = next_states_.begin(); i != next_states_.end(); ++i) {
event_order_[i->first] += "~TestNetworkDelegate\n";
EXPECT_TRUE(i->second & kStageDestruction) << event_order_[i->first];
}
}
bool TestNetworkDelegate::GetLoadTimingInfoBeforeRedirect(
LoadTimingInfo* load_timing_info_before_redirect) const {
*load_timing_info_before_redirect = load_timing_info_before_redirect_;
return has_load_timing_info_before_redirect_;
}
void TestNetworkDelegate::InitRequestStatesIfNew(int request_id) {
if (next_states_.find(request_id) == next_states_.end()) {
// TODO(davidben): Although the URLRequest documentation does not allow
// calling Cancel() before Start(), the ResourceLoader does so. URLRequest's
// destructor also calls Cancel. Either officially support this or fix the
// ResourceLoader code.
next_states_[request_id] = kStageBeforeURLRequest | kStageCompletedError;
event_order_[request_id] = "";
}
}
int TestNetworkDelegate::OnBeforeURLRequest(URLRequest* request,
CompletionOnceCallback callback,
GURL* new_url) {
int req_id = GetRequestId(request);
InitRequestStatesIfNew(req_id);
event_order_[req_id] += "OnBeforeURLRequest\n";
EXPECT_TRUE(next_states_[req_id] & kStageBeforeURLRequest) <<
event_order_[req_id];
next_states_[req_id] =
kStageBeforeStartTransaction |
kStageResponseStarted | // data: URLs do not trigger sending headers
kStageBeforeRedirect | // a delegate can trigger a redirection
kStageCompletedError; // request canceled by delegate
created_requests_++;
return OK;
}
int TestNetworkDelegate::OnBeforeStartTransaction(
URLRequest* request,
const HttpRequestHeaders& headers,
OnBeforeStartTransactionCallback callback) {
if (before_start_transaction_fails_)
return ERR_FAILED;
int req_id = GetRequestId(request);
InitRequestStatesIfNew(req_id);
event_order_[req_id] += "OnBeforeStartTransaction\n";
EXPECT_TRUE(next_states_[req_id] & kStageBeforeStartTransaction)
<< event_order_[req_id];
next_states_[req_id] =
kStageHeadersReceived | kStageCompletedError | kStageBeforeRedirect;
before_start_transaction_count_++;
return OK;
}
int TestNetworkDelegate::OnHeadersReceived(
URLRequest* request,
CompletionOnceCallback callback,
const HttpResponseHeaders* original_response_headers,
scoped_refptr<HttpResponseHeaders>* override_response_headers,
const IPEndPoint& endpoint,
std::optional<GURL>* preserve_fragment_on_redirect_url) {
EXPECT_FALSE(preserve_fragment_on_redirect_url->has_value());
int req_id = GetRequestId(request);
bool is_first_response =
event_order_[req_id].find("OnHeadersReceived\n") == std::string::npos;
event_order_[req_id] += "OnHeadersReceived\n";
InitRequestStatesIfNew(req_id);
EXPECT_TRUE(next_states_[req_id] & kStageHeadersReceived) <<
event_order_[req_id];
next_states_[req_id] =
kStageBeforeRedirect |
kStageResponseStarted |
kStageCompletedError; // e.g. proxy resolution problem
// Basic authentication sends a second request from the URLRequestHttpJob
// layer before the URLRequest reports that a response has started.
next_states_[req_id] |= kStageBeforeStartTransaction;
if (!redirect_on_headers_received_url_.is_empty()) {
*override_response_headers = base::MakeRefCounted<HttpResponseHeaders>(
original_response_headers->raw_headers());
(*override_response_headers)->ReplaceStatusLine("HTTP/1.1 302 Found");
(*override_response_headers)->RemoveHeader("Location");
(*override_response_headers)
->AddHeader("Location", redirect_on_headers_received_url_.spec());
redirect_on_headers_received_url_ = GURL();
// Since both values are std::optionals, can just copy this over.
*preserve_fragment_on_redirect_url = preserve_fragment_on_redirect_url_;
} else if (add_header_to_first_response_ && is_first_response) {
*override_response_headers = base::MakeRefCounted<HttpResponseHeaders>(
original_response_headers->raw_headers());
(*override_response_headers)
->AddHeader("X-Network-Delegate", "Greetings, planet");
}
headers_received_count_++;
return OK;
}
void TestNetworkDelegate::OnBeforeRedirect(URLRequest* request,
const GURL& new_location) {
load_timing_info_before_redirect_ = LoadTimingInfo();
request->GetLoadTimingInfo(&load_timing_info_before_redirect_);
has_load_timing_info_before_redirect_ = true;
EXPECT_FALSE(load_timing_info_before_redirect_.request_start_time.is_null());
EXPECT_FALSE(load_timing_info_before_redirect_.request_start.is_null());
int req_id = GetRequestId(request);
InitRequestStatesIfNew(req_id);
event_order_[req_id] += "OnBeforeRedirect\n";
EXPECT_TRUE(next_states_[req_id] & kStageBeforeRedirect) <<
event_order_[req_id];
next_states_[req_id] =
kStageBeforeURLRequest | // HTTP redirects trigger this.
kStageBeforeStartTransaction | // Redirects from the network delegate do
// not
// trigger onBeforeURLRequest.
kStageCompletedError;
// A redirect can lead to a file or a data URL. In this case, we do not send
// headers.
next_states_[req_id] |= kStageResponseStarted;
}
void TestNetworkDelegate::OnResponseStarted(URLRequest* request,
int net_error) {
DCHECK_NE(ERR_IO_PENDING, net_error);
LoadTimingInfo load_timing_info;
request->GetLoadTimingInfo(&load_timing_info);
EXPECT_FALSE(load_timing_info.request_start_time.is_null());
EXPECT_FALSE(load_timing_info.request_start.is_null());
int req_id = GetRequestId(request);
InitRequestStatesIfNew(req_id);
event_order_[req_id] += "OnResponseStarted\n";
EXPECT_TRUE(next_states_[req_id] & kStageResponseStarted)
<< event_order_[req_id];
next_states_[req_id] = kStageCompletedSuccess | kStageCompletedError;
if (net_error == ERR_ABORTED)
return;
if (net_error != OK) {
error_count_++;
last_error_ = net_error;
}
}
void TestNetworkDelegate::OnCompleted(URLRequest* request,
bool started,
int net_error) {
DCHECK_NE(net_error, net::ERR_IO_PENDING);
int req_id = GetRequestId(request);
InitRequestStatesIfNew(req_id);
event_order_[req_id] += "OnCompleted\n";
// Expect "Success -> (next_states_ & kStageCompletedSuccess)"
// is logically identical to
// Expect "!(Success) || (next_states_ & kStageCompletedSuccess)"
EXPECT_TRUE(net_error != OK ||
(next_states_[req_id] & kStageCompletedSuccess))
<< event_order_[req_id];
EXPECT_TRUE(net_error == OK || (next_states_[req_id] & kStageCompletedError))
<< event_order_[req_id];
next_states_[req_id] = kStageURLRequestDestroyed;
completed_requests_++;
if (net_error == ERR_ABORTED) {
canceled_requests_++;
} else if (net_error != OK) {
error_count_++;
last_error_ = net_error;
} else {
DCHECK_EQ(OK, net_error);
}
}
void TestNetworkDelegate::OnURLRequestDestroyed(URLRequest* request) {
int req_id = GetRequestId(request);
InitRequestStatesIfNew(req_id);
event_order_[req_id] += "OnURLRequestDestroyed\n";
EXPECT_TRUE(next_states_[req_id] & kStageURLRequestDestroyed) <<
event_order_[req_id];
next_states_[req_id] = kStageDestruction;
destroyed_requests_++;
}
bool TestNetworkDelegate::OnAnnotateAndMoveUserBlockedCookies(
const URLRequest& request,
const net::FirstPartySetMetadata& first_party_set_metadata,
net::CookieAccessResultList& maybe_included_cookies,
net::CookieAccessResultList& excluded_cookies) {
RecordCookieSettingOverrides(request.cookie_setting_overrides());
bool allow = true;
if (cookie_options_bit_mask_ & NO_GET_COOKIES)
allow = false;
if (!allow) {
blocked_annotate_cookies_count_++;
ExcludeAllCookies(CookieInclusionStatus::EXCLUDE_USER_PREFERENCES,
maybe_included_cookies, excluded_cookies);
}
return allow;
}
NetworkDelegate::PrivacySetting TestNetworkDelegate::OnForcePrivacyMode(
const URLRequest& request) const {
RecordCookieSettingOverrides(request.cookie_setting_overrides());
return NetworkDelegate::PrivacySetting::kStateAllowed;
}
bool TestNetworkDelegate::OnCanSetCookie(
const URLRequest& request,
const net::CanonicalCookie& cookie,
CookieOptions* options,
const net::FirstPartySetMetadata& first_party_set_metadata,
CookieInclusionStatus* inclusion_status) {
RecordCookieSettingOverrides(request.cookie_setting_overrides());
bool allow = true;
if (cookie_options_bit_mask_ & NO_SET_COOKIE)
allow = false;
if (!allow) {
blocked_set_cookie_count_++;
} else {
set_cookie_count_++;
}
return allow;
}
bool TestNetworkDelegate::OnCancelURLRequestWithPolicyViolatingReferrerHeader(
const URLRequest& request,
const GURL& target_url,
const GURL& referrer_url) const {
return cancel_request_with_policy_violating_referrer_;
}
int TestNetworkDelegate::GetRequestId(URLRequest* request) {
TestRequestId* test_request_id = reinterpret_cast<TestRequestId*>(
request->GetUserData(kTestNetworkDelegateRequestIdKey));
if (test_request_id)
return test_request_id->id();
int id = next_request_id_++;
request->SetUserData(kTestNetworkDelegateRequestIdKey,
std::make_unique<TestRequestId>(id));
return id;
}
FilteringTestNetworkDelegate::FilteringTestNetworkDelegate() = default;
FilteringTestNetworkDelegate::~FilteringTestNetworkDelegate() = default;
bool FilteringTestNetworkDelegate::OnCanSetCookie(
const URLRequest& request,
const net::CanonicalCookie& cookie,
CookieOptions* options,
const net::FirstPartySetMetadata& first_party_set_metadata,
CookieInclusionStatus* inclusion_status) {
// Filter out cookies with the same name as |cookie_name_filter_| and
// combine with |allowed_from_caller|.
bool allowed = cookie.Name() != cookie_name_filter_;
++set_cookie_called_count_;
if (!allowed)
++blocked_set_cookie_count_;
// Call the nested delegate's method first to avoid a short circuit.
return TestNetworkDelegate::OnCanSetCookie(request, cookie, options,
first_party_set_metadata,
inclusion_status) &&
allowed;
}
NetworkDelegate::PrivacySetting
FilteringTestNetworkDelegate::OnForcePrivacyMode(
const URLRequest& request) const {
if (force_privacy_mode_) {
return partitioned_state_allowed_
? NetworkDelegate::PrivacySetting::kPartitionedStateAllowedOnly
: NetworkDelegate::PrivacySetting::kStateDisallowed;
}
return TestNetworkDelegate::OnForcePrivacyMode(request);
}
bool FilteringTestNetworkDelegate::OnAnnotateAndMoveUserBlockedCookies(
const URLRequest& request,
const net::FirstPartySetMetadata& first_party_set_metadata,
net::CookieAccessResultList& maybe_included_cookies,
net::CookieAccessResultList& excluded_cookies) {
// Filter out cookies if |block_annotate_cookies_| is set and
// combine with |allowed_from_caller|.
bool allowed = !block_annotate_cookies_;
++annotate_cookies_called_count_;
if (!allowed) {
++blocked_annotate_cookies_count_;
ExcludeAllCookies(net::CookieInclusionStatus::EXCLUDE_USER_PREFERENCES,
maybe_included_cookies, excluded_cookies);
}
if (allowed && block_get_cookies_by_name_ && !cookie_name_filter_.empty()) {
for (auto& cookie : maybe_included_cookies) {
if (cookie.cookie.Name().find(cookie_name_filter_) != std::string::npos) {
cookie.access_result.status.AddExclusionReason(
net::CookieInclusionStatus::EXCLUDE_USER_PREFERENCES);
}
}
for (auto& cookie : excluded_cookies) {
if (cookie.cookie.Name().find(cookie_name_filter_) != std::string::npos) {
cookie.access_result.status.AddExclusionReason(
net::CookieInclusionStatus::EXCLUDE_USER_PREFERENCES);
}
}
MoveExcludedCookies(maybe_included_cookies, excluded_cookies);
}
// Call the nested delegate's method first to avoid a short circuit.
return TestNetworkDelegate::OnAnnotateAndMoveUserBlockedCookies(
request, first_party_set_metadata, maybe_included_cookies,
excluded_cookies) &&
allowed;
}
// URLRequestInterceptor that intercepts only the first request it sees,
// returning the provided URLRequestJob.
class TestScopedURLInterceptor::TestRequestInterceptor
: public URLRequestInterceptor {
public:
explicit TestRequestInterceptor(std::unique_ptr<URLRequestJob> intercept_job)
: intercept_job_(std::move(intercept_job)) {}
~TestRequestInterceptor() override { CHECK(safe_to_delete_); }
std::unique_ptr<URLRequestJob> MaybeInterceptRequest(
URLRequest* request) const override {
return std::move(intercept_job_);
}
bool job_used() const { return intercept_job_.get() == nullptr; }
void set_safe_to_delete() { safe_to_delete_ = true; }
private:
mutable std::unique_ptr<URLRequestJob> intercept_job_;
// This is used to catch chases where the TestRequestInterceptor is destroyed
// before the TestScopedURLInterceptor.
bool safe_to_delete_ = false;
};
TestScopedURLInterceptor::TestScopedURLInterceptor(
const GURL& url,
std::unique_ptr<URLRequestJob> intercept_job)
: url_(url) {
std::unique_ptr<TestRequestInterceptor> interceptor =
std::make_unique<TestRequestInterceptor>(std::move(intercept_job));
interceptor_ = interceptor.get();
URLRequestFilter::GetInstance()->AddUrlInterceptor(url_,
std::move(interceptor));
}
TestScopedURLInterceptor::~TestScopedURLInterceptor() {
DCHECK(interceptor_->job_used());
interceptor_->set_safe_to_delete();
interceptor_ = nullptr;
URLRequestFilter::GetInstance()->RemoveUrlHandler(url_);
}
} // namespace net