Skip to content

GitLab

T
tangled
Commit 1f4a4281 authored by John Abd-El-Malek's avatar John Abd-El-Malek Committed by Commit Bot
Browse files
Options

Update SafeBrowsingProtocolManager to use SimpleURLLoader. 

Bug: 825242
Change-Id: I9e674841ca4199d53b9b50f12050cb4d085daa10
Reviewed-on: https://chromium-review.googlesource.com/1007010Reviewed-by: default avatarJialiu Lin <jialiul@chromium.org>
Reviewed-by: default avatarVarun Khaneja <vakh@chromium.org>
Commit-Queue: John Abd-El-Malek <jam@chromium.org>
Cr-Commit-Position: refs/heads/master@{#550173}
parent 405745c9
Show whitespace changes
Inline Side-by-side
Showing with 248 additions and 367 deletions
chrome/browser/safe_browsing/protocol_manager.cc
View file @ 1f4a4281
......@@ -29,9 +29,8 @@
#include "net/http/http_response_headers.h"
#include "net/http/http_status_code.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_request_context_getter.h"
#include "net/url_request/url_request_status.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "services/network/public/cpp/simple_url_loader.h"
using base::Time;
using base::TimeDelta;
......@@ -136,10 +135,10 @@ class SBProtocolManagerFactoryImpl : public SBProtocolManagerFactory {
std::unique_ptr<SafeBrowsingProtocolManager> CreateProtocolManager(
SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config) override {
return base::WrapUnique(new SafeBrowsingProtocolManager(
delegate, request_context_getter, config));
return base::WrapUnique(
new SafeBrowsingProtocolManager(delegate, url_loader_factory, config));
}
private:
......@@ -155,17 +154,16 @@ SBProtocolManagerFactory* SafeBrowsingProtocolManager::factory_ = nullptr;
std::unique_ptr<SafeBrowsingProtocolManager>
SafeBrowsingProtocolManager::Create(
SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config) {
if (!factory_)
factory_ = new SBProtocolManagerFactoryImpl();
return factory_->CreateProtocolManager(delegate, request_context_getter,
config);
return factory_->CreateProtocolManager(delegate, url_loader_factory, config);
}
SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config)
: delegate_(delegate),
request_type_(NO_REQUEST),
......@@ -180,11 +178,10 @@ SafeBrowsingProtocolManager::SafeBrowsingProtocolManager(
version_(config.version),
update_size_(0),
client_name_(config.client_name),
request_context_getter_(request_context_getter),
url_loader_factory_(url_loader_factory),
url_prefix_(config.url_prefix),
backup_update_reason_(BACKUP_UPDATE_REASON_MAX),
disable_auto_update_(config.disable_auto_update),
url_fetcher_id_(0) {
disable_auto_update_(config.disable_auto_update) {
DCHECK(!url_prefix_.empty());
backup_url_prefixes_[BACKUP_UPDATE_REASON_CONNECT] =
......@@ -212,13 +209,6 @@ void SafeBrowsingProtocolManager::RecordGetHashResult(bool is_download,
}
}
void SafeBrowsingProtocolManager::RecordHttpResponseOrErrorCode(
const char* metric_name,
const net::URLRequestStatus& status,
int response_code) {
RecordHttpResponseOrErrorCode(metric_name, status.error(), response_code);
}
void SafeBrowsingProtocolManager::RecordHttpResponseOrErrorCode(
const char* metric_name,
int net_error,
......@@ -289,21 +279,21 @@ void SafeBrowsingProtocolManager::GetFullHash(
}
}
})");
std::unique_ptr<net::URLFetcher> fetcher_ptr =
net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
net::URLFetcher::POST, this, traffic_annotation);
net::URLFetcher* fetcher = fetcher_ptr.get();
data_use_measurement::DataUseUserData::AttachToFetcher(
fetcher, data_use_measurement::DataUseUserData::SAFE_BROWSING);
hash_requests_[fetcher] = {std::move(fetcher_ptr),
auto resource_request = std::make_unique<network::ResourceRequest>();
resource_request->url = gethash_url;
resource_request->method = "POST";
resource_request->load_flags = net::LOAD_DISABLE_CACHE;
auto loader_ptr = network::SimpleURLLoader::Create(
std::move(resource_request), traffic_annotation);
loader_ptr->AttachStringForUpload(FormatGetHash(prefixes), "text/plain");
auto* loader = loader_ptr.get();
loader_ptr->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
url_loader_factory_.get(),
base::BindOnce(&SafeBrowsingProtocolManager::OnURLLoaderComplete,
base::Unretained(this), loader));
hash_requests_[loader] = {std::move(loader_ptr),
FullHashDetails(callback, is_download)};
const std::string get_hash = FormatGetHash(prefixes);
fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
fetcher->SetRequestContext(request_context_getter_.get());
fetcher->SetUploadData("text/plain", get_hash);
fetcher->Start();
}
void SafeBrowsingProtocolManager::GetNextUpdate() {
......@@ -314,8 +304,6 @@ void SafeBrowsingProtocolManager::GetNextUpdate() {
IssueUpdateRequest();
}
// net::URLFetcherDelegate implementation ----------------------------------
// All SafeBrowsing request responses are handled here.
// TODO(paulg): Clarify with the SafeBrowsing team whether a failed parse of a
// chunk should retry the download and parse of that chunk (and
......@@ -324,22 +312,37 @@ void SafeBrowsingProtocolManager::GetNextUpdate() {
// drop it. This isn't so bad because the next UPDATE_REQUEST we
// do will report all the chunks we have. If that chunk is still
// required, the SafeBrowsing servers will tell us to get it again.
void SafeBrowsingProtocolManager::OnURLFetchComplete(
const net::URLFetcher* source) {
void SafeBrowsingProtocolManager::OnURLLoaderComplete(
network::SimpleURLLoader* url_loader,
std::unique_ptr<std::string> response_body) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
auto it = hash_requests_.find(source);
int response_code = source->GetResponseCode();
net::URLRequestStatus status = source->GetStatus();
int response_code = 0;
if (url_loader->ResponseInfo() && url_loader->ResponseInfo()->headers)
response_code = url_loader->ResponseInfo()->headers->response_code();
std::string data;
if (response_body)
data = *response_body.get();
OnURLLoaderCompleteInternal(url_loader, url_loader->NetError(), response_code,
data);
}
void SafeBrowsingProtocolManager::OnURLLoaderCompleteInternal(
network::SimpleURLLoader* url_loader,
int net_error,
int response_code,
const std::string& data) {
auto it = hash_requests_.find(url_loader);
if (it != hash_requests_.end()) {
// GetHash response.
RecordHttpResponseOrErrorCode(kGetHashUmaResponseMetricName, status,
RecordHttpResponseOrErrorCode(kGetHashUmaResponseMetricName, net_error,
response_code);
const FullHashDetails& details = it->second.second;
std::vector<SBFullHashResult> full_hashes;
base::TimeDelta cache_lifetime;
if (status.is_success() && (response_code == net::HTTP_OK ||
if (net_error == net::OK && (response_code == net::HTTP_OK ||
response_code == net::HTTP_NO_CONTENT)) {
// For tracking our GetHash false positive (net::HTTP_NO_CONTENT) rate,
// compared to real (net::HTTP_OK) responses.
......@@ -350,8 +353,6 @@ void SafeBrowsingProtocolManager::OnURLFetchComplete(
gethash_error_count_ = 0;
gethash_back_off_mult_ = 1;
std::string data;
source->GetResponseAsString(&data);
if (!ParseGetHash(data.data(), data.length(), &cache_lifetime,
&full_hashes)) {
full_hashes.clear();
......@@ -361,13 +362,15 @@ void SafeBrowsingProtocolManager::OnURLFetchComplete(
}
} else {
HandleGetHashError(Time::Now());
if (status.status() == net::URLRequestStatus::FAILED) {
if (net_error != net::OK) {
RecordGetHashResult(details.is_download, GET_HASH_NETWORK_ERROR);
DVLOG(1) << "SafeBrowsing GetHash request for: " << source->GetURL()
<< " failed with error: " << status.error();
DVLOG(1) << "SafeBrowsing GetHash request for: "
<< url_loader->GetFinalURL()
<< " failed with error: " << net_error;
} else {
RecordGetHashResult(details.is_download, GET_HASH_HTTP_ERROR);
DVLOG(1) << "SafeBrowsing GetHash request for: " << source->GetURL()
DVLOG(1) << "SafeBrowsing GetHash request for: "
<< url_loader->GetFinalURL()
<< " failed with error: " << response_code;
}
}
......@@ -380,13 +383,13 @@ void SafeBrowsingProtocolManager::OnURLFetchComplete(
hash_requests_.erase(it);
} else {
// Update or chunk response.
RecordHttpResponseOrErrorCode(kGetChunkUmaResponseMetricName, status,
RecordHttpResponseOrErrorCode(kGetChunkUmaResponseMetricName, net_error,
response_code);
std::unique_ptr<net::URLFetcher> fetcher = std::move(request_);
std::unique_ptr<network::SimpleURLLoader> loader = std::move(request_);
if (request_type_ == UPDATE_REQUEST ||
request_type_ == BACKUP_UPDATE_REQUEST) {
if (!fetcher.get()) {
if (!loader.get()) {
// We've timed out waiting for an update response, so we've cancelled
// the update request and scheduled a new one. Ignore this response.
return;
......@@ -396,17 +399,13 @@ void SafeBrowsingProtocolManager::OnURLFetchComplete(
timeout_timer_.Stop();
}
if (status.is_success() && response_code == net::HTTP_OK) {
if (net_error == net::OK && response_code == net::HTTP_OK) {
// We have data from the SafeBrowsing service.
std::string data;
source->GetResponseAsString(&data);
// TODO(shess): Cleanup the flow of this code so that |parsed_ok| can be
// removed or omitted.
const bool parsed_ok =
HandleServiceResponse(source->GetURL(), data.data(), data.length());
const bool parsed_ok = HandleServiceResponse(data.data(), data.length());
if (!parsed_ok) {
DVLOG(1) << "SafeBrowsing request for: " << source->GetURL()
DVLOG(1) << "SafeBrowsing request for: " << loader->GetFinalURL()
<< " failed parse.";
chunk_request_urls_.clear();
if (request_type_ == UPDATE_REQUEST &&
......@@ -440,11 +439,11 @@ void SafeBrowsingProtocolManager::OnURLFetchComplete(
break;
}
} else {
if (status.status() == net::URLRequestStatus::FAILED) {
DVLOG(1) << "SafeBrowsing request for: " << source->GetURL()
<< " failed with error: " << status.error();
if (net_error != net::OK) {
DVLOG(1) << "SafeBrowsing request for: " << loader->GetFinalURL()
<< " failed with error: " << net_error;
} else {
DVLOG(1) << "SafeBrowsing request for: " << source->GetURL()
DVLOG(1) << "SafeBrowsing request for: " << loader->GetFinalURL()
<< " failed with error: " << response_code;
}
if (request_type_ == CHUNK_REQUEST) {
......@@ -452,10 +451,10 @@ void SafeBrowsingProtocolManager::OnURLFetchComplete(
chunk_request_urls_.clear();
} else if (request_type_ == UPDATE_REQUEST) {
BackupUpdateReason backup_update_reason = BACKUP_UPDATE_REASON_MAX;
if (status.is_success()) {
if (net_error == net::OK) {
backup_update_reason = BACKUP_UPDATE_REASON_HTTP;
} else {
switch (status.error()) {
switch (net_error) {
case net::ERR_INTERNET_DISCONNECTED:
case net::ERR_NETWORK_CHANGED:
backup_update_reason = BACKUP_UPDATE_REASON_NETWORK;
......@@ -478,8 +477,7 @@ void SafeBrowsingProtocolManager::OnURLFetchComplete(
}
}
bool SafeBrowsingProtocolManager::HandleServiceResponse(const GURL& url,
const char* data,
bool SafeBrowsingProtocolManager::HandleServiceResponse(const char* data,
size_t length) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
......@@ -687,15 +685,17 @@ bool SafeBrowsingProtocolManager::IssueBackupUpdateRequest(
}
}
})");
request_ =
net::URLFetcher::Create(url_fetcher_id_++, backup_update_url,
net::URLFetcher::POST, this, traffic_annotation);
data_use_measurement::DataUseUserData::AttachToFetcher(
request_.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
request_->SetRequestContext(request_context_getter_.get());
request_->SetUploadData("text/plain", update_list_data_);
request_->Start();
auto resource_request = std::make_unique<network::ResourceRequest>();
resource_request->url = backup_update_url;
resource_request->method = "POST";
resource_request->load_flags = net::LOAD_DISABLE_CACHE;
request_ = network::SimpleURLLoader::Create(std::move(resource_request),
traffic_annotation);
request_->AttachStringForUpload(update_list_data_, "text/plain");
request_->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
url_loader_factory_.get(),
base::BindOnce(&SafeBrowsingProtocolManager::OnURLLoaderComplete,
base::Unretained(this), request_.get()));
// Begin the update request timeout.
timeout_timer_.Start(FROM_HERE, kSbMaxUpdateWait, this,
......@@ -716,15 +716,18 @@ void SafeBrowsingProtocolManager::IssueChunkRequest() {
DCHECK(!next_chunk.url.empty());
GURL chunk_url = NextChunkUrl(next_chunk.url);
request_type_ = CHUNK_REQUEST;
request_ = net::URLFetcher::Create(url_fetcher_id_++, chunk_url,
net::URLFetcher::GET, this,
kChunkBackupRequestTrafficAnnotation);
data_use_measurement::DataUseUserData::AttachToFetcher(
request_.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
request_->SetRequestContext(request_context_getter_.get());
auto resource_request = std::make_unique<network::ResourceRequest>();
resource_request->url = chunk_url;
resource_request->load_flags = net::LOAD_DISABLE_CACHE;
request_ = network::SimpleURLLoader::Create(
std::move(resource_request), kChunkBackupRequestTrafficAnnotation);
request_->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
url_loader_factory_.get(),
base::BindOnce(&SafeBrowsingProtocolManager::OnURLLoaderComplete,
base::Unretained(this), request_.get()));
chunk_request_start_ = base::Time::Now();
request_->Start();
}
void SafeBrowsingProtocolManager::OnGetChunksComplete(
......@@ -770,15 +773,18 @@ void SafeBrowsingProtocolManager::OnGetChunksComplete(
UMA_HISTOGRAM_COUNTS("SB2.UpdateRequestSize", update_list_data_.size());
GURL update_url = UpdateUrl(extended_reporting_level);
request_ = net::URLFetcher::Create(url_fetcher_id_++, update_url,
net::URLFetcher::POST, this,
kChunkBackupRequestTrafficAnnotation);
data_use_measurement::DataUseUserData::AttachToFetcher(
request_.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
request_->SetRequestContext(request_context_getter_.get());
request_->SetUploadData("text/plain", update_list_data_);
request_->Start();
auto resource_request = std::make_unique<network::ResourceRequest>();
resource_request->url = update_url;
resource_request->method = "POST";
resource_request->load_flags = net::LOAD_DISABLE_CACHE;
request_ = network::SimpleURLLoader::Create(
std::move(resource_request), kChunkBackupRequestTrafficAnnotation);
request_->AttachStringForUpload(update_list_data_, "text/plain");
request_->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
url_loader_factory_.get(),
base::BindOnce(&SafeBrowsingProtocolManager::OnURLLoaderComplete,
base::Unretained(this), request_.get()));
// Begin the update request timeout.
timeout_timer_.Start(FROM_HERE, kSbMaxUpdateWait, this,
......
chrome/browser/safe_browsing/protocol_manager.h
View file @ 1f4a4281
......@@ -33,14 +33,12 @@
#include "components/safe_browsing/common/safe_browsing_prefs.h"
#include "components/safe_browsing/db/safebrowsing.pb.h"
#include "components/safe_browsing/db/util.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "net/url_request/url_request_status.h"
#include "url/gurl.h"
namespace net {
class URLFetcher;
class URLRequestContextGetter;
} // namespace net
namespace network {
class SimpleURLLoader;
class SharedURLLoaderFactory;
} // namespace network
namespace safe_browsing {
......@@ -48,7 +46,7 @@ class SBProtocolManagerFactory;
class SafeBrowsingProtocolManagerDelegate;
// Lives on the IO thread.
class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
class SafeBrowsingProtocolManager {
public:
// FullHashCallback is invoked when GetFullHash completes.
// Parameters:
......@@ -60,7 +58,7 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
base::Callback<void(const std::vector<SBFullHashResult>&,
const base::TimeDelta&)>;
~SafeBrowsingProtocolManager() override;
virtual ~SafeBrowsingProtocolManager();
// Makes the passed |factory| the factory used to instantiate
// a SafeBrowsingService. Useful for tests.
......@@ -71,15 +69,22 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
// Create an instance of the safe browsing protocol manager.
static std::unique_ptr<SafeBrowsingProtocolManager> Create(
SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config);
// Sets up the update schedule and internal state for making periodic requests
// of the Safebrowsing servers.
virtual void Initialize();
// net::URLFetcherDelegate interface.
void OnURLFetchComplete(const net::URLFetcher* source) override;
// Callback when the request completes
void OnURLLoaderComplete(network::SimpleURLLoader* url_loader,
std::unique_ptr<std::string> response_body);
// To ease testing.
void OnURLLoaderCompleteInternal(network::SimpleURLLoader* url_loader,
int net_error,
int response_code,
const std::string& data);
// Retrieve the full hash for a set of prefixes, and invoke the callback
// argument when the results are retrieved. The callback may be invoked
......@@ -164,11 +169,9 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
// Record HTTP response code when there's no error in fetching an HTTP
// request, and the error code, when there is.
// |metric_name| is the name of the UMA metric to record the response code or
// error code against, |status| represents the status of the HTTP request, and
// |response code| represents the HTTP response code received from the server.
static void RecordHttpResponseOrErrorCode(
const char* metric_name, const net::URLRequestStatus& status,
int response_code);
// error code against, |net_error| represents the status of the HTTP request,
// and |response code| represents the HTTP response code received from the
// server.
static void RecordHttpResponseOrErrorCode(const char* metric_name,
int net_error,
int response_code);
......@@ -180,10 +183,10 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
protected:
// Constructs a SafeBrowsingProtocolManager for |delegate| that issues
// network requests using |request_context_getter|.
// network requests using |url_loader_factory|.
SafeBrowsingProtocolManager(
SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config);
private:
......@@ -267,7 +270,7 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
// Runs the protocol parser on received data and update the
// SafeBrowsingService with the new content. Returns 'true' on successful
// parse, 'false' on error.
bool HandleServiceResponse(const GURL& url, const char* data, size_t length);
bool HandleServiceResponse(const char* data, size_t length);
// Updates internal state for each GetHash response error, assuming that the
// current time is |now|.
......@@ -305,7 +308,7 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
// Current active request (in case we need to cancel) for updates or chunks
// from the SafeBrowsing service. We can only have one of these outstanding
// at any given time unlike GetHash requests, which are tracked separately.
std::unique_ptr<net::URLFetcher> request_;
std::unique_ptr<network::SimpleURLLoader> request_;
// The kind of request that is currently in progress.
SafeBrowsingRequestType request_type_;
......@@ -337,8 +340,9 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
// All chunk requests that need to be made.
base::circular_deque<ChunkUrl> chunk_request_urls_;
std::map<const net::URLFetcher*,
std::pair<std::unique_ptr<net::URLFetcher>, FullHashDetails>>
std::map<
const network::SimpleURLLoader*,
std::pair<std::unique_ptr<network::SimpleURLLoader>, FullHashDetails>>
hash_requests_;
// True if the service has been given an add/sub chunk but it hasn't been
......@@ -367,8 +371,8 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
// safebrowsing hits and chunk update requests.
std::string additional_query_;
// The context we use to issue network requests.
scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
// The URLLoaderFactory we use to issue network requests.
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
// URL prefix where browser fetches safebrowsing chunk updates, and hashes.
std::string url_prefix_;
......@@ -386,9 +390,6 @@ class SafeBrowsingProtocolManager : public net::URLFetcherDelegate {
// ForceScheduleNextUpdate() is called. This is set for testing purpose.
bool disable_auto_update_;
// ID for URLFetchers for testing.
int url_fetcher_id_;
DISALLOW_COPY_AND_ASSIGN(SafeBrowsingProtocolManager);
};
......@@ -400,7 +401,7 @@ class SBProtocolManagerFactory {
virtual std::unique_ptr<SafeBrowsingProtocolManager> CreateProtocolManager(
SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config) = 0;
private:
......
chrome/browser/safe_browsing/protocol_manager_unittest.cc
View file @ 1f4a4281
......@@ -17,12 +17,13 @@
#include "components/safe_browsing/common/safe_browsing_prefs.h"
#include "components/safe_browsing/db/safebrowsing.pb.h"
#include "components/safe_browsing/db/util.h"
#include "content/public/common/weak_wrapper_shared_url_loader_factory.h"
#include "content/public/test/test_browser_thread_bundle.h"
#include "google_apis/google_api_keys.h"
#include "net/base/escape.h"
#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/url_request/test_url_fetcher_factory.h"
#include "services/network/test/test_url_loader_factory.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gmock_mutant.h"
#include "testing/gtest/include/gtest/gtest.h"
......@@ -87,6 +88,12 @@ class SafeBrowsingProtocolManagerTest : public testing::Test {
"&key=%s",
net::EscapeQueryParamValue(key, true).c_str());
}
test_shared_loader_factory_ =
base::MakeRefCounted<content::WeakWrapperSharedURLLoaderFactory>(
&test_url_loader_factory_);
test_url_loader_factory_.SetInterceptor(base::Bind(
&SafeBrowsingProtocolManagerTest::OnRequest, base::Unretained(this)));
}
std::unique_ptr<SafeBrowsingProtocolManager> CreateProtocolManager(
......@@ -99,40 +106,57 @@ class SafeBrowsingProtocolManagerTest : public testing::Test {
config.backup_network_error_url_prefix = kBackupNetworkUrlPrefix;
config.version = kAppVer;
return std::unique_ptr<SafeBrowsingProtocolManager>(
SafeBrowsingProtocolManager::Create(delegate, nullptr, config));
SafeBrowsingProtocolManager::Create(
delegate, test_shared_loader_factory_, config));
}
void OnRequest(const network::ResourceRequest& request) {
last_request_ = request;
}
std::string GetBodyFromRequest(const network::ResourceRequest& request) {
auto body = request.request_body;
if (!body)
return std::string();
CHECK_EQ(1u, body->elements()->size());
auto& element = body->elements()->at(0);
CHECK_EQ(network::DataElement::TYPE_BYTES, element.type());
return std::string(element.bytes(), element.length());
}
void ValidateUpdateFetcherRequest(const net::TestURLFetcher* url_fetcher,
const std::string& expected_prefix,
void ValidateUpdateFetcherRequest(const std::string& expected_prefix,
const std::string& expected_suffix) {
ASSERT_TRUE(url_fetcher);
EXPECT_EQ(net::LOAD_DISABLE_CACHE, url_fetcher->GetLoadFlags());
EXPECT_EQ(net::LOAD_DISABLE_CACHE, last_request_.load_flags);
std::string expected_lists(base::StringPrintf("%s;\n%s;\n",
kDefaultPhishList,
kDefaultMalwareList));
EXPECT_EQ(expected_lists, url_fetcher->upload_data());
EXPECT_EQ(GURL(expected_prefix + "/downloads?client=unittest&appver=1.0"
EXPECT_EQ(expected_lists, GetBodyFromRequest(last_request_));
EXPECT_EQ(GURL(expected_prefix +
"/downloads?client=unittest&appver=1.0"
"&pver=3.0" +
key_param_ + expected_suffix),
url_fetcher->GetOriginalURL());
last_request_.url);
}
void ValidateUpdateFetcherRequest(const net::TestURLFetcher* url_fetcher) {
ValidateUpdateFetcherRequest(url_fetcher, kUrlPrefix, kUrlSuffix);
void ValidateUpdateFetcherRequest() {
ValidateUpdateFetcherRequest(kUrlPrefix, kUrlSuffix);
}
void ValidateRedirectFetcherRequest(const net::TestURLFetcher* url_fetcher,
const std::string& expected_url) {
ASSERT_TRUE(url_fetcher);
EXPECT_EQ(net::LOAD_DISABLE_CACHE, url_fetcher->GetLoadFlags());
EXPECT_EQ("", url_fetcher->upload_data());
EXPECT_EQ(GURL(expected_url), url_fetcher->GetOriginalURL());
void ValidateRedirectFetcherRequest(const std::string& expected_url) {
EXPECT_EQ(net::LOAD_DISABLE_CACHE, last_request_.load_flags);
EXPECT_EQ("", GetBodyFromRequest(last_request_));
EXPECT_EQ(GURL(expected_url), last_request_.url);
}
// Fakes BrowserThreads and the main MessageLoop.
content::TestBrowserThreadBundle thread_bundle_;
network::TestURLLoaderFactory test_url_loader_factory_;
scoped_refptr<network::SharedURLLoaderFactory> test_shared_loader_factory_;
network::ResourceRequest last_request_;
// Replaces the main MessageLoop's TaskRunner with a TaskRunner on which time
// is mocked to allow testing of things bound to timers below.
base::ScopedMockTimeMessageLoopTaskRunner mock_time_task_runner_;
......@@ -437,8 +461,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, ProblemAccessingDatabase) {
// local database. This is not exhaustive, as the actual list formatting
// is covered by SafeBrowsingProtocolManagerTest.TestChunkStrings.
TEST_F(SafeBrowsingProtocolManagerTest, ExistingDatabase) {
net::TestURLFetcherFactory url_fetcher_factory;
std::vector<SBListChunkRanges> ranges;
SBListChunkRanges range_phish(kPhishingList);
range_phish.adds = "adds_phish";
......@@ -465,31 +487,23 @@ TEST_F(SafeBrowsingProtocolManagerTest, ExistingDatabase) {
pm->ForceScheduleNextUpdate(TimeDelta());
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ASSERT_TRUE(url_fetcher);
EXPECT_EQ(net::LOAD_DISABLE_CACHE, url_fetcher->GetLoadFlags());
EXPECT_EQ(net::LOAD_DISABLE_CACHE, last_request_.load_flags);
EXPECT_EQ(base::StringPrintf("%s;a:adds_phish:s:subs_phish\n"
"unknown_list;a:adds_unknown:s:subs_unknown\n"
"%s;\n",
kDefaultPhishList, kDefaultMalwareList),
url_fetcher->upload_data());
GetBodyFromRequest(last_request_));
EXPECT_EQ(GURL("https://prefix.com/foo/downloads?client=unittest&appver=1.0"
"&pver=3.0" +
key_param_ + "&ext=0"),
url_fetcher->GetOriginalURL());
last_request_.url);
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(200);
url_fetcher->SetResponseString(std::string());
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseBadBodyBackupSuccess) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -506,25 +520,17 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseBadBodyBackupSuccess) {
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// The update response is successful, but an invalid body.
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(200);
url_fetcher->SetResponseString("THIS_IS_A_BAD_RESPONSE");
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200,
"THIS_IS_A_BAD_RESPONSE");
// There should now be a backup request.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupHttpUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupHttpUrlPrefix, "");
// Respond to the backup successfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(200);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -532,8 +538,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseBadBodyBackupSuccess) {
// Tests what happens when there is an HTTP error response to the update
// request, as well as an error response to the backup update request.
TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupError) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -550,25 +554,16 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupError) {
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Go ahead and respond to it.
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(404);
url_fetcher->SetResponseString(std::string());
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 404, std::string());
// There should now be a backup request.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupHttpUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupHttpUrlPrefix, "");
// Respond to the backup unsuccessfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(404);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 404, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -576,8 +571,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupError) {
// Tests what happens when there is an HTTP error response to the update
// request, followed by a successful response to the backup update request.
TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupSuccess) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -594,25 +587,16 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupSuccess) {
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Go ahead and respond to it.
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(404);
url_fetcher->SetResponseString(std::string());
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 404, std::string());
// There should now be a backup request.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupHttpUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupHttpUrlPrefix, "");
// Respond to the backup successfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(200);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -620,8 +604,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupSuccess) {
// Tests what happens when there is an HTTP error response to the update
// request, and a timeout on the backup update request.
TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupTimeout) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -638,19 +620,13 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupTimeout) {
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Go ahead and respond to it.
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(404);
url_fetcher->SetResponseString(std::string());
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 404, std::string());
// There should now be a backup request.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupHttpUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupHttpUrlPrefix, "");
// Confirm that no update is scheduled (still waiting on a response to the
// backup request).
......@@ -674,8 +650,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseHttpErrorBackupTimeout) {
// request, and an error with the backup update request.
TEST_F(SafeBrowsingProtocolManagerTest,
UpdateResponseConnectionErrorBackupError) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -692,24 +666,17 @@ TEST_F(SafeBrowsingProtocolManagerTest,
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Go ahead and respond to it.
url_fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
net::ERR_CONNECTION_RESET));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::ERR_CONNECTION_RESET, 0,
std::string());
// There should be a backup URLFetcher now.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupConnectUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupConnectUrlPrefix, "");
// Respond to the backup unsuccessfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(404);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 404, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -718,8 +685,6 @@ TEST_F(SafeBrowsingProtocolManagerTest,
// request, and a successful response to the backup update request.
TEST_F(SafeBrowsingProtocolManagerTest,
UpdateResponseConnectionErrorBackupSuccess) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -736,24 +701,17 @@ TEST_F(SafeBrowsingProtocolManagerTest,
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Go ahead and respond to it.
url_fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
net::ERR_CONNECTION_RESET));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::ERR_CONNECTION_RESET, 0,
std::string());
// There should be a backup URLFetcher now.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupConnectUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupConnectUrlPrefix, "");
// Respond to the backup unsuccessfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(200);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -761,8 +719,6 @@ TEST_F(SafeBrowsingProtocolManagerTest,
// update request, and an error with the backup update request.
TEST_F(SafeBrowsingProtocolManagerTest,
UpdateResponseNetworkErrorBackupError) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -779,25 +735,17 @@ TEST_F(SafeBrowsingProtocolManagerTest,
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Go ahead and respond to it.
url_fetcher->set_status(
net::URLRequestStatus(net::URLRequestStatus::FAILED,
net::ERR_INTERNET_DISCONNECTED));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::ERR_INTERNET_DISCONNECTED, 0,
std::string());
// There should be a backup URLFetcher now.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupNetworkUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupNetworkUrlPrefix, "");
// Respond to the backup unsuccessfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(404);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 404, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -806,8 +754,6 @@ TEST_F(SafeBrowsingProtocolManagerTest,
// update request, and a successful response to the backup update request.
TEST_F(SafeBrowsingProtocolManagerTest,
UpdateResponseNetworkErrorBackupSuccess) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -824,33 +770,23 @@ TEST_F(SafeBrowsingProtocolManagerTest,
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Go ahead and respond to it.
url_fetcher->set_status(
net::URLRequestStatus(net::URLRequestStatus::FAILED,
net::ERR_INTERNET_DISCONNECTED));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::ERR_INTERNET_DISCONNECTED, 0,
std::string());
// There should be a backup URLFetcher now.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupNetworkUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupNetworkUrlPrefix, "");
// Respond to the backup unsuccessfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(200);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
// Tests what happens when there is a timeout before an update response.
TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseTimeoutBackupSuccess) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -867,31 +803,23 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseTimeoutBackupSuccess) {
mock_time_task_runner_->RunUntilIdle();
// We should have an URLFetcher at this point in time.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// Force the timeout to fire.
mock_time_task_runner_->FastForwardBy(
SafeBrowsingProtocolManager::GetUpdateTimeoutForTesting());
// There should be a backup URLFetcher now.
net::TestURLFetcher* backup_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateUpdateFetcherRequest(backup_url_fetcher, kBackupConnectUrlPrefix, "");
ValidateUpdateFetcherRequest(kBackupConnectUrlPrefix, "");
// Respond to the backup unsuccessfully.
backup_url_fetcher->set_status(net::URLRequestStatus());
backup_url_fetcher->set_response_code(200);
backup_url_fetcher->SetResponseString(std::string());
backup_url_fetcher->delegate()->OnURLFetchComplete(backup_url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
// Tests what happens when there is a reset command in the response.
TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseReset) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -908,14 +836,10 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseReset) {
pm->ForceScheduleNextUpdate(TimeDelta());
mock_time_task_runner_->RunUntilIdle();
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
ValidateUpdateFetcherRequest();
// The update response is successful, and has a reset command.
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(200);
url_fetcher->SetResponseString("r:pleasereset\n");
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, "r:pleasereset\n");
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -923,8 +847,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, UpdateResponseReset) {
// Tests a single valid update response, followed by a single redirect response
// that has an valid, but empty body.
TEST_F(SafeBrowsingProtocolManagerTest, EmptyRedirectResponse) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -941,25 +863,16 @@ TEST_F(SafeBrowsingProtocolManagerTest, EmptyRedirectResponse) {
mock_time_task_runner_->RunUntilIdle();
// The update response contains a single redirect command.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(200);
url_fetcher->SetResponseString(
ValidateUpdateFetcherRequest();
pm->OnURLLoaderCompleteInternal(
nullptr, net::OK, 200,
base::StringPrintf("i:%s\n"
"u:redirect-server.example.com/path\n",
kDefaultPhishList));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
// The redirect response contains an empty body.
net::TestURLFetcher* chunk_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateRedirectFetcherRequest(
chunk_url_fetcher, "https://redirect-server.example.com/path");
chunk_url_fetcher->set_status(net::URLRequestStatus());
chunk_url_fetcher->set_response_code(200);
chunk_url_fetcher->SetResponseString(std::string());
chunk_url_fetcher->delegate()->OnURLFetchComplete(chunk_url_fetcher);
ValidateRedirectFetcherRequest("https://redirect-server.example.com/path");
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, std::string());
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -967,8 +880,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, EmptyRedirectResponse) {
// Tests a single valid update response, followed by a single redirect response
// that has an invalid body.
TEST_F(SafeBrowsingProtocolManagerTest, InvalidRedirectResponse) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -985,25 +896,17 @@ TEST_F(SafeBrowsingProtocolManagerTest, InvalidRedirectResponse) {
mock_time_task_runner_->RunUntilIdle();
// The update response contains a single redirect command.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(200);
url_fetcher->SetResponseString(
ValidateUpdateFetcherRequest();
pm->OnURLLoaderCompleteInternal(
nullptr, net::OK, 200,
base::StringPrintf("i:%s\n"
"u:redirect-server.example.com/path\n",
kDefaultPhishList));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
// The redirect response contains an invalid body.
net::TestURLFetcher* chunk_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateRedirectFetcherRequest(
chunk_url_fetcher, "https://redirect-server.example.com/path");
chunk_url_fetcher->set_status(net::URLRequestStatus());
chunk_url_fetcher->set_response_code(200);
chunk_url_fetcher->SetResponseString("THIS IS AN INVALID RESPONSE");
chunk_url_fetcher->delegate()->OnURLFetchComplete(chunk_url_fetcher);
ValidateRedirectFetcherRequest("https://redirect-server.example.com/path");
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200,
"THIS IS AN INVALID RESPONSE");
EXPECT_TRUE(pm->IsUpdateScheduled());
}
......@@ -1011,8 +914,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, InvalidRedirectResponse) {
// Tests a single valid update response, followed by a single redirect response
// containing chunks.
TEST_F(SafeBrowsingProtocolManagerTest, SingleRedirectResponseWithChunks) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -1031,25 +932,16 @@ TEST_F(SafeBrowsingProtocolManagerTest, SingleRedirectResponseWithChunks) {
mock_time_task_runner_->RunUntilIdle();
// The update response contains a single redirect command.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(200);
url_fetcher->SetResponseString(
ValidateUpdateFetcherRequest();
pm->OnURLLoaderCompleteInternal(
nullptr, net::OK, 200,
base::StringPrintf("i:%s\n"
"u:redirect-server.example.com/path\n",
kDefaultPhishList));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
// The redirect response contains a single chunk.
net::TestURLFetcher* chunk_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateRedirectFetcherRequest(
chunk_url_fetcher, "https://redirect-server.example.com/path");
chunk_url_fetcher->set_status(net::URLRequestStatus());
chunk_url_fetcher->set_response_code(200);
chunk_url_fetcher->SetResponseString(kChunkPayload1);
chunk_url_fetcher->delegate()->OnURLFetchComplete(chunk_url_fetcher);
ValidateRedirectFetcherRequest("https://redirect-server.example.com/path");
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, kChunkPayload1);
EXPECT_FALSE(pm->IsUpdateScheduled());
......@@ -1062,8 +954,6 @@ TEST_F(SafeBrowsingProtocolManagerTest, SingleRedirectResponseWithChunks) {
// Tests a single valid update response, followed by multiple redirect responses
// containing chunks.
TEST_F(SafeBrowsingProtocolManagerTest, MultipleRedirectResponsesWithChunks) {
net::TestURLFetcherFactory url_fetcher_factory;
testing::StrictMock<MockProtocolDelegate> test_delegate;
EXPECT_CALL(test_delegate, UpdateStarted()).Times(1);
EXPECT_CALL(test_delegate, GetChunks(_)).WillOnce(
......@@ -1082,27 +972,17 @@ TEST_F(SafeBrowsingProtocolManagerTest, MultipleRedirectResponsesWithChunks) {
mock_time_task_runner_->RunUntilIdle();
// The update response contains multiple redirect commands.
net::TestURLFetcher* url_fetcher = url_fetcher_factory.GetFetcherByID(0);
ValidateUpdateFetcherRequest(url_fetcher);
url_fetcher->set_status(net::URLRequestStatus());
url_fetcher->set_response_code(200);
url_fetcher->SetResponseString(
ValidateUpdateFetcherRequest();
pm->OnURLLoaderCompleteInternal(
nullptr, net::OK, 200,
base::StringPrintf("i:%s\n"
"u:redirect-server.example.com/one\n"
"u:redirect-server.example.com/two\n",
kDefaultPhishList));
url_fetcher->delegate()->OnURLFetchComplete(url_fetcher);
// The first redirect response contains a single chunk.
net::TestURLFetcher* first_chunk_url_fetcher =
url_fetcher_factory.GetFetcherByID(1);
ValidateRedirectFetcherRequest(
first_chunk_url_fetcher, "https://redirect-server.example.com/one");
first_chunk_url_fetcher->set_status(net::URLRequestStatus());
first_chunk_url_fetcher->set_response_code(200);
first_chunk_url_fetcher->SetResponseString(kChunkPayload1);
first_chunk_url_fetcher->delegate()->OnURLFetchComplete(
first_chunk_url_fetcher);
ValidateRedirectFetcherRequest("https://redirect-server.example.com/one");
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, kChunkPayload1);
// Invoke the AddChunksCallback to trigger the second request.
mock_time_task_runner_->RunUntilIdle();
......@@ -1110,15 +990,8 @@ TEST_F(SafeBrowsingProtocolManagerTest, MultipleRedirectResponsesWithChunks) {
EXPECT_FALSE(pm->IsUpdateScheduled());
// The second redirect response contains a single chunk.
net::TestURLFetcher* second_chunk_url_fetcher =
url_fetcher_factory.GetFetcherByID(2);
ValidateRedirectFetcherRequest(
second_chunk_url_fetcher, "https://redirect-server.example.com/two");
second_chunk_url_fetcher->set_status(net::URLRequestStatus());
second_chunk_url_fetcher->set_response_code(200);
second_chunk_url_fetcher->SetResponseString(kChunkPayload2);
second_chunk_url_fetcher->delegate()->OnURLFetchComplete(
second_chunk_url_fetcher);
ValidateRedirectFetcherRequest("https://redirect-server.example.com/two");
pm->OnURLLoaderCompleteInternal(nullptr, net::OK, 200, kChunkPayload2);
EXPECT_FALSE(pm->IsUpdateScheduled());
......
chrome/browser/safe_browsing/safe_browsing_service.cc
View file @ 1f4a4281
......@@ -446,7 +446,7 @@ void SafeBrowsingService::StartOnIOThread(
GetProtocolManagerDelegate();
if (protocol_manager_delegate) {
protocol_manager_ = SafeBrowsingProtocolManager::Create(
protocol_manager_delegate, url_request_context_getter, config);
protocol_manager_delegate, GetURLLoaderFactoryOnIOThread(), config);
protocol_manager_->Initialize();
}
}
......
chrome/browser/safe_browsing/safe_browsing_service_browsertest.cc
View file @ 1f4a4281
......@@ -576,10 +576,11 @@ class TestSafeBrowsingDatabaseFactory : public SafeBrowsingDatabaseFactory {
// safebrowsing server for testing purpose.
class TestProtocolManager : public SafeBrowsingProtocolManager {
public:
TestProtocolManager(SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
TestProtocolManager(
SafeBrowsingProtocolManagerDelegate* delegate,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config)
: SafeBrowsingProtocolManager(delegate, request_context_getter, config) {
: SafeBrowsingProtocolManager(delegate, url_loader_factory, config) {
create_count_++;
}
......@@ -635,11 +636,11 @@ class TestSBProtocolManagerFactory : public SBProtocolManagerFactory {
std::unique_ptr<SafeBrowsingProtocolManager> CreateProtocolManager(
SafeBrowsingProtocolManagerDelegate* delegate,
net::URLRequestContextGetter* request_context_getter,
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
const SafeBrowsingProtocolConfig& config) override {
base::AutoLock locker(lock_);
pm_ = new TestProtocolManager(delegate, request_context_getter, config);
pm_ = new TestProtocolManager(delegate, url_loader_factory, config);
if (!quit_closure_.is_null()) {
quit_closure_.Run();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment