Add Connector ctor to BinaryUploadService::Request

This also adds calls to this ctor via FileSourceRequest and
ValidateDataUploadRequest.

Bug: 1069066,1069069
Change-Id: Iec602e842fd920563989f05e1d413ca3eaef7eb5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2249089
Commit-Queue: Dominique Fauteux-Chapleau <domfc@chromium.org>
Reviewed-by: Daniel Rubery <drubery@chromium.org>
Cr-Commit-Position: refs/heads/master@{#780047}

chrome/browser/safe_browsing/cloud_content_scanning/binary_upload_service.cc

@@ -18,10 +18,12 @@
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/enterprise/connectors/connectors_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/advanced_protection_status_manager.h"
 #include "chrome/browser/safe_browsing/advanced_protection_status_manager_factory.h"
 #include "chrome/browser/safe_browsing/cloud_content_scanning/binary_fcm_service.h"
+#include "chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_utils.h"
 #include "chrome/browser/safe_browsing/cloud_content_scanning/multipart_uploader.h"
 #include "chrome/browser/safe_browsing/dm_token_utils.h"
 #include "components/enterprise/common/proto/connectors.pb.h"
@@ -574,6 +576,12 @@ 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,
+                                      GURL url)
+    : use_legacy_proto_(false),
+      content_analysis_callback_(std::move(callback)),
+      url_(url) {}
+
 BinaryUploadService::Request::~Request() = default;
 
 void BinaryUploadService::Request::set_request_dlp_scan(
@@ -625,8 +633,14 @@ void BinaryUploadService::Request::set_digest(const std::string& digest) {
 }
 
 void BinaryUploadService::Request::clear_dlp_scan_request() {
-  DCHECK(use_legacy_proto_);
-  deep_scanning_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 it = std::find(tags->begin(), tags->end(), "dlp");
+    if (it != tags->end())
+      tags->erase(it);
+  }
 }
 
 void BinaryUploadService::Request::set_analysis_connector(
@@ -673,6 +687,20 @@ const std::string& BinaryUploadService::Request::fcm_notification_token()
     return content_analysis_request_.fcm_notification_token();
 }
 
