Reland "Reuse upload browsertests for corresponding Enterprise Connectors"

This is a reland of 8a905049

The issue was that settings_list->Get was in a DCHECK, meaning it was
never ran in non-debug builds. This fixes it by removing the DCHECK and
also uses GetList()::operator[] instead of
Get(size_t index, Value** out_value) since the later is deprecated.

Original change's description:
> Reuse upload browsertests for corresponding Enterprise Connectors
>
> This reuses tests by having the policy setters of
> DeepScanningBrowserTestBase set either legacy or Connector policies, and
> then making every upload browsertest parametrized with a bool so both
> policy sets get tested.
>
> The DeepScanningDialogViews test also change a bit, the ScanType test
> parameter is removed since this dialog doesn't depend on the type of
> scanning being done. This avoids having a very large number of
> combinations for that test that don't cover different code paths.
>
> Bug: 1076083
> Change-Id: I419b21de0095add8b5b214993be010d022941202
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2210782
> Reviewed-by: Roger Tawa <rogerta@chromium.org>
> Commit-Queue: Dominique Fauteux-Chapleau <domfc@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#770745}

Bug: 1076083
Change-Id: I28eb4e2b9db730152c8c7f2a0a8404372ee00923
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2211903Reviewed-by: Roger Tawa <rogerta@chromium.org>
Commit-Queue: Dominique Fauteux-Chapleau <domfc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#771100}

chrome/browser/enterprise/connectors/analysis_service_settings.cc

