Skip to content

GitLab

T
tangled
Commit 8420b2c2 authored by Dominique Fauteux-Chapleau's avatar Dominique Fauteux-Chapleau Committed by Commit Bot
Browse files
Options

Remove legacy protos support from BinaryUploadService 

This should not change deep scanning behaviour with Connectors.

Bug: 1103390
Change-Id: I8f45972d7649eae31d7c3e9024f925c059ad68d1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2427427Reviewed-by: default avatarDaniel Rubery <drubery@chromium.org>
Commit-Queue: Dominique Fauteux-Chapleau <domfc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#810833}
parent e7c7018d
Show whitespace changes
Inline Side-by-side
Showing with 227 additions and 460 deletions
chrome/browser/safe_browsing/cloud_content_scanning/binary_upload_service.cc
View file @ 8420b2c2
...@@ -35,7 +35,6 @@ ...@@ -35,7 +35,6 @@
#include "components/safe_browsing/content/web_ui/safe_browsing_ui.h" #include "components/safe_browsing/content/web_ui/safe_browsing_ui.h"
#include "components/safe_browsing/core/common/safe_browsing_prefs.h" #include "components/safe_browsing/core/common/safe_browsing_prefs.h"
#include "components/safe_browsing/core/features.h" #include "components/safe_browsing/core/features.h"
#include "components/safe_browsing/core/proto/webprotect.pb.h"
#include "content/public/browser/browser_task_traits.h" #include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h" #include "content/public/browser/browser_thread.h"
#include "net/base/url_util.h" #include "net/base/url_util.h"
...@@ -53,16 +52,11 @@ const char kSbAppUploadUrl[] = ...@@ -53,16 +52,11 @@ const char kSbAppUploadUrl[] =
"https://safebrowsing.google.com/safebrowsing/uploads/app"; "https://safebrowsing.google.com/safebrowsing/uploads/app";
bool IsAdvancedProtectionRequest(const BinaryUploadService::Request& request) { bool IsAdvancedProtectionRequest(const BinaryUploadService::Request& request) {
if (request.use_legacy_proto()) { for (const std::string& tag : request.content_analysis_request().tags()) {
return !request.deep_scanning_request().has_dlp_scan_request() && if (tag == "dlp")
request.deep_scanning_request().has_malware_scan_request() && return false;
request.deep_scanning_request()
.malware_scan_request()
.population() ==
MalwareDeepScanningClientRequest::POPULATION_TITANIUM;
} else {
return request.device_token().empty();
} }
return request.device_token().empty();
} }
std::string ResultToString(BinaryUploadService::Result result) { std::string ResultToString(BinaryUploadService::Result result) {
...@@ -235,7 +229,8 @@ void BinaryUploadService::MaybeUploadForDeepScanningCallback( ...@@ -235,7 +229,8 @@ void BinaryUploadService::MaybeUploadForDeepScanningCallback(
if (!authorized) { if (!authorized) {
// TODO(crbug/1028133): Add extra logic to handle UX for non-authorized // TODO(crbug/1028133): Add extra logic to handle UX for non-authorized
// users. // users.
request->FinishRequest(Result::UNAUTHORIZED); request->FinishRequest(Result::UNAUTHORIZED,
enterprise_connectors::ContentAnalysisResponse());
return; return;
} }
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
...@@ -256,21 +251,17 @@ void BinaryUploadService::UploadForDeepScanning( ...@@ -256,21 +251,17 @@ void BinaryUploadService::UploadForDeepScanning(
if (!binary_fcm_service_) { if (!binary_fcm_service_) {
content::GetUIThreadTaskRunner({})->PostTask( content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&BinaryUploadService::FinishRequest, FROM_HERE,
base::BindOnce(&BinaryUploadService::FinishRequest,
weakptr_factory_.GetWeakPtr(), raw_request, weakptr_factory_.GetWeakPtr(), raw_request,
Result::FAILED_TO_GET_TOKEN)); Result::FAILED_TO_GET_TOKEN,
enterprise_connectors::ContentAnalysisResponse()));
return; return;
} }
if (raw_request->use_legacy_proto()) {
binary_fcm_service_->SetCallbackForToken(
token, base::BindRepeating(&BinaryUploadService::OnGetLegacyResponse,
weakptr_factory_.GetWeakPtr(), raw_request));
} else {
binary_fcm_service_->SetCallbackForToken( binary_fcm_service_->SetCallbackForToken(
token, base::BindRepeating(&BinaryUploadService::OnGetConnectorResponse, token, base::BindRepeating(&BinaryUploadService::OnGetResponse,
weakptr_factory_.GetWeakPtr(), raw_request)); weakptr_factory_.GetWeakPtr(), raw_request));
}
binary_fcm_service_->GetInstanceID( binary_fcm_service_->GetInstanceID(
base::BindOnce(&BinaryUploadService::OnGetInstanceID, base::BindOnce(&BinaryUploadService::OnGetInstanceID,
weakptr_factory_.GetWeakPtr(), raw_request)); weakptr_factory_.GetWeakPtr(), raw_request));
...@@ -287,7 +278,8 @@ void BinaryUploadService::OnGetInstanceID(Request* request, ...@@ -287,7 +278,8 @@ void BinaryUploadService::OnGetInstanceID(Request* request,
return; return;
if (instance_id == BinaryFCMService::kInvalidId) { if (instance_id == BinaryFCMService::kInvalidId) {
FinishRequest(request, Result::FAILED_TO_GET_TOKEN); FinishRequest(request, Result::FAILED_TO_GET_TOKEN,
enterprise_connectors::ContentAnalysisResponse());
return; return;
} }
...@@ -310,7 +302,8 @@ void BinaryUploadService::OnGetRequestData(Request* request, ...@@ -310,7 +302,8 @@ void BinaryUploadService::OnGetRequestData(Request* request,
return; return;
if (result != Result::SUCCESS) { if (result != Result::SUCCESS) {
FinishRequest(request, result); FinishRequest(request, result,
enterprise_connectors::ContentAnalysisResponse());
return; return;
} }
...@@ -327,13 +320,8 @@ void BinaryUploadService::OnGetRequestData(Request* request, ...@@ -327,13 +320,8 @@ void BinaryUploadService::OnGetRequestData(Request* request,
base::BindOnce(&BinaryUploadService::OnUploadComplete, base::BindOnce(&BinaryUploadService::OnUploadComplete,
weakptr_factory_.GetWeakPtr(), request)); weakptr_factory_.GetWeakPtr(), request));
if (request->use_legacy_proto()) {
WebUIInfoSingleton::GetInstance()->AddToDeepScanRequests(
request->deep_scanning_request());
} else {
WebUIInfoSingleton::GetInstance()->AddToDeepScanRequests( WebUIInfoSingleton::GetInstance()->AddToDeepScanRequests(
request->tab_url(), request->content_analysis_request()); request->tab_url(), request->content_analysis_request());
}
// |request| might have been deleted by the call to Start() in tests, so don't // |request| might have been deleted by the call to Start() in tests, so don't
// dereference it afterwards. // dereference it afterwards.
...@@ -348,26 +336,15 @@ void BinaryUploadService::OnUploadComplete(Request* request, ...@@ -348,26 +336,15 @@ void BinaryUploadService::OnUploadComplete(Request* request,
return; return;
if (!success) { if (!success) {
FinishRequest(request, Result::UPLOAD_FAILURE); FinishRequest(request, Result::UPLOAD_FAILURE,
return; enterprise_connectors::ContentAnalysisResponse());
}
if (request->use_legacy_proto()) {
DeepScanningClientResponse response;
if (!response.ParseFromString(response_data)) {
FinishRequest(request, Result::UPLOAD_FAILURE);
return; return;
} }
active_uploads_.erase(request);
// Synchronous scans can return results in the initial response proto, so
// check for those.
OnGetLegacyResponse(request, response);
} else {
enterprise_connectors::ContentAnalysisResponse response; enterprise_connectors::ContentAnalysisResponse response;
if (!response.ParseFromString(response_data)) { if (!response.ParseFromString(response_data)) {
FinishRequest(request, Result::UPLOAD_FAILURE); FinishRequest(request, Result::UPLOAD_FAILURE,
enterprise_connectors::ContentAnalysisResponse());
return; return;
} }
...@@ -375,11 +352,10 @@ void BinaryUploadService::OnUploadComplete(Request* request, ...@@ -375,11 +352,10 @@ void BinaryUploadService::OnUploadComplete(Request* request,
// Synchronous scans can return results in the initial response proto, so // Synchronous scans can return results in the initial response proto, so
// check for those. // check for those.
OnGetConnectorResponse(request, response); OnGetResponse(request, response);
}
} }
void BinaryUploadService::OnGetConnectorResponse( void BinaryUploadService::OnGetResponse(
Request* request, Request* request,
enterprise_connectors::ContentAnalysisResponse response) { enterprise_connectors::ContentAnalysisResponse response) {
if (!IsActive(request)) if (!IsActive(request))
...@@ -393,32 +369,10 @@ void BinaryUploadService::OnGetConnectorResponse( ...@@ -393,32 +369,10 @@ void BinaryUploadService::OnGetConnectorResponse(
} }
} }
MaybeFinishConnectorRequest(request); MaybeFinishRequest(request);
} }
void BinaryUploadService::OnGetLegacyResponse( void BinaryUploadService::MaybeFinishRequest(Request* request) {
Request* request,
DeepScanningClientResponse response) {
if (!IsActive(request))
return;
if (response.has_dlp_scan_verdict()) {
VLOG(1) << "Request " << request->request_token()
<< " finished DLP scanning";
received_dlp_verdicts_[request].reset(response.release_dlp_scan_verdict());
}
if (response.has_malware_scan_verdict()) {
VLOG(1) << "Request " << request->request_token()
<< " finished malware scanning";
received_malware_verdicts_[request].reset(
response.release_malware_scan_verdict());
}
MaybeFinishLegacyRequest(request);
}
void BinaryUploadService::MaybeFinishConnectorRequest(Request* request) {
for (const std::string& tag : request->content_analysis_request().tags()) { for (const std::string& tag : request->content_analysis_request().tags()) {
const auto& results = received_connector_results_[request]; const auto& results = received_connector_results_[request];
if (std::none_of(results.begin(), results.end(), if (std::none_of(results.begin(), results.end(),
...@@ -436,62 +390,16 @@ void BinaryUploadService::MaybeFinishConnectorRequest(Request* request) { ...@@ -436,62 +390,16 @@ void BinaryUploadService::MaybeFinishConnectorRequest(Request* request) {
response.set_request_token(request->request_token()); response.set_request_token(request->request_token());
for (auto& tag_and_result : received_connector_results_[request]) for (auto& tag_and_result : received_connector_results_[request])
*response.add_results() = std::move(tag_and_result.second); *response.add_results() = std::move(tag_and_result.second);
FinishConnectorRequest(request, Result::SUCCESS, std::move(response)); FinishRequest(request, Result::SUCCESS, std::move(response));
}
void BinaryUploadService::MaybeFinishLegacyRequest(Request* request) {
bool requested_dlp_scan_response =
request->deep_scanning_request().has_dlp_scan_request();
auto received_dlp_response = received_dlp_verdicts_.find(request);
if (requested_dlp_scan_response &&
received_dlp_response == received_dlp_verdicts_.end()) {
VLOG(1) << "Request " << request->request_token()
<< " is waiting for DLP scanning to complete.";
return;
}
bool requested_malware_scan_response =
request->deep_scanning_request().has_malware_scan_request();
auto received_malware_response = received_malware_verdicts_.find(request);
if (requested_malware_scan_response &&
received_malware_response == received_malware_verdicts_.end()) {
VLOG(1) << "Request " << request->request_token()
<< " is waiting for malware scanning to complete.";
return;
}
DeepScanningClientResponse response;
response.set_token(request->request_token());
if (requested_dlp_scan_response) {
// Transfers ownership of the DLP response to |response|.
response.set_allocated_dlp_scan_verdict(
received_dlp_response->second.release());
}
if (requested_malware_scan_response) {
// Transfers ownership of the malware response to |response|.
response.set_allocated_malware_scan_verdict(
received_malware_response->second.release());
}
FinishLegacyRequest(request, Result::SUCCESS, std::move(response));
} }
void BinaryUploadService::OnTimeout(Request* request) { void BinaryUploadService::OnTimeout(Request* request) {
if (IsActive(request)) if (IsActive(request))
FinishRequest(request, Result::TIMEOUT); FinishRequest(request, Result::TIMEOUT,
}
void BinaryUploadService::FinishRequest(Request* request, Result result) {
if (request->use_legacy_proto()) {
FinishLegacyRequest(request, result, DeepScanningClientResponse());
} else {
FinishConnectorRequest(request, result,
enterprise_connectors::ContentAnalysisResponse()); enterprise_connectors::ContentAnalysisResponse());
}
} }
void BinaryUploadService::FinishConnectorRequest( void BinaryUploadService::FinishRequest(
Request* request, Request* request,
Result result, Result result,
enterprise_connectors::ContentAnalysisResponse response) { enterprise_connectors::ContentAnalysisResponse response) {
...@@ -505,25 +413,7 @@ void BinaryUploadService::FinishConnectorRequest( ...@@ -505,25 +413,7 @@ void BinaryUploadService::FinishConnectorRequest(
active_tokens_[request], ResultToString(result), response); active_tokens_[request], ResultToString(result), response);
std::string instance_id = request->fcm_notification_token(); std::string instance_id = request->fcm_notification_token();
request->FinishConnectorRequest(result, response); request->FinishRequest(result, response);
FinishRequestCleanup(request, instance_id);
}
void BinaryUploadService::FinishLegacyRequest(
Request* request,
Result result,
DeepScanningClientResponse response) {
RecordRequestMetrics(request, result, response);
// We add the request here in case we never actually uploaded anything, so it
// wasn't added in OnGetRequestData
WebUIInfoSingleton::GetInstance()->AddToDeepScanRequests(
request->deep_scanning_request());
WebUIInfoSingleton::GetInstance()->AddToDeepScanResponses(
active_tokens_[request], ResultToString(result), response);
std::string instance_id = request->fcm_notification_token();
request->FinishLegacyRequest(result, response);
FinishRequestCleanup(request, instance_id); FinishRequestCleanup(request, instance_id);
} }
...@@ -626,184 +516,104 @@ void BinaryUploadService::RecordRequestMetrics( ...@@ -626,184 +516,104 @@ void BinaryUploadService::RecordRequestMetrics(
BinaryUploadService::Request::Data::Data() = default; BinaryUploadService::Request::Data::Data() = default;
BinaryUploadService::Request::Request(Callback callback, GURL url)
: use_legacy_proto_(true), callback_(std::move(callback)), url_(url) {}
BinaryUploadService::Request::Request(ContentAnalysisCallback callback, BinaryUploadService::Request::Request(ContentAnalysisCallback callback,
GURL url) GURL url)
: use_legacy_proto_(false), : content_analysis_callback_(std::move(callback)), url_(url) {}
content_analysis_callback_(std::move(callback)),
url_(url) {}
BinaryUploadService::Request::~Request() = default; BinaryUploadService::Request::~Request() = default;
void BinaryUploadService::Request::set_tab_url(const GURL& tab_url) { void BinaryUploadService::Request::set_tab_url(const GURL& tab_url) {
DCHECK(!use_legacy_proto_);
tab_url_ = tab_url; tab_url_ = tab_url;
} }
const GURL& BinaryUploadService::Request::tab_url() const { const GURL& BinaryUploadService::Request::tab_url() const {
DCHECK(!use_legacy_proto_);
return tab_url_; return tab_url_;
} }
void BinaryUploadService::Request::set_request_dlp_scan(
DlpDeepScanningClientRequest dlp_request) {
DCHECK(use_legacy_proto_);
*deep_scanning_request_.mutable_dlp_scan_request() = std::move(dlp_request);
}
void BinaryUploadService::Request::set_request_malware_scan(
MalwareDeepScanningClientRequest malware_request) {
DCHECK(use_legacy_proto_);
*deep_scanning_request_.mutable_malware_scan_request() =
std::move(malware_request);
}
void BinaryUploadService::Request::set_fcm_token(const std::string& token) { void BinaryUploadService::Request::set_fcm_token(const std::string& token) {
if (use_legacy_proto_)
deep_scanning_request_.set_fcm_notification_token(token);
else
content_analysis_request_.set_fcm_notification_token(token); content_analysis_request_.set_fcm_notification_token(token);
} }
void BinaryUploadService::Request::set_device_token(const std::string& token) { void BinaryUploadService::Request::set_device_token(const std::string& token) {
if (use_legacy_proto_)
deep_scanning_request_.set_dm_token(token);
else
content_analysis_request_.set_device_token(token); content_analysis_request_.set_device_token(token);
} }
void BinaryUploadService::Request::set_request_token(const std::string& token) { void BinaryUploadService::Request::set_request_token(const std::string& token) {
if (use_legacy_proto_)
deep_scanning_request_.set_request_token(token);
else
content_analysis_request_.set_request_token(token); content_analysis_request_.set_request_token(token);
} }
void BinaryUploadService::Request::set_filename(const std::string& filename) { void BinaryUploadService::Request::set_filename(const std::string& filename) {
if (use_legacy_proto_)
deep_scanning_request_.set_filename(filename);
else
content_analysis_request_.mutable_request_data()->set_filename(filename); content_analysis_request_.mutable_request_data()->set_filename(filename);
} }
void BinaryUploadService::Request::set_digest(const std::string& digest) { void BinaryUploadService::Request::set_digest(const std::string& digest) {
if (use_legacy_proto_)
deep_scanning_request_.set_digest(digest);
else
content_analysis_request_.mutable_request_data()->set_digest(digest); content_analysis_request_.mutable_request_data()->set_digest(digest);
} }
void BinaryUploadService::Request::clear_dlp_scan_request() { void BinaryUploadService::Request::clear_dlp_scan_request() {
if (use_legacy_proto()) {
deep_scanning_request_.clear_dlp_scan_request();
} else {
auto* tags = content_analysis_request_.mutable_tags(); auto* tags = content_analysis_request_.mutable_tags();
auto it = std::find(tags->begin(), tags->end(), "dlp"); auto it = std::find(tags->begin(), tags->end(), "dlp");
if (it != tags->end()) if (it != tags->end())
tags->erase(it); tags->erase(it);
}
} }
void BinaryUploadService::Request::set_analysis_connector( void BinaryUploadService::Request::set_analysis_connector(
enterprise_connectors::AnalysisConnector connector) { enterprise_connectors::AnalysisConnector connector) {
DCHECK(!use_legacy_proto_);
content_analysis_request_.set_analysis_connector(connector); content_analysis_request_.set_analysis_connector(connector);
} }
void BinaryUploadService::Request::set_url(const std::string& url) { void BinaryUploadService::Request::set_url(const std::string& url) {
DCHECK(!use_legacy_proto_);
content_analysis_request_.mutable_request_data()->set_url(url); content_analysis_request_.mutable_request_data()->set_url(url);
} }
void BinaryUploadService::Request::set_csd(ClientDownloadRequest csd) { void BinaryUploadService::Request::set_csd(ClientDownloadRequest csd) {
DCHECK(!use_legacy_proto_);
*content_analysis_request_.mutable_request_data()->mutable_csd() = *content_analysis_request_.mutable_request_data()->mutable_csd() =
std::move(csd); std::move(csd);
} }
void BinaryUploadService::Request::add_tag(const std::string& tag) { void BinaryUploadService::Request::add_tag(const std::string& tag) {
DCHECK(!use_legacy_proto_);
content_analysis_request_.add_tags(tag); content_analysis_request_.add_tags(tag);
} }
void BinaryUploadService::Request::set_email(const std::string& email) { void BinaryUploadService::Request::set_email(const std::string& email) {
DCHECK(!use_legacy_proto_);
content_analysis_request_.mutable_request_data()->set_email(email); content_analysis_request_.mutable_request_data()->set_email(email);
} }
const std::string& BinaryUploadService::Request::device_token() const { const std::string& BinaryUploadService::Request::device_token() const {
if (use_legacy_proto_)
return deep_scanning_request_.dm_token();
else
return content_analysis_request_.device_token(); return content_analysis_request_.device_token();
} }
const std::string& BinaryUploadService::Request::request_token() const { const std::string& BinaryUploadService::Request::request_token() const {
if (use_legacy_proto_)
return deep_scanning_request_.request_token();
else
return content_analysis_request_.request_token(); return content_analysis_request_.request_token();
} }
const std::string& BinaryUploadService::Request::fcm_notification_token() const std::string& BinaryUploadService::Request::fcm_notification_token()
const { const {
if (use_legacy_proto_)
return deep_scanning_request_.fcm_notification_token();
else
return content_analysis_request_.fcm_notification_token(); return content_analysis_request_.fcm_notification_token();
} }
const std::string& BinaryUploadService::Request::filename() const { const std::string& BinaryUploadService::Request::filename() const {
if (use_legacy_proto_)
return deep_scanning_request_.filename();
else
return content_analysis_request_.request_data().filename(); return content_analysis_request_.request_data().filename();
} }
const std::string& BinaryUploadService::Request::digest() const { const std::string& BinaryUploadService::Request::digest() const {
if (use_legacy_proto_)
return deep_scanning_request_.digest();
else
return content_analysis_request_.request_data().digest(); return content_analysis_request_.request_data().digest();
} }
void BinaryUploadService::Request::FinishRequest(Result result) { void BinaryUploadService::Request::FinishRequest(
if (use_legacy_proto_) {
std::move(callback_).Run(result, DeepScanningClientResponse());
} else {
std::move(content_analysis_callback_)
.Run(result, enterprise_connectors::ContentAnalysisResponse());
}
}
void BinaryUploadService::Request::FinishConnectorRequest(
Result result, Result result,
enterprise_connectors::ContentAnalysisResponse response) { enterprise_connectors::ContentAnalysisResponse response) {
std::move(content_analysis_callback_).Run(result, response); std::move(content_analysis_callback_).Run(result, response);
} }
void BinaryUploadService::Request::FinishLegacyRequest(
Result result,
DeepScanningClientResponse response) {
std::move(callback_).Run(result, response);
}
void BinaryUploadService::Request::SerializeToString( void BinaryUploadService::Request::SerializeToString(
std::string* destination) const { std::string* destination) const {
if (use_legacy_proto_)
deep_scanning_request_.SerializeToString(destination);
else
content_analysis_request_.SerializeToString(destination); content_analysis_request_.SerializeToString(destination);
} }
GURL BinaryUploadService::Request::GetUrlWithParams() const { GURL BinaryUploadService::Request::GetUrlWithParams() const {
GURL url = GetUrlOverride().value_or(url_); GURL url = GetUrlOverride().value_or(url_);
if (use_legacy_proto_)
return url;
url = net::AppendQueryParameter(url, enterprise::kUrlParamDeviceToken, url = net::AppendQueryParameter(url, enterprise::kUrlParamDeviceToken,
device_token()); device_token());
...@@ -838,10 +648,7 @@ bool BinaryUploadService::IsActive(Request* request) { ...@@ -838,10 +648,7 @@ bool BinaryUploadService::IsActive(Request* request) {
class ValidateDataUploadRequest : public BinaryUploadService::Request { class ValidateDataUploadRequest : public BinaryUploadService::Request {
public: public:
explicit ValidateDataUploadRequest(BinaryUploadService::Callback callback, ValidateDataUploadRequest(
GURL url)
: BinaryUploadService::Request(std::move(callback), url) {}
explicit ValidateDataUploadRequest(
BinaryUploadService::ContentAnalysisCallback callback, BinaryUploadService::ContentAnalysisCallback callback,
GURL url) GURL url)
: BinaryUploadService::Request(std::move(callback), url) {} : BinaryUploadService::Request(std::move(callback), url) {}
...@@ -883,18 +690,9 @@ void BinaryUploadService::IsAuthorized(const GURL& url, ...@@ -883,18 +690,9 @@ void BinaryUploadService::IsAuthorized(const GURL& url,
} }
pending_validate_data_upload_request_ = true; pending_validate_data_upload_request_ = true;
auto request = auto request = std::make_unique<ValidateDataUploadRequest>(
base::FeatureList::IsEnabled(
enterprise_connectors::kEnterpriseConnectorsEnabled)
? std::make_unique<ValidateDataUploadRequest>(
base::BindOnce(
&BinaryUploadService::
ValidateDataUploadRequestConnectorCallback,
weakptr_factory_.GetWeakPtr()),
url)
: std::make_unique<ValidateDataUploadRequest>(
base::BindOnce( base::BindOnce(
&BinaryUploadService::ValidateDataUploadRequestCallback, &BinaryUploadService::ValidateDataUploadRequestConnectorCallback,
weakptr_factory_.GetWeakPtr()), weakptr_factory_.GetWeakPtr()),
url); url);
request->set_device_token(dm_token.value()); request->set_device_token(dm_token.value());
......
chrome/browser/safe_browsing/cloud_content_scanning/binary_upload_service.h
View file @ 8420b2c2
...@@ -22,7 +22,6 @@ ...@@ -22,7 +22,6 @@
#include "components/enterprise/common/proto/connectors.pb.h" #include "components/enterprise/common/proto/connectors.pb.h"
#include "components/keyed_service/core/keyed_service.h" #include "components/keyed_service/core/keyed_service.h"
#include "components/safe_browsing/core/proto/csd.pb.h" #include "components/safe_browsing/core/proto/csd.pb.h"
#include "components/safe_browsing/core/proto/webprotect.pb.h"
#include "services/network/public/cpp/shared_url_loader_factory.h" #include "services/network/public/cpp/shared_url_loader_factory.h"
class Profile; class Profile;
...@@ -97,7 +96,6 @@ class BinaryUploadService : public KeyedService { ...@@ -97,7 +96,6 @@ class BinaryUploadService : public KeyedService {
class Request { class Request {
public: public:
// |callback| will run on the UI thread. // |callback| will run on the UI thread.
Request(Callback callback, GURL url);
Request(ContentAnalysisCallback, GURL url); Request(ContentAnalysisCallback, GURL url);
virtual ~Request(); virtual ~Request();
Request(const Request&) = delete; Request(const Request&) = delete;
...@@ -132,11 +130,6 @@ class BinaryUploadService : public KeyedService { ...@@ -132,11 +130,6 @@ class BinaryUploadService : public KeyedService {
using DataCallback = base::OnceCallback<void(Result, const Data&)>; using DataCallback = base::OnceCallback<void(Result, const Data&)>;
virtual void GetRequestData(DataCallback callback) = 0; virtual void GetRequestData(DataCallback callback) = 0;
// Returns the metadata to upload, as a DeepScanningClientRequest.
const DeepScanningClientRequest& deep_scanning_request() const {
return deep_scanning_request_;
}
// Returns the URL to send the request to. // Returns the URL to send the request to.
GURL GetUrlWithParams() const; GURL GetUrlWithParams() const;
...@@ -146,17 +139,9 @@ class BinaryUploadService : public KeyedService { ...@@ -146,17 +139,9 @@ class BinaryUploadService : public KeyedService {
return content_analysis_request_; return content_analysis_request_;
} }
bool use_legacy_proto() const { return use_legacy_proto_; }
void set_tab_url(const GURL& tab_url); void set_tab_url(const GURL& tab_url);
const GURL& tab_url() const; const GURL& tab_url() const;
// Methods for modifying the DeepScanningClientRequest.
void set_request_dlp_scan(DlpDeepScanningClientRequest dlp_request);
void set_request_malware_scan(
MalwareDeepScanningClientRequest malware_request);
void set_request_token(const std::string& token);
// Methods for modifying the ContentAnalysisRequest. // Methods for modifying the ContentAnalysisRequest.
void set_analysis_connector( void set_analysis_connector(
enterprise_connectors::AnalysisConnector connector); enterprise_connectors::AnalysisConnector connector);
...@@ -164,15 +149,14 @@ class BinaryUploadService : public KeyedService { ...@@ -164,15 +149,14 @@ class BinaryUploadService : public KeyedService {
void set_csd(ClientDownloadRequest csd); void set_csd(ClientDownloadRequest csd);
void add_tag(const std::string& tag); void add_tag(const std::string& tag);
void set_email(const std::string& email); void set_email(const std::string& email);
void set_request_token(const std::string& token);
// Methods for modifying either internal proto requests.
void set_fcm_token(const std::string& token); void set_fcm_token(const std::string& token);
void set_device_token(const std::string& token); void set_device_token(const std::string& token);
void set_filename(const std::string& filename); void set_filename(const std::string& filename);
void set_digest(const std::string& digest); void set_digest(const std::string& digest);
void clear_dlp_scan_request(); void clear_dlp_scan_request();
// Methods for accessing either internal proto requests. // Methods for accessing the ContentAnalysisRequest.
const std::string& device_token() const; const std::string& device_token() const;
const std::string& request_token() const; const std::string& request_token() const;
const std::string& fcm_notification_token() const; const std::string& fcm_notification_token() const;
...@@ -181,26 +165,19 @@ class BinaryUploadService : public KeyedService { ...@@ -181,26 +165,19 @@ class BinaryUploadService : public KeyedService {
// Finish the request, with the given |result| and |response| from the // Finish the request, with the given |result| and |response| from the
// server. // server.
void FinishRequest(Result result); void FinishRequest(Result result,
void FinishConnectorRequest(
Result result,
enterprise_connectors::ContentAnalysisResponse response); enterprise_connectors::ContentAnalysisResponse response);
void FinishLegacyRequest(Result result,
DeepScanningClientResponse response);
// Calls SerializeToString on the appropriate proto request. // Calls SerializeToString on the appropriate proto request.
void SerializeToString(std::string* destination) const; void SerializeToString(std::string* destination) const;
private: private:
const bool use_legacy_proto_;
DeepScanningClientRequest deep_scanning_request_;
Callback callback_;
enterprise_connectors::ContentAnalysisRequest content_analysis_request_; enterprise_connectors::ContentAnalysisRequest content_analysis_request_;
ContentAnalysisCallback content_analysis_callback_; ContentAnalysisCallback content_analysis_callback_;
// The URL to send the data to for scanning.
GURL url_; GURL url_;
// The URL of the page that initially triggered the scan. // The URL of the page that initially triggered the scan.
GURL tab_url_; GURL tab_url_;
}; };
...@@ -230,14 +207,9 @@ class BinaryUploadService : public KeyedService { ...@@ -230,14 +207,9 @@ class BinaryUploadService : public KeyedService {
static GURL GetUploadUrl(bool is_advanced_protection_request); static GURL GetUploadUrl(bool is_advanced_protection_request);
protected: protected:
void FinishRequest(Request* request, Result result); void FinishRequest(Request* request,
void FinishConnectorRequest(
Request* request,
Result result, Result result,
enterprise_connectors::ContentAnalysisResponse response); enterprise_connectors::ContentAnalysisResponse response);
void FinishLegacyRequest(Request* request,
Result result,
DeepScanningClientResponse response);
private: private:
friend class BinaryUploadServiceTest; friend class BinaryUploadServiceTest;
...@@ -257,14 +229,10 @@ class BinaryUploadService : public KeyedService { ...@@ -257,14 +229,10 @@ class BinaryUploadService : public KeyedService {
bool success, bool success,
const std::string& response_data); const std::string& response_data);
void OnGetConnectorResponse( void OnGetResponse(Request* request,
Request* request,
enterprise_connectors::ContentAnalysisResponse response); enterprise_connectors::ContentAnalysisResponse response);
void OnGetLegacyResponse(Request* request,
DeepScanningClientResponse response);
void MaybeFinishConnectorRequest(Request* request); void MaybeFinishRequest(Request* request);
void MaybeFinishLegacyRequest(Request* request);
void OnTimeout(Request* request); void OnTimeout(Request* request);
...@@ -292,7 +260,7 @@ class BinaryUploadService : public KeyedService { ...@@ -292,7 +260,7 @@ class BinaryUploadService : public KeyedService {
Result result, Result result,
const DeepScanningClientResponse& response); const DeepScanningClientResponse& response);
// Called at the end of either Finish{Connector|Legacy}Request methods. // Called at the end of the FinishRequest method.
void FinishRequestCleanup(Request* request, const std::string& instance_id); void FinishRequestCleanup(Request* request, const std::string& instance_id);
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_; scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
......
chrome/browser/safe_browsing/cloud_content_scanning/binary_upload_service_unittest.cc
View file @ 8420b2c2
...@@ -35,9 +35,7 @@ using ::testing::SaveArg; ...@@ -35,9 +35,7 @@ using ::testing::SaveArg;
class MockRequest : public BinaryUploadService::Request { class MockRequest : public BinaryUploadService::Request {
public: public:
explicit MockRequest(BinaryUploadService::Callback callback) MockRequest(BinaryUploadService::ContentAnalysisCallback callback,
: BinaryUploadService::Request(std::move(callback), GURL()) {}
explicit MockRequest(BinaryUploadService::ContentAnalysisCallback callback,
const GURL& url) const GURL& url)
: BinaryUploadService::Request(std::move(callback), url) {} : BinaryUploadService::Request(std::move(callback), url) {}
MOCK_METHOD1(GetRequestData, void(DataCallback)); MOCK_METHOD1(GetRequestData, void(DataCallback));
...@@ -45,8 +43,9 @@ class MockRequest : public BinaryUploadService::Request { ...@@ -45,8 +43,9 @@ class MockRequest : public BinaryUploadService::Request {
class FakeMultipartUploadRequest : public MultipartUploadRequest { class FakeMultipartUploadRequest : public MultipartUploadRequest {
public: public:
FakeMultipartUploadRequest(bool should_succeed, FakeMultipartUploadRequest(
DeepScanningClientResponse response, bool should_succeed,
enterprise_connectors::ContentAnalysisResponse response,
Callback callback) Callback callback)
: MultipartUploadRequest(nullptr, : MultipartUploadRequest(nullptr,
GURL(), GURL(),
...@@ -66,14 +65,15 @@ class FakeMultipartUploadRequest : public MultipartUploadRequest { ...@@ -66,14 +65,15 @@ class FakeMultipartUploadRequest : public MultipartUploadRequest {
private: private:
bool should_succeed_; bool should_succeed_;
DeepScanningClientResponse response_; enterprise_connectors::ContentAnalysisResponse response_;
Callback callback_; Callback callback_;
}; };
class FakeMultipartUploadRequestFactory : public MultipartUploadRequestFactory { class FakeMultipartUploadRequestFactory : public MultipartUploadRequestFactory {
public: public:
FakeMultipartUploadRequestFactory(bool should_succeed, FakeMultipartUploadRequestFactory(
DeepScanningClientResponse response) bool should_succeed,
enterprise_connectors::ContentAnalysisResponse response)
: should_succeed_(should_succeed), response_(response) {} : should_succeed_(should_succeed), response_(response) {}
std::unique_ptr<MultipartUploadRequest> Create( std::unique_ptr<MultipartUploadRequest> Create(
...@@ -89,7 +89,7 @@ class FakeMultipartUploadRequestFactory : public MultipartUploadRequestFactory { ...@@ -89,7 +89,7 @@ class FakeMultipartUploadRequestFactory : public MultipartUploadRequestFactory {
private: private:
bool should_succeed_; bool should_succeed_;
DeepScanningClientResponse response_; enterprise_connectors::ContentAnalysisResponse response_;
}; };
class MockBinaryFCMService : public BinaryFCMService { class MockBinaryFCMService : public BinaryFCMService {
...@@ -108,7 +108,7 @@ class BinaryUploadServiceTest : public testing::Test { ...@@ -108,7 +108,7 @@ class BinaryUploadServiceTest : public testing::Test {
public: public:
BinaryUploadServiceTest() BinaryUploadServiceTest()
: task_environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME), : task_environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME),
fake_factory_(true, DeepScanningClientResponse()) { fake_factory_(true, enterprise_connectors::ContentAnalysisResponse()) {
MultipartUploadRequest::RegisterFactoryForTests(&fake_factory_); MultipartUploadRequest::RegisterFactoryForTests(&fake_factory_);
auto fcm_service = std::make_unique<MockBinaryFCMService>(); auto fcm_service = std::make_unique<MockBinaryFCMService>();
fcm_service_ = fcm_service.get(); fcm_service_ = fcm_service.get();
...@@ -122,8 +122,9 @@ class BinaryUploadServiceTest : public testing::Test { ...@@ -122,8 +122,9 @@ class BinaryUploadServiceTest : public testing::Test {
MultipartUploadRequest::RegisterFactoryForTests(nullptr); MultipartUploadRequest::RegisterFactoryForTests(nullptr);
} }
void ExpectNetworkResponse(bool should_succeed, void ExpectNetworkResponse(
DeepScanningClientResponse response) { bool should_succeed,
enterprise_connectors::ContentAnalysisResponse response) {
fake_factory_ = FakeMultipartUploadRequestFactory(should_succeed, response); fake_factory_ = FakeMultipartUploadRequestFactory(should_succeed, response);
} }
...@@ -148,9 +149,10 @@ class BinaryUploadServiceTest : public testing::Test { ...@@ -148,9 +149,10 @@ class BinaryUploadServiceTest : public testing::Test {
service_->MaybeUploadForDeepScanning(std::move(request)); service_->MaybeUploadForDeepScanning(std::move(request));
} }
void ReceiveMessageForRequest(BinaryUploadService::Request* request, void ReceiveMessageForRequest(
const DeepScanningClientResponse& response) { BinaryUploadService::Request* request,
service_->OnGetLegacyResponse(request, response); const enterprise_connectors::ContentAnalysisResponse& response) {
service_->OnGetResponse(request, response);
} }
void ReceiveResponseFromUpload(BinaryUploadService::Request* request, void ReceiveResponseFromUpload(BinaryUploadService::Request* request,
...@@ -166,16 +168,21 @@ class BinaryUploadServiceTest : public testing::Test { ...@@ -166,16 +168,21 @@ class BinaryUploadServiceTest : public testing::Test {
std::unique_ptr<MockRequest> MakeRequest( std::unique_ptr<MockRequest> MakeRequest(
BinaryUploadService::Result* scanning_result, BinaryUploadService::Result* scanning_result,
DeepScanningClientResponse* scanning_response) { enterprise_connectors::ContentAnalysisResponse* scanning_response,
auto request = std::make_unique<MockRequest>(base::BindOnce( bool is_app) {
auto request = std::make_unique<MockRequest>(
base::BindOnce(
[](BinaryUploadService::Result* target_result, [](BinaryUploadService::Result* target_result,
DeepScanningClientResponse* target_response, enterprise_connectors::ContentAnalysisResponse* target_response,
BinaryUploadService::Result result, BinaryUploadService::Result result,
DeepScanningClientResponse response) { enterprise_connectors::ContentAnalysisResponse response) {
*target_result = result; *target_result = result;
*target_response = response; *target_response = response;
}, },
scanning_result, scanning_response)); scanning_result, scanning_response),
GURL());
if (!is_app)
request->set_device_token("fake_device_token");
ON_CALL(*request, GetRequestData(_)) ON_CALL(*request, GetRequestData(_))
.WillByDefault( .WillByDefault(
Invoke([](BinaryUploadService::Request::DataCallback callback) { Invoke([](BinaryUploadService::Request::DataCallback callback) {
...@@ -209,11 +216,11 @@ class BinaryUploadServiceTest : public testing::Test { ...@@ -209,11 +216,11 @@ class BinaryUploadServiceTest : public testing::Test {
TEST_F(BinaryUploadServiceTest, FailsForLargeFile) { TEST_F(BinaryUploadServiceTest, FailsForLargeFile) {
BinaryUploadService::Result scanning_result; BinaryUploadService::Result scanning_result;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
ON_CALL(*request, GetRequestData(_)) ON_CALL(*request, GetRequestData(_))
.WillByDefault( .WillByDefault(
Invoke([](BinaryUploadService::Request::DataCallback callback) { Invoke([](BinaryUploadService::Request::DataCallback callback) {
...@@ -230,10 +237,10 @@ TEST_F(BinaryUploadServiceTest, FailsForLargeFile) { ...@@ -230,10 +237,10 @@ TEST_F(BinaryUploadServiceTest, FailsForLargeFile) {
TEST_F(BinaryUploadServiceTest, FailsWhenMissingInstanceID) { TEST_F(BinaryUploadServiceTest, FailsWhenMissingInstanceID) {
BinaryUploadService::Result scanning_result; BinaryUploadService::Result scanning_result;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
ExpectInstanceID(BinaryFCMService::kInvalidId); ExpectInstanceID(BinaryFCMService::kInvalidId);
...@@ -245,12 +252,13 @@ TEST_F(BinaryUploadServiceTest, FailsWhenMissingInstanceID) { ...@@ -245,12 +252,13 @@ TEST_F(BinaryUploadServiceTest, FailsWhenMissingInstanceID) {
TEST_F(BinaryUploadServiceTest, FailsWhenUploadFails) { TEST_F(BinaryUploadServiceTest, FailsWhenUploadFails) {
BinaryUploadService::Result scanning_result; BinaryUploadService::Result scanning_result;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
ExpectNetworkResponse(false, DeepScanningClientResponse()); ExpectNetworkResponse(false,
enterprise_connectors::ContentAnalysisResponse());
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
content::RunAllTasksUntilIdle(); content::RunAllTasksUntilIdle();
...@@ -261,48 +269,54 @@ TEST_F(BinaryUploadServiceTest, FailsWhenUploadFails) { ...@@ -261,48 +269,54 @@ TEST_F(BinaryUploadServiceTest, FailsWhenUploadFails) {
TEST_F(BinaryUploadServiceTest, HoldsScanResponsesUntilAllReady) { TEST_F(BinaryUploadServiceTest, HoldsScanResponsesUntilAllReady) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
ExpectNetworkResponse(true, DeepScanningClientResponse()); ExpectNetworkResponse(true, enterprise_connectors::ContentAnalysisResponse());
MockRequest* raw_request = request.get(); MockRequest* raw_request = request.get();
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
content::RunAllTasksUntilIdle(); content::RunAllTasksUntilIdle();
// Simulate receiving the DLP response // Simulate receiving the DLP response
DeepScanningClientResponse response; enterprise_connectors::ContentAnalysisResponse response;
response.mutable_dlp_scan_verdict(); auto* dlp_result = response.add_results();
dlp_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
dlp_result->set_tag("dlp");
ReceiveMessageForRequest(raw_request, response); ReceiveMessageForRequest(raw_request, response);
content::RunAllTasksUntilIdle(); content::RunAllTasksUntilIdle();
EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN); EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN);
// Simulate receiving the malware response // Simulate receiving the malware response
response.clear_dlp_scan_verdict(); response.clear_results();
response.mutable_malware_scan_verdict(); auto* malware_result = response.add_results();
malware_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
malware_result->set_tag("malware");
ReceiveMessageForRequest(raw_request, response); ReceiveMessageForRequest(raw_request, response);
content::RunAllTasksUntilIdle(); content::RunAllTasksUntilIdle();
EXPECT_TRUE(scanning_response.has_dlp_scan_verdict()); EXPECT_EQ(scanning_response.results().at(0).tag(), "dlp");
EXPECT_TRUE(scanning_response.has_malware_scan_verdict()); EXPECT_EQ(scanning_response.results().at(1).tag(), "malware");
EXPECT_EQ(scanning_result, BinaryUploadService::Result::SUCCESS); EXPECT_EQ(scanning_result, BinaryUploadService::Result::SUCCESS);
} }
TEST_F(BinaryUploadServiceTest, TimesOut) { TEST_F(BinaryUploadServiceTest, TimesOut) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
ExpectNetworkResponse(true, DeepScanningClientResponse()); ExpectNetworkResponse(true, enterprise_connectors::ContentAnalysisResponse());
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
content::RunAllTasksUntilIdle(); content::RunAllTasksUntilIdle();
task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(300)); task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(300));
...@@ -313,11 +327,11 @@ TEST_F(BinaryUploadServiceTest, TimesOut) { ...@@ -313,11 +327,11 @@ TEST_F(BinaryUploadServiceTest, TimesOut) {
TEST_F(BinaryUploadServiceTest, OnInstanceIDAfterTimeout) { TEST_F(BinaryUploadServiceTest, OnInstanceIDAfterTimeout) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
BinaryFCMService::GetInstanceIDCallback instance_id_callback; BinaryFCMService::GetInstanceIDCallback instance_id_callback;
ON_CALL(*fcm_service_, GetInstanceID(_)) ON_CALL(*fcm_service_, GetInstanceID(_))
...@@ -327,7 +341,7 @@ TEST_F(BinaryUploadServiceTest, OnInstanceIDAfterTimeout) { ...@@ -327,7 +341,7 @@ TEST_F(BinaryUploadServiceTest, OnInstanceIDAfterTimeout) {
instance_id_callback = std::move(callback); instance_id_callback = std::move(callback);
})); }));
ExpectNetworkResponse(true, DeepScanningClientResponse()); ExpectNetworkResponse(true, enterprise_connectors::ContentAnalysisResponse());
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
content::RunAllTasksUntilIdle(); content::RunAllTasksUntilIdle();
task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(300)); task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(300));
...@@ -342,14 +356,14 @@ TEST_F(BinaryUploadServiceTest, OnInstanceIDAfterTimeout) { ...@@ -342,14 +356,14 @@ TEST_F(BinaryUploadServiceTest, OnInstanceIDAfterTimeout) {
TEST_F(BinaryUploadServiceTest, OnUploadCompleteAfterTimeout) { TEST_F(BinaryUploadServiceTest, OnUploadCompleteAfterTimeout) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
ExpectNetworkResponse(true, DeepScanningClientResponse()); ExpectNetworkResponse(true, enterprise_connectors::ContentAnalysisResponse());
MockRequest* raw_request = request.get(); MockRequest* raw_request = request.get();
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
...@@ -365,14 +379,14 @@ TEST_F(BinaryUploadServiceTest, OnUploadCompleteAfterTimeout) { ...@@ -365,14 +379,14 @@ TEST_F(BinaryUploadServiceTest, OnUploadCompleteAfterTimeout) {
TEST_F(BinaryUploadServiceTest, OnGetResponseAfterTimeout) { TEST_F(BinaryUploadServiceTest, OnGetResponseAfterTimeout) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
ExpectNetworkResponse(true, DeepScanningClientResponse()); ExpectNetworkResponse(true, enterprise_connectors::ContentAnalysisResponse());
MockRequest* raw_request = request.get(); MockRequest* raw_request = request.get();
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
...@@ -381,22 +395,29 @@ TEST_F(BinaryUploadServiceTest, OnGetResponseAfterTimeout) { ...@@ -381,22 +395,29 @@ TEST_F(BinaryUploadServiceTest, OnGetResponseAfterTimeout) {
EXPECT_EQ(scanning_result, BinaryUploadService::Result::TIMEOUT); EXPECT_EQ(scanning_result, BinaryUploadService::Result::TIMEOUT);
// Expect nothing to change if we get a message after the timeout. // Expect nothing to change if we get a message after the timeout.
ReceiveMessageForRequest(raw_request, DeepScanningClientResponse()); ReceiveMessageForRequest(raw_request,
enterprise_connectors::ContentAnalysisResponse());
EXPECT_EQ(scanning_result, BinaryUploadService::Result::TIMEOUT); EXPECT_EQ(scanning_result, BinaryUploadService::Result::TIMEOUT);
} }
TEST_F(BinaryUploadServiceTest, OnUnauthorized) { TEST_F(BinaryUploadServiceTest, OnUnauthorized) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
DeepScanningClientResponse simulated_response; enterprise_connectors::ContentAnalysisResponse simulated_response;
simulated_response.mutable_dlp_scan_verdict(); auto* dlp_result = simulated_response.add_results();
simulated_response.mutable_malware_scan_verdict(); dlp_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
dlp_result->set_tag("dlp");
auto* malware_result = simulated_response.add_results();
malware_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
malware_result->set_tag("malware");
ExpectNetworkResponse(true, simulated_response); ExpectNetworkResponse(true, simulated_response);
EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN); EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN);
...@@ -416,17 +437,23 @@ TEST_F(BinaryUploadServiceTest, OnUnauthorized) { ...@@ -416,17 +437,23 @@ TEST_F(BinaryUploadServiceTest, OnUnauthorized) {
TEST_F(BinaryUploadServiceTest, OnGetSynchronousResponse) { TEST_F(BinaryUploadServiceTest, OnGetSynchronousResponse) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
DeepScanningClientResponse simulated_response; enterprise_connectors::ContentAnalysisResponse simulated_response;
simulated_response.mutable_dlp_scan_verdict(); auto* dlp_result = simulated_response.add_results();
simulated_response.mutable_malware_scan_verdict(); dlp_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
dlp_result->set_tag("dlp");
auto* malware_result = simulated_response.add_results();
malware_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
malware_result->set_tag("malware");
ExpectNetworkResponse(true, simulated_response); ExpectNetworkResponse(true, simulated_response);
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
...@@ -440,11 +467,11 @@ TEST_F(BinaryUploadServiceTest, ReturnsAsynchronouslyWithNoFCM) { ...@@ -440,11 +467,11 @@ TEST_F(BinaryUploadServiceTest, ReturnsAsynchronouslyWithNoFCM) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ false);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->set_request_malware_scan(MalwareDeepScanningClientRequest()); request->add_tag("malware");
UploadForDeepScanning(std::move(request)); UploadForDeepScanning(std::move(request));
...@@ -468,20 +495,22 @@ TEST_F(BinaryUploadServiceTest, AdvancedProtectionMalwareRequestAuthorized) { ...@@ -468,20 +495,22 @@ TEST_F(BinaryUploadServiceTest, AdvancedProtectionMalwareRequestAuthorized) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ true);
request->add_tag("malware");
MalwareDeepScanningClientRequest malware_request;
malware_request.set_population(
MalwareDeepScanningClientRequest::POPULATION_TITANIUM);
request->set_request_malware_scan(malware_request);
ExpectInstanceID("valid id"); ExpectInstanceID("valid id");
DeepScanningClientResponse simulated_response; enterprise_connectors::ContentAnalysisResponse simulated_response;
simulated_response.mutable_dlp_scan_verdict(); auto* dlp_result = simulated_response.add_results();
simulated_response.mutable_malware_scan_verdict(); dlp_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
dlp_result->set_tag("dlp");
auto* malware_result = simulated_response.add_results();
malware_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
malware_result->set_tag("malware");
ExpectNetworkResponse(true, simulated_response); ExpectNetworkResponse(true, simulated_response);
EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN); EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN);
...@@ -500,20 +529,22 @@ TEST_F(BinaryUploadServiceTest, AdvancedProtectionDlpRequestUnauthorized) { ...@@ -500,20 +529,22 @@ TEST_F(BinaryUploadServiceTest, AdvancedProtectionDlpRequestUnauthorized) {
BinaryUploadService::Result scanning_result = BinaryUploadService::Result scanning_result =
BinaryUploadService::Result::UNKNOWN; BinaryUploadService::Result::UNKNOWN;
DeepScanningClientResponse scanning_response; enterprise_connectors::ContentAnalysisResponse scanning_response;
std::unique_ptr<MockRequest> request = std::unique_ptr<MockRequest> request =
MakeRequest(&scanning_result, &scanning_response); MakeRequest(&scanning_result, &scanning_response, /*is_app*/ true);
request->set_request_dlp_scan(DlpDeepScanningClientRequest()); request->add_tag("dlp");
request->add_tag("malware");
MalwareDeepScanningClientRequest malware_request;
malware_request.set_population( enterprise_connectors::ContentAnalysisResponse simulated_response;
MalwareDeepScanningClientRequest::POPULATION_TITANIUM); auto* dlp_result = simulated_response.add_results();
request->set_request_malware_scan(malware_request); dlp_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
DeepScanningClientResponse simulated_response; dlp_result->set_tag("dlp");
simulated_response.mutable_dlp_scan_verdict(); auto* malware_result = simulated_response.add_results();
simulated_response.mutable_malware_scan_verdict(); malware_result->set_status(
enterprise_connectors::ContentAnalysisResponse::Result::SUCCESS);
malware_result->set_tag("malware");
ExpectNetworkResponse(true, simulated_response); ExpectNetworkResponse(true, simulated_response);
EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN); EXPECT_EQ(scanning_result, BinaryUploadService::Result::UNKNOWN);
......
chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_dialog_delegate.cc
View file @ 8420b2c2
...@@ -71,9 +71,6 @@ DeepScanningDialogDelegate::Factory* GetFactoryStorage() { ...@@ -71,9 +71,6 @@ DeepScanningDialogDelegate::Factory* GetFactoryStorage() {
// from a string. // from a string.
class StringSourceRequest : public BinaryUploadService::Request { class StringSourceRequest : public BinaryUploadService::Request {
public: public:
StringSourceRequest(GURL analysis_url,
std::string text,
BinaryUploadService::Callback callback);
StringSourceRequest(GURL analysis_url, StringSourceRequest(GURL analysis_url,
std::string text, std::string text,
BinaryUploadService::ContentAnalysisCallback callback); BinaryUploadService::ContentAnalysisCallback callback);
...@@ -91,17 +88,6 @@ class StringSourceRequest : public BinaryUploadService::Request { ...@@ -91,17 +88,6 @@ class StringSourceRequest : public BinaryUploadService::Request {
BinaryUploadService::Result::FILE_TOO_LARGE; BinaryUploadService::Result::FILE_TOO_LARGE;
}; };
StringSourceRequest::StringSourceRequest(GURL analysis_url,
std::string text,
BinaryUploadService::Callback callback)
: Request(std::move(callback), analysis_url) {
// Only remember strings less than the maximum allowed.
if (text.size() < BinaryUploadService::kMaxUploadSizeBytes) {
data_.contents = std::move(text);
result_ = BinaryUploadService::Result::SUCCESS;
}
}
StringSourceRequest::StringSourceRequest( StringSourceRequest::StringSourceRequest(
GURL analysis_url, GURL analysis_url,
std::string text, std::string text,
...@@ -632,7 +618,8 @@ void DeepScanningDialogDelegate::OnGotFileInfo( ...@@ -632,7 +618,8 @@ void DeepScanningDialogDelegate::OnGotFileInfo(
// property (too large, unsupported file type, encrypted, ...) that make its // property (too large, unsupported file type, encrypted, ...) that make its
// upload pointless, so the request should finish early. // upload pointless, so the request should finish early.
if (result != BinaryUploadService::Result::SUCCESS) { if (result != BinaryUploadService::Result::SUCCESS) {
request->FinishRequest(result); request->FinishRequest(result,
enterprise_connectors::ContentAnalysisResponse());
return; return;
} }
......
chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_dialog_delegate_browsertest.cc
View file @ 8420b2c2
...@@ -52,7 +52,8 @@ class FakeBinaryUploadService : public BinaryUploadService { ...@@ -52,7 +52,8 @@ class FakeBinaryUploadService : public BinaryUploadService {
// Finish the authentication request. Called after ShowForWebContents to // Finish the authentication request. Called after ShowForWebContents to
// simulate an async callback. // simulate an async callback.
void ReturnAuthorizedResponse() { void ReturnAuthorizedResponse() {
FinishRequest(authorization_request_.get(), authorization_result_); FinishRequest(authorization_request_.get(), authorization_result_,
enterprise_connectors::ContentAnalysisResponse());
} }
void SetResponseForText( void SetResponseForText(
...@@ -87,12 +88,11 @@ class FakeBinaryUploadService : public BinaryUploadService { ...@@ -87,12 +88,11 @@ class FakeBinaryUploadService : public BinaryUploadService {
} else { } else {
std::string file = request->filename(); std::string file = request->filename();
if (file.empty()) { if (file.empty()) {
request->FinishConnectorRequest(prepared_text_result_, request->FinishRequest(prepared_text_result_, prepared_text_response_);
prepared_text_response_);
} else { } else {
ASSERT_TRUE(prepared_file_results_.count(file)); ASSERT_TRUE(prepared_file_results_.count(file));
ASSERT_TRUE(prepared_file_responses_.count(file)); ASSERT_TRUE(prepared_file_responses_.count(file));
request->FinishConnectorRequest(prepared_file_results_[file], request->FinishRequest(prepared_file_results_[file],
prepared_file_responses_[file]); prepared_file_responses_[file]);
} }
} }
......
chrome/browser/safe_browsing/cloud_content_scanning/test_binary_upload_service.cc
View file @ 8420b2c2
...@@ -18,17 +18,9 @@ TestBinaryUploadService::TestBinaryUploadService() ...@@ -18,17 +18,9 @@ TestBinaryUploadService::TestBinaryUploadService()
void TestBinaryUploadService::MaybeUploadForDeepScanning( void TestBinaryUploadService::MaybeUploadForDeepScanning(
std::unique_ptr<Request> request) { std::unique_ptr<Request> request) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI); DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
if (request->use_legacy_proto()) {
content::GetUIThreadTaskRunner({})->PostTask( content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, FROM_HERE, base::BindOnce(&Request::FinishRequest, std::move(request),
base::BindOnce(&Request::FinishLegacyRequest, std::move(request),
saved_result_, saved_response_)); saved_result_, saved_response_));
} else {
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&Request::FinishConnectorRequest, std::move(request),
saved_result_, saved_content_analysis_response_));
}
was_called_ = true; was_called_ = true;
} }
...@@ -36,12 +28,6 @@ void TestBinaryUploadService::SetResponse( ...@@ -36,12 +28,6 @@ void TestBinaryUploadService::SetResponse(
Result result, Result result,
enterprise_connectors::ContentAnalysisResponse response) { enterprise_connectors::ContentAnalysisResponse response) {
saved_result_ = result; saved_result_ = result;
saved_content_analysis_response_ = response;
}
void TestBinaryUploadService::SetResponse(Result result,
DeepScanningClientResponse response) {
saved_result_ = result;
saved_response_ = response; saved_response_ = response;
} }
......
chrome/browser/safe_browsing/cloud_content_scanning/test_binary_upload_service.h
View file @ 8420b2c2
...@@ -21,16 +21,13 @@ class TestBinaryUploadService : public BinaryUploadService { ...@@ -21,16 +21,13 @@ class TestBinaryUploadService : public BinaryUploadService {
void MaybeUploadForDeepScanning(std::unique_ptr<Request> request) override; void MaybeUploadForDeepScanning(std::unique_ptr<Request> request) override;
void SetResponse(Result result, void SetResponse(Result result,
enterprise_connectors::ContentAnalysisResponse response); enterprise_connectors::ContentAnalysisResponse response);
void SetResponse(Result result, DeepScanningClientResponse response);
bool was_called() { return was_called_; } bool was_called() { return was_called_; }
void ClearWasCalled(); void ClearWasCalled();
private: private:
Result saved_result_ = Result::UNKNOWN; Result saved_result_ = Result::UNKNOWN;
DeepScanningClientResponse saved_response_ = DeepScanningClientResponse(); enterprise_connectors::ContentAnalysisResponse saved_response_;
enterprise_connectors::ContentAnalysisResponse
saved_content_analysis_response_;
bool was_called_ = false; bool was_called_ = false;
}; };
......
chrome/browser/safe_browsing/download_protection/deep_scanning_request_unittest.cc
View file @ 8420b2c2
...@@ -68,7 +68,7 @@ class FakeBinaryUploadService : public BinaryUploadService { ...@@ -68,7 +68,7 @@ class FakeBinaryUploadService : public BinaryUploadService {
void MaybeUploadForDeepScanning(std::unique_ptr<Request> request) override { void MaybeUploadForDeepScanning(std::unique_ptr<Request> request) override {
last_request_ = request->content_analysis_request(); last_request_ = request->content_analysis_request();
request->FinishConnectorRequest(saved_result_, saved_response_); request->FinishRequest(saved_result_, saved_response_);
} }
void SetResponse(BinaryUploadService::Result result, void SetResponse(BinaryUploadService::Result result,
......
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