+const std::string& BinaryUploadService::Request::filename() const {
+  if (use_legacy_proto_)
+    return deep_scanning_request_.filename();
+  else
+    return content_analysis_request_.request_data().filename();
+}
+
+const std::string& BinaryUploadService::Request::digest() const {
+  if (use_legacy_proto_)
+    return deep_scanning_request_.digest();
+  else
+    return content_analysis_request_.request_data().digest();
+}
+
 void BinaryUploadService::Request::FinishRequest(Result result) {
   if (use_legacy_proto_) {
     std::move(callback_).Run(result, DeepScanningClientResponse());
@@ -711,6 +739,10 @@ class ValidateDataUploadRequest : public BinaryUploadService::Request {
   explicit ValidateDataUploadRequest(BinaryUploadService::Callback callback,
                                      GURL url)
       : BinaryUploadService::Request(std::move(callback), url) {}
+  explicit ValidateDataUploadRequest(
+      BinaryUploadService::ContentAnalysisCallback callback,
+      GURL url)
+      : BinaryUploadService::Request(std::move(callback), url) {}
   ValidateDataUploadRequest(const ValidateDataUploadRequest&) = delete;
   ValidateDataUploadRequest& operator=(const ValidateDataUploadRequest&) =
       delete;
@@ -749,11 +781,20 @@ void BinaryUploadService::IsAuthorized(const GURL& url,
       }
 
       pending_validate_data_upload_request_ = true;
-      auto request = std::make_unique<ValidateDataUploadRequest>(
-          base::BindOnce(
-              &BinaryUploadService::ValidateDataUploadRequestCallback,
-              weakptr_factory_.GetWeakPtr()),
-          url);
+      auto request =
+          base::FeatureList::IsEnabled(
+              enterprise_connectors::kEnterpriseConnectorsEnabled)
+              ? std::make_unique<ValidateDataUploadRequest>(
+                    base::BindOnce(
+                        &BinaryUploadService::
+                            ValidateDataUploadRequestConnectorCallback,
+                        weakptr_factory_.GetWeakPtr()),
+                    url)
+              : std::make_unique<ValidateDataUploadRequest>(
+                    base::BindOnce(
+                        &BinaryUploadService::ValidateDataUploadRequestCallback,
+                        weakptr_factory_.GetWeakPtr()),
+                    url);
       request->set_device_token(dm_token.value());
       UploadForDeepScanning(std::move(request));
     }
@@ -762,6 +803,13 @@ void BinaryUploadService::IsAuthorized(const GURL& url,
   std::move(callback).Run(can_upload_enterprise_data_.value());
 }
 
+void BinaryUploadService::ValidateDataUploadRequestConnectorCallback(
+    BinaryUploadService::Result result,
+    enterprise_connectors::ContentAnalysisResponse response) {
+  pending_validate_data_upload_request_ = false;
+  can_upload_enterprise_data_ = result == BinaryUploadService::Result::SUCCESS;
+}
+
 void BinaryUploadService::ValidateDataUploadRequestCallback(
     BinaryUploadService::Result result,
     DeepScanningClientResponse response) {

chrome/browser/safe_browsing/cloud_content_scanning/binary_upload_service.h

@@ -95,7 +95,8 @@ class BinaryUploadService : public KeyedService {
   class Request {
    public:
     // |callback| will run on the UI thread.
-    explicit Request(Callback callback, GURL url);
+    Request(Callback callback, GURL url);
+    Request(ContentAnalysisCallback, GURL url);
     virtual ~Request();
     Request(const Request&) = delete;
     Request& operator=(const Request&) = delete;
@@ -150,7 +151,6 @@ class BinaryUploadService : public KeyedService {
     void set_request_malware_scan(
         MalwareDeepScanningClientRequest malware_request);
     void set_request_token(const std::string& token);
-    void clear_dlp_scan_request();
 
     // Methods for modifying the ContentAnalysisRequest.
     void set_analysis_connector(
@@ -164,11 +164,14 @@ class BinaryUploadService : public KeyedService {
     void set_device_token(const std::string& token);
     void set_filename(const std::string& filename);
     void set_digest(const std::string& digest);
+    void clear_dlp_scan_request();
 
     // Methods for accessing either internal proto requests.
     const std::string& device_token() const;
     const std::string& request_token() const;
     const std::string& fcm_notification_token() const;
+    const std::string& filename() const;
+    const std::string& digest() const;
 
     // Finish the request, with the given |result| and |response| from the
     // server.
@@ -264,6 +267,9 @@ class BinaryUploadService : public KeyedService {
                                           bool authorized);
 
   // Callback once the response from the backend is received.
+  void ValidateDataUploadRequestConnectorCallback(
+      BinaryUploadService::Result result,
+      enterprise_connectors::ContentAnalysisResponse response);
   void ValidateDataUploadRequestCallback(BinaryUploadService::Result result,
                                          DeepScanningClientResponse response);
 

chrome/browser/safe_browsing/cloud_content_scanning/file_source_request.cc

@@ -104,6 +104,19 @@ FileSourceRequest::FileSourceRequest(
   set_filename(file_name_.AsUTF8Unsafe());
 }
 
+FileSourceRequest::FileSourceRequest(
+    const enterprise_connectors::AnalysisSettings& analysis_settings,
+    base::FilePath path,
+    base::FilePath file_name,
+    BinaryUploadService::ContentAnalysisCallback callback)
+    : Request(std::move(callback), analysis_settings.analysis_url),
+      has_cached_result_(false),
+      block_unsupported_types_(analysis_settings.block_unsupported_file_types),
+      path_(std::move(path)),
+      file_name_(std::move(file_name)) {
+  set_filename(file_name_.AsUTF8Unsafe());
+}
+
 FileSourceRequest::~FileSourceRequest() = default;
 
 void FileSourceRequest::GetRequestData(DataCallback callback) {
@@ -119,6 +132,31 @@ void FileSourceRequest::GetRequestData(DataCallback callback) {
                      weakptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
+bool FileSourceRequest::FileTypeUnsupportedByDlp() const {
+  if (use_legacy_proto()) {
+    return deep_scanning_request().has_dlp_scan_request() &&
+           !FileTypeSupportedForDlp(file_name_);
+  } else {
+    for (const std::string& tag : content_analysis_request().tags()) {
+      if (tag == "dlp")
+        return !FileTypeSupportedForDlp(file_name_);
+    }
+    return false;
+  }
+}
+
+bool FileSourceRequest::HasMalwareRequest() const {
+  if (use_legacy_proto()) {
+    return deep_scanning_request().has_malware_scan_request();
+  } else {
+    for (const std::string& tag : content_analysis_request().tags()) {
+      if (tag == "malware")
+        return true;
+    }
+    return false;
+  }
+}
+
 void FileSourceRequest::OnGotFileData(
     DataCallback callback,
     std::pair<BinaryUploadService::Result, Data> result_and_data) {
@@ -131,13 +169,11 @@ void FileSourceRequest::OnGotFileData(
     return;
   }
 
-  if (deep_scanning_request().has_dlp_scan_request() &&
-      !FileTypeSupportedForDlp(file_name_)) {
+  if (FileTypeUnsupportedByDlp()) {
     // Abort the request early if settings say to block unsupported types or if
     // there was no malware request to be done, otherwise proceed with the
     // malware request only.
-    if (block_unsupported_types_ ||
-        !deep_scanning_request().has_malware_scan_request()) {
+    if (block_unsupported_types_ || !HasMalwareRequest()) {
       CacheResultAndData(
           BinaryUploadService::Result::DLP_SCAN_UNSUPPORTED_FILE_TYPE,
           std::move(result_and_data.second));

chrome/browser/safe_browsing/cloud_content_scanning/file_source_request.h

@@ -21,6 +21,11 @@ class FileSourceRequest : public BinaryUploadService::Request {
       base::FilePath path,
       base::FilePath file_name,
       BinaryUploadService::Callback callback);
+  FileSourceRequest(
+      const enterprise_connectors::AnalysisSettings& analysis_settings,
+      base::FilePath path,
+      base::FilePath file_name,
+      BinaryUploadService::ContentAnalysisCallback callback);
   FileSourceRequest(const FileSourceRequest&) = delete;
   FileSourceRequest& operator=(const FileSourceRequest&) = delete;
   ~FileSourceRequest() override;
@@ -37,6 +42,10 @@ class FileSourceRequest : public BinaryUploadService::Request {
                               Data data,
                               const ArchiveAnalyzerResults& analyzer_result);
 
+  // Helper functions to access the correct request proto.
+  bool FileTypeUnsupportedByDlp() const;
+  bool HasMalwareRequest() const;
+
   void CacheResultAndData(BinaryUploadService::Result result, Data data);
 
   bool has_cached_result_;