@@ -27,7 +27,7 @@ AnalysisServiceSettings::AnalysisServiceSettings(
   matcher_ = std::make_unique<url_matcher::URLMatcher>();
   url_matcher::URLMatcherConditionSet::ID id(0);
   const base::Value* enable = settings_value.FindListKey(kKeyEnable);
-  if (enable && enable->is_list()) {
+  if (enable && enable->is_list() && !enable->GetList().empty()) {
     for (const base::Value& value : enable->GetList())
       AddUrlPatternSettings(value, true, &id);
   } else {

chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_browsertest_base.cc

@@ -5,13 +5,16 @@
 #include "chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_browsertest_base.h"
 #include "base/bind_helpers.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/enterprise/connectors/connectors_manager.h"
 #include "chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_dialog_views.h"
+#include "chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_test_utils.h"
 #include "chrome/browser/safe_browsing/cloud_content_scanning/fake_deep_scanning_dialog_delegate.h"
 #include "chrome/browser/safe_browsing/dm_token_utils.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "components/safe_browsing/core/common/safe_browsing_prefs.h"
 #include "components/safe_browsing/core/features.h"
 
 namespace safe_browsing {
@@ -63,10 +66,17 @@ class UnresponsiveDeepScanningDialogDelegate
 
 }  // namespace
 
-DeepScanningBrowserTestBase::DeepScanningBrowserTestBase() {
+DeepScanningBrowserTestBase::DeepScanningBrowserTestBase(
+    bool use_legacy_policies)
+    : use_legacy_policies_(use_legacy_policies) {
   // Enable every deep scanning features.
-  scoped_feature_list_.InitWithFeatures(
-      {kContentComplianceEnabled, kMalwareScanEnabled}, {});
+  if (use_legacy_policies_) {
+    scoped_feature_list_.InitWithFeatures(
+        {kContentComplianceEnabled, kMalwareScanEnabled}, {});
+  } else {
+    scoped_feature_list_.InitWithFeatures(
+        {enterprise_connectors::kEnterpriseConnectorsEnabled}, {});
+  }
 
   // Change the time values of the upload UI to smaller ones to make tests
   // showing it run faster.
@@ -78,7 +88,12 @@ DeepScanningBrowserTestBase::DeepScanningBrowserTestBase() {
 
 DeepScanningBrowserTestBase::~DeepScanningBrowserTestBase() = default;
 
+void DeepScanningBrowserTestBase::SetUpOnMainThread() {
+  enterprise_connectors::ConnectorsManager::GetInstance()->SetUpForTesting();
+}
+
 void DeepScanningBrowserTestBase::TearDownOnMainThread() {
+  enterprise_connectors::ConnectorsManager::GetInstance()->TearDownForTesting();
   DeepScanningDialogDelegate::ResetFactoryForTesting();
 
   SetDlpPolicy(CheckContentComplianceValues::CHECK_NONE);
@@ -90,42 +105,68 @@ void DeepScanningBrowserTestBase::TearDownOnMainThread() {
       BlockUnsupportedFiletypesValues::BLOCK_UNSUPPORTED_FILETYPES_NONE);
   SetBlockLargeFileTransferPolicy(BlockLargeFileTransferValues::BLOCK_NONE);
   SetUnsafeEventsReportingPolicy(false);
+  ClearUrlsToCheckComplianceOfDownloads();
+  ClearUrlsToCheckForMalwareOfUploads();
 }
 
 void DeepScanningBrowserTestBase::SetDlpPolicy(
     CheckContentComplianceValues state) {
-  g_browser_process->local_state()->SetInteger(prefs::kCheckContentCompliance,
-                                               state);
+  if (use_legacy_policies_) {
+    g_browser_process->local_state()->SetInteger(prefs::kCheckContentCompliance,
+                                                 state);
+  } else {
+    SetDlpPolicyForConnectors(state);
+  }
 }
 
 void DeepScanningBrowserTestBase::SetMalwarePolicy(
     SendFilesForMalwareCheckValues state) {
-  browser()->profile()->GetPrefs()->SetInteger(
-      prefs::kSafeBrowsingSendFilesForMalwareCheck, state);
+  if (use_legacy_policies_) {
+    browser()->profile()->GetPrefs()->SetInteger(
+        prefs::kSafeBrowsingSendFilesForMalwareCheck, state);
+  } else {
+    SetMalwarePolicyForConnectors(state);
+  }
 }
 
 void DeepScanningBrowserTestBase::SetWaitPolicy(
     DelayDeliveryUntilVerdictValues state) {
-  g_browser_process->local_state()->SetInteger(
-      prefs::kDelayDeliveryUntilVerdict, state);
+  if (use_legacy_policies_) {
+    g_browser_process->local_state()->SetInteger(
+        prefs::kDelayDeliveryUntilVerdict, state);
+  } else {
+    SetDelayDeliveryUntilVerdictPolicyForConnectors(state);
+  }
 }
 
 void DeepScanningBrowserTestBase::SetAllowPasswordProtectedFilesPolicy(
     AllowPasswordProtectedFilesValues state) {
-  g_browser_process->local_state()->SetInteger(
-      prefs::kAllowPasswordProtectedFiles, state);
+  if (use_legacy_policies_) {
+    g_browser_process->local_state()->SetInteger(
+        prefs::kAllowPasswordProtectedFiles, state);
+  } else {
+    SetAllowPasswordProtectedFilesPolicyForConnectors(state);
+  }
 }
 
 void DeepScanningBrowserTestBase::SetBlockUnsupportedFileTypesPolicy(
     BlockUnsupportedFiletypesValues state) {
-  g_browser_process->local_state()->SetInteger(
-      prefs::kBlockUnsupportedFiletypes, state);
+  if (use_legacy_policies_) {
+    g_browser_process->local_state()->SetInteger(
+        prefs::kBlockUnsupportedFiletypes, state);
+  } else {
+    SetBlockUnsupportedFileTypesPolicyForConnectors(state);
+  }
 }
 
 void DeepScanningBrowserTestBase::SetBlockLargeFileTransferPolicy(
     BlockLargeFileTransferValues state) {
-  g_browser_process->local_state()->SetInteger(prefs::kBlockLargeFileTransfer,
-                                               state);
+  if (use_legacy_policies_) {
+    g_browser_process->local_state()->SetInteger(prefs::kBlockLargeFileTransfer,
+                                                 state);
+  } else {
+    SetBlockLargeFileTransferPolicyForConnectors(state);
+  }
 }
 
 void DeepScanningBrowserTestBase::SetUnsafeEventsReportingPolicy(bool report) {
@@ -135,9 +176,44 @@ void DeepScanningBrowserTestBase::SetUnsafeEventsReportingPolicy(bool report) {
 
 void DeepScanningBrowserTestBase::AddUrlToCheckComplianceOfDownloads(
     const std::string& url) {
-  ListPrefUpdate(g_browser_process->local_state(),
-                 prefs::kURLsToCheckComplianceOfDownloadedContent)
-      ->Append(url);
+  if (use_legacy_policies_) {
+    ListPrefUpdate(g_browser_process->local_state(),
+                   prefs::kURLsToCheckComplianceOfDownloadedContent)
+        ->Append(url);
+  } else {
+    AddUrlsToCheckComplianceOfDownloadsForConnectors({url});
+  }
+}
+
+void DeepScanningBrowserTestBase::AddUrlToCheckForMalwareOfUploads(
+    const std::string& url) {
+  if (use_legacy_policies_) {
+    ListPrefUpdate(g_browser_process->local_state(),
+                   prefs::kURLsToCheckForMalwareOfUploadedContent)
+        ->Append(url);
+  } else {
+    AddUrlsToCheckForMalwareOfUploadsForConnectors({url});
+  }
+}
+
+void DeepScanningBrowserTestBase::ClearUrlsToCheckComplianceOfDownloads() {
+  if (use_legacy_policies_) {
+    ListPrefUpdate(g_browser_process->local_state(),
+                   prefs::kURLsToCheckComplianceOfDownloadedContent)
+        ->Clear();
+  } else {
+    ClearUrlsToCheckComplianceOfDownloadsForConnectors();
+  }
+}
+
+void DeepScanningBrowserTestBase::ClearUrlsToCheckForMalwareOfUploads() {
+  if (use_legacy_policies_) {
+    ListPrefUpdate(g_browser_process->local_state(),
+                   prefs::kURLsToCheckForMalwareOfUploadedContent)
+        ->Clear();
+  } else {
+    ClearUrlsToCheckForMalwareOfUploadsForConnectors();
+  }
 }
 
 void DeepScanningBrowserTestBase::SetUpDelegate() {

chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_browsertest_base.h

@@ -15,9 +15,10 @@ namespace safe_browsing {
 // used by browser tests should be added to this class.
 class DeepScanningBrowserTestBase : public InProcessBrowserTest {
  public:
-  DeepScanningBrowserTestBase();
+  explicit DeepScanningBrowserTestBase(bool use_legacy_policies = true);
   ~DeepScanningBrowserTestBase() override;
 
+  void SetUpOnMainThread() override;
   void TearDownOnMainThread() override;
 
   // Setters for deep scanning policies.
@@ -31,6 +32,9 @@ class DeepScanningBrowserTestBase : public InProcessBrowserTest {
   void SetBlockLargeFileTransferPolicy(BlockLargeFileTransferValues state);
   void SetUnsafeEventsReportingPolicy(bool report);
   void AddUrlToCheckComplianceOfDownloads(const std::string& url);
+  void AddUrlToCheckForMalwareOfUploads(const std::string& url);
+  void ClearUrlsToCheckComplianceOfDownloads();
+  void ClearUrlsToCheckForMalwareOfUploads();
 
   // Sets up a FakeDeepScanningDialogDelegate to use this class's StatusCallback
   // and EncryptionStatusCallback. Also sets up a test DM token.
@@ -64,6 +68,7 @@ class DeepScanningBrowserTestBase : public InProcessBrowserTest {
   DeepScanningClientResponse status_callback_response_;
   base::ScopedTempDir temp_dir_;
   std::vector<base::FilePath> created_file_paths_;
+  bool use_legacy_policies_;
 };
 
 }  // namespace safe_browsing

chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_dialog_views_browsertest.cc

@@ -27,10 +27,8 @@ constexpr base::TimeDelta kNoDelay = base::TimeDelta::FromSeconds(0);
 constexpr base::TimeDelta kSmallDelay = base::TimeDelta::FromMilliseconds(300);
 constexpr base::TimeDelta kNormalDelay = base::TimeDelta::FromMilliseconds(500);
 
-enum class ScanType { ONLY_DLP, ONLY_MALWARE, DLP_AND_MALWARE };
-
 // Tests the behavior of the dialog in the following ways:
-// - It shows the appropriate buttons depending on it's state.
+// - It shows the appropriate buttons depending on its state.
 // - It transitions from states in the correct order.
 // - It respects time constraints (minimum shown time, initial delay, timeout)
 // - It is always destroyed, therefore |quit_closure_| is called in the dtor
@@ -39,14 +37,13 @@ class DeepScanningDialogViewsBehaviorBrowserTest
     : public DeepScanningBrowserTestBase,
       public DeepScanningDialogViews::TestObserver,
       public testing::WithParamInterface<
-          std::tuple<ScanType, bool, bool, base::TimeDelta>> {
+          std::tuple<bool, bool, bool, base::TimeDelta>> {
  public:
-  DeepScanningDialogViewsBehaviorBrowserTest() {
+  DeepScanningDialogViewsBehaviorBrowserTest()
+      : DeepScanningBrowserTestBase(std::get<0>(GetParam())) {
     DeepScanningDialogViews::SetObserverForTesting(this);
 
-    bool dlp_result = !dlp_enabled() || dlp_success();
-    bool malware_result = !malware_enabled() || malware_success();
-    expected_scan_result_ = dlp_result && malware_result;
+    expected_scan_result_ = dlp_success() && malware_success();
   }
 
   void ConstructorCalled(DeepScanningDialogViews* views,
@@ -158,14 +155,6 @@ class DeepScanningDialogViewsBehaviorBrowserTest
     CallQuitClosure();
   }
 
-  bool dlp_enabled() const {
-    return std::get<0>(GetParam()) != ScanType::ONLY_MALWARE;
-  }
-
-  bool malware_enabled() const {
-    return std::get<0>(GetParam()) != ScanType::ONLY_DLP;
-  }
-
   bool dlp_success() const { return std::get<1>(GetParam()); }
 
   bool malware_success() const { return std::get<2>(GetParam()); }
@@ -194,9 +183,11 @@ class DeepScanningDialogViewsBehaviorBrowserTest
 // - The "CancelledByUser" metrics are recorded.
 class DeepScanningDialogViewsCancelPendingScanBrowserTest
     : public DeepScanningBrowserTestBase,
+      public testing::WithParamInterface<bool>,
       public DeepScanningDialogViews::TestObserver {
  public:
-  DeepScanningDialogViewsCancelPendingScanBrowserTest() {
+  DeepScanningDialogViewsCancelPendingScanBrowserTest()
+      : DeepScanningBrowserTestBase(GetParam()) {
     DeepScanningDialogViews::SetObserverForTesting(this);
   }
 
@@ -238,9 +229,11 @@ class DeepScanningDialogViewsCancelPendingScanBrowserTest
 class DeepScanningDialogViewsWarningBrowserTest
     : public DeepScanningBrowserTestBase,
       public DeepScanningDialogViews::TestObserver,
-      public testing::WithParamInterface<std::tuple<base::TimeDelta, bool>> {
+      public testing::WithParamInterface<
+          std::tuple<base::TimeDelta, bool, bool>> {
  public:
-  DeepScanningDialogViewsWarningBrowserTest() {
+  DeepScanningDialogViewsWarningBrowserTest()
+      : DeepScanningBrowserTestBase(std::get<2>(GetParam())) {
     DeepScanningDialogViews::SetObserverForTesting(this);
   }
 
@@ -304,9 +297,10 @@ class DeepScanningDialogViewsAppearanceBrowserTest
     : public DeepScanningBrowserTestBase,
       public DeepScanningDialogViews::TestObserver,
       public testing::WithParamInterface<
-          std::tuple<bool, bool, DeepScanAccessPoint>> {
+          std::tuple<bool, bool, DeepScanAccessPoint, bool>> {
  public:
-  DeepScanningDialogViewsAppearanceBrowserTest() {
+  DeepScanningDialogViewsAppearanceBrowserTest()
+      : DeepScanningBrowserTestBase(std::get<3>(GetParam())) {
     DeepScanningDialogViews::SetObserverForTesting(this);
   }
 
@@ -411,28 +405,13 @@ constexpr char kTestUrl[] = "https://google.com";
 IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsBehaviorBrowserTest, Test) {
   base::ScopedAllowBlockingForTesting allow_blocking;
 
-  // The test is wrong if neither DLP or Malware is enabled. This would imply a
-  // Deep Scanning call site called ShowForWebContents without first checking
-  // IsEnabled returns true.
-  EXPECT_TRUE(dlp_enabled() || malware_enabled());
-
   // Setup policies to enable deep scanning, its UI and the responses to be
   // simulated.
-  base::Optional<bool> dlp = base::nullopt;
-  base::Optional<bool> malware = base::nullopt;
-  if (dlp_enabled()) {
-    dlp = dlp_success();
-    SetDlpPolicy(CHECK_UPLOADS_AND_DOWNLOADS);
-  }
-  if (malware_enabled()) {
-    malware = malware_success();
-    SetMalwarePolicy(SEND_UPLOADS_AND_DOWNLOADS);
-    ListPrefUpdate(g_browser_process->local_state(),
-                   prefs::kURLsToCheckForMalwareOfUploadedContent)
-        ->Append("*");
-  }
-  SetStatusCallbackResponse(
-      SimpleDeepScanningClientResponseForTesting(dlp, malware));
+  SetDlpPolicy(CHECK_UPLOADS_AND_DOWNLOADS);
+  SetMalwarePolicy(SEND_UPLOADS_AND_DOWNLOADS);
+  AddUrlToCheckForMalwareOfUploads("*");
+  SetStatusCallbackResponse(SimpleDeepScanningClientResponseForTesting(
+      dlp_success(), malware_success()));
 
   // Always set this policy so the UI is shown.
   SetWaitPolicy(DELAY_UPLOADS);
@@ -446,8 +425,8 @@ IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsBehaviorBrowserTest, Test) {
   SetQuitClosure(run_loop.QuitClosure());
 
   DeepScanningDialogDelegate::Data data;
-  data.do_dlp_scan = dlp_enabled();
-  data.do_malware_scan = malware_enabled();
+  data.do_dlp_scan = true;
+  data.do_malware_scan = true;
   CreateFilesForTest({"foo.doc"}, {"content"}, &data);
   ASSERT_TRUE(DeepScanningDialogDelegate::IsEnabled(
       browser()->profile(), GURL(kTestUrl), &data,
@@ -483,18 +462,16 @@ IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsBehaviorBrowserTest, Test) {
 //               more than its minimum duration (GetMinimumPendingDialogTime <
 //               kNormalDelay).
 INSTANTIATE_TEST_SUITE_P(
-    DeepScanningDialogViewsBehaviorBrowserTest,
+    ,
     DeepScanningDialogViewsBehaviorBrowserTest,
     testing::Combine(
-        /*scan_type*/ testing::Values(ScanType::ONLY_DLP,
-                                      ScanType::ONLY_MALWARE,
-                                      ScanType::DLP_AND_MALWARE),
+        /*use_legacy_policies*/ testing::Bool(),
         /*dlp_success*/ testing::Bool(),
         /*malware_success*/ testing::Bool(),
         /*response_delay*/
         testing::Values(kNoDelay, kSmallDelay, kNormalDelay)));
 
-IN_PROC_BROWSER_TEST_F(DeepScanningDialogViewsCancelPendingScanBrowserTest,
+IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsCancelPendingScanBrowserTest,
                        Test) {
   base::ScopedAllowBlockingForTesting allow_blocking;
 
@@ -542,6 +519,10 @@ IN_PROC_BROWSER_TEST_F(DeepScanningDialogViewsCancelPendingScanBrowserTest,
   ValidateMetrics();
 }
 
+INSTANTIATE_TEST_SUITE_P(,
+                         DeepScanningDialogViewsCancelPendingScanBrowserTest,
+                         /*use_legacy_policies=*/testing::Bool());
+
 IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsWarningBrowserTest, Test) {
   base::ScopedAllowBlockingForTesting allow_blocking;
 
@@ -596,10 +577,12 @@ IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsWarningBrowserTest, Test) {
   EXPECT_TRUE(called);
 }
 
-INSTANTIATE_TEST_SUITE_P(
-    DeepScanningDialogViewsWarningBrowserTest,
-    DeepScanningDialogViewsWarningBrowserTest,
-    testing::Combine(testing::Values(kNoDelay, kSmallDelay), testing::Bool()));
+INSTANTIATE_TEST_SUITE_P(,
+                         DeepScanningDialogViewsWarningBrowserTest,
+                         testing::Combine(
+                             /*delay=*/testing::Values(kNoDelay, kSmallDelay),
+                             /*user_bypasses_warning=*/testing::Bool(),
+                             /*use_legacy_policies=*/testing::Bool()));
 
 IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsAppearanceBrowserTest, Test) {
   base::ScopedAllowBlockingForTesting allow_blocking;
@@ -651,7 +634,7 @@ IN_PROC_BROWSER_TEST_P(DeepScanningDialogViewsAppearanceBrowserTest, Test) {
   EXPECT_TRUE(called);
 }
 
-INSTANTIATE_TEST_SUITE_P(DeepScanningDialogViewsAppearanceBrowserTest,
+INSTANTIATE_TEST_SUITE_P(,
                          DeepScanningDialogViewsAppearanceBrowserTest,
                          testing::Combine(
                              /*file_scan=*/testing::Bool(),
@@ -659,6 +642,7 @@ INSTANTIATE_TEST_SUITE_P(DeepScanningDialogViewsAppearanceBrowserTest,
                              /*access_point=*/
                              testing::Values(DeepScanAccessPoint::UPLOAD,
                                              DeepScanAccessPoint::DRAG_AND_DROP,
-                                             DeepScanAccessPoint::PASTE)));
+                                             DeepScanAccessPoint::PASTE),
+                             /*use_legacy_policies=*/testing::Bool()));
 
 }  // namespace safe_browsing

chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_test_utils.cc

@@ -31,6 +31,8 @@ base::Value MakeListValue(const std::vector<std::string>& elements) {
 base::Value DefaultConnectorSettings() {
   base::Value settings(base::Value::Type::DICTIONARY);
 
+  settings.SetKey(enterprise_connectors::kKeyServiceProvider,
+                  base::Value("google"));
   settings.SetKey(enterprise_connectors::kKeyEnable,
                   base::Value(base::Value::Type::LIST));
   settings.SetKey(enterprise_connectors::kKeyDisable,
@@ -56,14 +58,12 @@ void AddConnectorUrlPattern(enterprise_connectors::AnalysisConnector connector,
 
   ListPrefUpdate settings_list(g_browser_process->local_state(),
                                ConnectorPref(connector));
-  base::Value* settings = nullptr;
-  DCHECK(settings_list->Get(0, &settings));
-  DCHECK(settings);
-  DCHECK(settings->is_dict());
+  base::Value& settings = settings_list->GetList()[0];
+  DCHECK(settings.is_dict());
 
   base::Value* list =
-      settings->FindListPath(enable ? enterprise_connectors::kKeyEnable
-                                    : enterprise_connectors::kKeyDisable);
+      settings.FindListKey(enable ? enterprise_connectors::kKeyEnable
+                                  : enterprise_connectors::kKeyDisable);
   DCHECK(list);
 
   base::Value list_element(base::Value::Type::DICTIONARY);
@@ -73,17 +73,51 @@ void AddConnectorUrlPattern(enterprise_connectors::AnalysisConnector connector,
   list->Append(std::move(list_element));
 }
 
+void ClearConnectorUrlPattern(
+    enterprise_connectors::AnalysisConnector connector,
+    bool enable,
+    base::Value tags) {
+  ListPrefUpdate settings_list(g_browser_process->local_state(),
+                               ConnectorPref(connector));
+  DCHECK(settings_list.Get());
+  if (settings_list->empty())
+    return;
+
+  base::Value& settings = settings_list->GetList()[0];
+  DCHECK(settings.is_dict());
+
+  base::Value* list =
+      settings.FindListKey(enable ? enterprise_connectors::kKeyEnable
+                                  : enterprise_connectors::kKeyDisable);
+  if (!list)
+    return;
+
+  DCHECK(list->is_list());
+  for (const base::Value& pattern : list->GetList()) {
+    DCHECK(pattern.is_dict());
+
+    const base::Value* pattern_tags =
+        pattern.FindKey(enterprise_connectors::kKeyTags);
+    if (!pattern_tags)
+      continue;
+
+    DCHECK(pattern_tags->is_list());
+    if (*pattern_tags == tags) {
+      list->EraseListValue(pattern);
+    }
+  }
+}
+
+template <typename T>
 void SetConnectorField(enterprise_connectors::AnalysisConnector connector,
                        const char* key,
-                       bool value) {
+                       T value) {
   InitConnectorPrefIfEmpty(connector);
   ListPrefUpdate settings_list(g_browser_process->local_state(),
                                ConnectorPref(connector));
-  base::Value* settings = nullptr;
-  DCHECK(settings_list->Get(0, &settings));
-  DCHECK(settings);
-  DCHECK(settings->is_dict());
-  settings->SetKey(key, base::Value(std::move(value)));
+  base::Value& settings = settings_list->GetList()[0];
+  DCHECK(settings.is_dict());
+  settings.SetKey(key, base::Value(std::move(value)));
 }
 
 }  // namespace
@@ -353,7 +387,6 @@ void SetDlpPolicyForConnectors(CheckContentComplianceValues state) {
   // wildcard pattern should also be included in the disable list if the policy
   // is disabled for downloads since no scan can occur with the legacy policy
   // when it is disabled.
-
   bool enable_uploads =
       state == CHECK_UPLOADS || state == CHECK_UPLOADS_AND_DOWNLOADS;
 
@@ -405,10 +438,11 @@ void SetMalwarePolicyForConnectors(SendFilesForMalwareCheckValues state) {
 
 void SetDelayDeliveryUntilVerdictPolicyForConnectors(
     DelayDeliveryUntilVerdictValues state) {
-  bool delay_uploads =
-      state == DELAY_UPLOADS || state == DELAY_UPLOADS_AND_DOWNLOADS;
-  bool delay_downloads =
-      state == DELAY_DOWNLOADS || state == DELAY_UPLOADS_AND_DOWNLOADS;
+  int delay_uploads =
+      (state == DELAY_UPLOADS || state == DELAY_UPLOADS_AND_DOWNLOADS) ? 1 : 0;
+  int delay_downloads =
+      (state == DELAY_DOWNLOADS || state == DELAY_UPLOADS_AND_DOWNLOADS) ? 1
+                                                                         : 0;
   SetConnectorField(enterprise_connectors::AnalysisConnector::BULK_DATA_ENTRY,
                     enterprise_connectors::kKeyBlockUntilVerdict,
                     delay_uploads);
@@ -428,10 +462,10 @@ void SetAllowPasswordProtectedFilesPolicyForConnectors(
       state == ALLOW_DOWNLOADS || state == ALLOW_UPLOADS_AND_DOWNLOADS;
   SetConnectorField(enterprise_connectors::AnalysisConnector::FILE_ATTACHED,
                     enterprise_connectors::kKeyBlockPasswordProtected,
-                    allow_uploads);
+                    !allow_uploads);
   SetConnectorField(enterprise_connectors::AnalysisConnector::FILE_DOWNLOADED,
                     enterprise_connectors::kKeyBlockPasswordProtected,
-                    allow_downloads);
+                    !allow_downloads);
 }
 
 void SetBlockUnsupportedFileTypesPolicyForConnectors(
@@ -497,4 +531,18 @@ void AddUrlsToNotCheckForMalwareOfDownloadsForConnectors(
       MakeListValue(urls), MakeListValue({"malware"}));
 }
 
+void ClearUrlsToCheckComplianceOfDownloadsForConnectors() {
+  ClearConnectorUrlPattern(
+      enterprise_connectors::AnalysisConnector::FILE_DOWNLOADED, true,
+      MakeListValue({"dlp"}));
+}
+
+void ClearUrlsToCheckForMalwareOfUploadsForConnectors() {
+  for (auto connector :
+       {enterprise_connectors::AnalysisConnector::FILE_ATTACHED,
+        enterprise_connectors::AnalysisConnector::BULK_DATA_ENTRY}) {
+    ClearConnectorUrlPattern(connector, true, MakeListValue({"malware"}));
+  }
+}
+
 }  // namespace safe_browsing

chrome/browser/safe_browsing/cloud_content_scanning/deep_scanning_test_utils.h

@@ -126,6 +126,8 @@ void AddUrlsToCheckForMalwareOfUploadsForConnectors(
     const std::vector<std::string>& urls);
 void AddUrlsToNotCheckForMalwareOfDownloadsForConnectors(
     const std::vector<std::string>& urls);
+void ClearUrlsToCheckComplianceOfDownloadsForConnectors();
+void ClearUrlsToCheckForMalwareOfUploadsForConnectors();
 
 }  // namespace safe_browsing