Added tests for new crowd deny preload list logic

As a follow-up to https://chromium-review.googlesource.com/c/chromium/src/+/2003320
Added a test for the new logic and fixed the test that was broken.

Bug: 1042611
Change-Id: I26f29d782879f28272fc5d544c0a783b7dc948de
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2010789
Commit-Queue: Balazs Engedy <engedy@chromium.org>
Reviewed-by: Balazs Engedy <engedy@chromium.org>
Reviewed-by: Andy Paicu <andypaicu@chromium.org>
Auto-Submit: Andy Paicu <andypaicu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#733921}

chrome/browser/permissions/crowd_deny_fake_safe_browsing_database_manager.cc

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/permissions/crowd_deny_fake_safe_browsing_database_manager.h"
+
+#include "components/safe_browsing/core/db/database_manager.h"
+
+CrowdDenyFakeSafeBrowsingDatabaseManager::
+    CrowdDenyFakeSafeBrowsingDatabaseManager() = default;
+
+void CrowdDenyFakeSafeBrowsingDatabaseManager::SetSimulatedMetadataForUrl(
+    const GURL& url,
+    const safe_browsing::ThreatMetadata& metadata) {
+  url_to_simulated_threat_metadata_[url] = metadata;
+}
+
+void CrowdDenyFakeSafeBrowsingDatabaseManager::RemoveAllBlacklistedUrls() {
+  url_to_simulated_threat_metadata_.clear();
+}
+
+CrowdDenyFakeSafeBrowsingDatabaseManager::
+    ~CrowdDenyFakeSafeBrowsingDatabaseManager() {
+  EXPECT_THAT(pending_clients_, testing::IsEmpty());
+}
+
+bool CrowdDenyFakeSafeBrowsingDatabaseManager::CheckApiBlacklistUrl(
+    const GURL& url,
+    Client* client) {
+  if (simulate_synchronous_result_)
+    return true;
+
+  if (simulate_timeout_) {
+    EXPECT_THAT(pending_clients_, testing::Not(testing::Contains(client)));
+    pending_clients_.insert(client);
+  } else {
+    auto result = GetSimulatedMetadataOrSafe(url);
+    client->OnCheckApiBlacklistUrlResult(url, std::move(result));
+  }
+  return false;
+}
+
+bool CrowdDenyFakeSafeBrowsingDatabaseManager::CancelApiCheck(Client* client) {
+  EXPECT_THAT(pending_clients_, testing::Contains(client));
+  pending_clients_.erase(client);
+  return true;
+}
+
+bool CrowdDenyFakeSafeBrowsingDatabaseManager::IsSupported() const {
+  return true;
+}
+
+bool CrowdDenyFakeSafeBrowsingDatabaseManager::ChecksAreAlwaysAsync() const {
+  return false;
+}
+safe_browsing::ThreatMetadata
+CrowdDenyFakeSafeBrowsingDatabaseManager::GetSimulatedMetadataOrSafe(
+    const GURL& url) {
+  auto it = url_to_simulated_threat_metadata_.find(url);
+  return it != url_to_simulated_threat_metadata_.end()
+             ? it->second
+             : safe_browsing::ThreatMetadata();
+}

chrome/browser/permissions/crowd_deny_fake_safe_browsing_database_manager.h

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_PERMISSIONS_CROWD_DENY_FAKE_SAFE_BROWSING_DATABASE_MANAGER_H_
+#define CHROME_BROWSER_PERMISSIONS_CROWD_DENY_FAKE_SAFE_BROWSING_DATABASE_MANAGER_H_
+
+#include <map>
+#include <set>
+
+#include "base/memory/weak_ptr.h"
+#include "components/safe_browsing/core/db/test_database_manager.h"
+#include "components/safe_browsing/core/db/util.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+class CrowdDenyFakeSafeBrowsingDatabaseManager
+    : public safe_browsing::TestSafeBrowsingDatabaseManager {
+ public:
+  CrowdDenyFakeSafeBrowsingDatabaseManager();
+
+  void SetSimulatedMetadataForUrl(
+      const GURL& url,
+      const safe_browsing::ThreatMetadata& metadata);
+
+  void RemoveAllBlacklistedUrls();
+
+  void set_simulate_timeout(bool simulate_timeout) {
+    simulate_timeout_ = simulate_timeout;
+  }
+
+  void set_simulate_synchronous_result(bool simulate_synchronous_result) {
+    simulate_synchronous_result_ = simulate_synchronous_result;
+  }
+
+ protected:
+  ~CrowdDenyFakeSafeBrowsingDatabaseManager() override;
+
+  // safe_browsing::TestSafeBrowsingDatabaseManager:
+  bool CheckApiBlacklistUrl(const GURL& url, Client* client) override;
+  bool CancelApiCheck(Client* client) override;
+  bool IsSupported() const override;
+  bool ChecksAreAlwaysAsync() const override;
+
+ private:
+  safe_browsing::ThreatMetadata GetSimulatedMetadataOrSafe(const GURL& url);
+
+  std::set<Client*> pending_clients_;
+  std::map<GURL, safe_browsing::ThreatMetadata>
+      url_to_simulated_threat_metadata_;
+  bool simulate_timeout_ = false;
+  bool simulate_synchronous_result_ = false;
+
+  base::WeakPtrFactory<CrowdDenyFakeSafeBrowsingDatabaseManager> weak_factory_{
+      this};
+
+  DISALLOW_COPY_AND_ASSIGN(CrowdDenyFakeSafeBrowsingDatabaseManager);
+};
+
+#endif  // CHROME_BROWSER_PERMISSIONS_CROWD_DENY_FAKE_SAFE_BROWSING_DATABASE_MANAGER_H_

chrome/browser/permissions/crowd_deny_safe_browsing_request_unittest.cc

@@ -10,8 +10,7 @@
 #include "base/task/post_task.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/mock_callback.h"
-#include "components/safe_browsing/core/db/database_manager.h"
-#include "components/safe_browsing/core/db/test_database_manager.h"
+#include "chrome/browser/permissions/crowd_deny_fake_safe_browsing_database_manager.h"
 #include "content/public/test/browser_task_environment.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -23,77 +22,6 @@ namespace {
 constexpr char kTestOriginFoo[] = "https://foo.com";
 constexpr char kTestOriginBar[] = "https://bar.com";
 
-class FakeSafeBrowsingDatabaseManager
-    : public safe_browsing::TestSafeBrowsingDatabaseManager {
- public:
-  FakeSafeBrowsingDatabaseManager() = default;
-
-  void SetSimulatedMetadataForUrl(
-      const GURL& url,
-      const safe_browsing::ThreatMetadata& metadata) {
-    url_to_simulated_threat_metadata_.emplace(url, metadata);
-  }
-
-  void RemoveAllBlacklistedUrls() { url_to_simulated_threat_metadata_.clear(); }
-
-  void set_simulate_timeout(bool simulate_timeout) {
-    simulate_timeout_ = simulate_timeout;
-  }
-
-  void set_simulate_synchronous_result(bool simulate_synchronous_result) {
-    simulate_synchronous_result_ = simulate_synchronous_result;
-  }
-
- protected:
-  ~FakeSafeBrowsingDatabaseManager() override {
-    EXPECT_THAT(pending_clients_, testing::IsEmpty());
-  }
-
-  safe_browsing::ThreatMetadata GetSimulatedMetadataOrSafe(const GURL& url) {
-    auto it = url_to_simulated_threat_metadata_.find(url);
-    return it != url_to_simulated_threat_metadata_.end()
-               ? it->second
-               : safe_browsing::ThreatMetadata();
-  }
-
-  // safe_browsing::TestSafeBrowsingDatabaseManager:
-  bool CheckApiBlacklistUrl(const GURL& url, Client* client) override {
-    if (simulate_synchronous_result_)
-      return true;
-
-    if (simulate_timeout_) {
-      EXPECT_THAT(pending_clients_, testing::Not(testing::Contains(client)));
-      pending_clients_.insert(client);
-    } else {
-      auto result = GetSimulatedMetadataOrSafe(url);
-      client->OnCheckApiBlacklistUrlResult(url, std::move(result));
-    }
-    return false;
-  }
-
-  bool CancelApiCheck(Client* client) override {
-    EXPECT_THAT(pending_clients_, testing::Contains(client));
-    pending_clients_.erase(client);
-    return true;
-  }
-
-  bool IsSupported() const override { return true; }
-  bool ChecksAreAlwaysAsync() const override { return false; }
-
- private:
-  void OnCheckUrlForSubresourceFilterComplete(Client* client, const GURL& url);
-
-  std::set<Client*> pending_clients_;
-  std::map<GURL, safe_browsing::ThreatMetadata>
-      url_to_simulated_threat_metadata_;
-  bool simulate_timeout_ = false;
-  bool simulate_synchronous_result_ = false;
-
-  base::WeakPtrFactory<FakeSafeBrowsingDatabaseManager> weak_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingDatabaseManager);
-};
-
 }  // namespace
 
 class CrowdDenySafeBrowsingRequestTest : public testing::Test {
@@ -102,7 +30,7 @@ class CrowdDenySafeBrowsingRequestTest : public testing::Test {
 
   CrowdDenySafeBrowsingRequestTest()
       : fake_database_manager_(
-            base::MakeRefCounted<FakeSafeBrowsingDatabaseManager>()) {}
+            base::MakeRefCounted<CrowdDenyFakeSafeBrowsingDatabaseManager>()) {}
   ~CrowdDenySafeBrowsingRequestTest() override = default;
 
  protected:
@@ -110,7 +38,7 @@ class CrowdDenySafeBrowsingRequestTest : public testing::Test {
     return &task_environment_;
   }
 
-  FakeSafeBrowsingDatabaseManager* fake_database_manager() {
+  CrowdDenyFakeSafeBrowsingDatabaseManager* fake_database_manager() {
     return fake_database_manager_.get();
   }
 
@@ -136,7 +64,8 @@ class CrowdDenySafeBrowsingRequestTest : public testing::Test {
   content::BrowserTaskEnvironment task_environment_{
       base::test::TaskEnvironment::TimeSource::MOCK_TIME};
 
-  scoped_refptr<FakeSafeBrowsingDatabaseManager> fake_database_manager_;
+  scoped_refptr<CrowdDenyFakeSafeBrowsingDatabaseManager>
+      fake_database_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(CrowdDenySafeBrowsingRequestTest);
 };

chrome/browser/permissions/permission_request_manager_unittest.cc

@@ -17,6 +17,7 @@
 #include "build/build_config.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/permissions/adaptive_quiet_notification_permission_ui_enabler.h"
+#include "chrome/browser/permissions/crowd_deny_fake_safe_browsing_database_manager.h"
 #include "chrome/browser/permissions/crowd_deny_preload_data.h"
 #include "chrome/browser/permissions/mock_permission_request.h"
 #include "chrome/browser/permissions/notification_permission_ui_selector.h"
@@ -25,14 +26,17 @@
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/quiet_notification_permission_ui_config.h"
 #include "chrome/browser/permissions/quiet_notification_permission_ui_state.h"
+#include "chrome/browser/safe_browsing/test_safe_browsing_service.h"
 #include "chrome/browser/ui/permission_bubble/mock_permission_prompt_factory.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
+#include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "components/safe_browsing/core/db/test_database_manager.h"
 #include "components/user_manager/scoped_user_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -45,6 +49,9 @@ const double kTestEngagementScore = 29;
 
 class PermissionRequestManagerTest : public ChromeRenderViewHostTestHarness {
  public:
+  using SiteReputation =
+      CrowdDenyPreloadData::SiteReputation::NotificationUserExperienceQuality;
+
   PermissionRequestManagerTest()
       : ChromeRenderViewHostTestHarness(),
         request1_("test1",
@@ -85,10 +92,19 @@ class PermissionRequestManagerTest : public ChromeRenderViewHostTestHarness {
     PermissionRequestManager::CreateForWebContents(web_contents());
     manager_ = PermissionRequestManager::FromWebContents(web_contents());
     prompt_factory_.reset(new MockPermissionPromptFactory(manager_));
+
+    db_manager_ =
+        base::MakeRefCounted<CrowdDenyFakeSafeBrowsingDatabaseManager>();
+    sb_factory_ =
+        std::make_unique<safe_browsing::TestSafeBrowsingServiceFactory>();
+    sb_factory_->SetTestDatabaseManager(db_manager_.get());
+    TestingBrowserProcess::GetGlobal()->SetSafeBrowsingService(
+        sb_factory_->CreateSafeBrowsingService());
   }
 
   void TearDown() override {
     prompt_factory_.reset();
+    TestingBrowserProcess::GetGlobal()->SetSafeBrowsingService(nullptr);
     ChromeRenderViewHostTestHarness::TearDown();
   }
 
@@ -131,6 +147,20 @@ class PermissionRequestManagerTest : public ChromeRenderViewHostTestHarness {
     manager_->NavigationEntryCommitted(details);
   }
 
+  void SetUpPreloadDataForUrl(const GURL& url, SiteReputation reputation) {
+    CrowdDenyPreloadData::GetInstance()
+        ->set_origin_notification_user_experience_for_testing(
+            url::Origin::Create(url), reputation);
+  }
+
+  void SetUpSafeBrowsingMetadataForUrl(const GURL& url,
+                                       bool unsolicited_notifications) {
+    safe_browsing::ThreatMetadata test_metadata;
+    if (unsolicited_notifications)
+      test_metadata.api_permissions.emplace("NOTIFICATIONS");
+    db_manager_->SetSimulatedMetadataForUrl(url, test_metadata);
+  }
+
 #if defined(OS_CHROMEOS)
   std::unique_ptr<MockPermissionRequest> MakeRequestInWebKioskMode(
       const GURL& url,
@@ -170,6 +200,8 @@ class PermissionRequestManagerTest : public ChromeRenderViewHostTestHarness {
   MockPermissionRequest iframe_request_mic_other_domain_;
   PermissionRequestManager* manager_;
   std::unique_ptr<MockPermissionPromptFactory> prompt_factory_;
+  scoped_refptr<CrowdDenyFakeSafeBrowsingDatabaseManager> db_manager_;
+  std::unique_ptr<safe_browsing::TestSafeBrowsingServiceFactory> sb_factory_;
 };
 
 TEST_F(PermissionRequestManagerTest, SingleRequest) {
@@ -969,8 +1001,7 @@ TEST_F(PermissionRequestManagerTest, TestWebKioskModeDifferentOrigin) {
 }
 #endif  // defined(OS_CHROMEOS)
 
-// TODO(andypaicu): re-enable ASAP. crbug.com/1042611
-TEST_F(PermissionRequestManagerTest, DISABLED_TestCrowdDenyHoldbackChance) {
+TEST_F(PermissionRequestManagerTest, TestCrowdDenyHoldbackChance) {
   const struct {
     std::string holdback_chance;
     bool enabled_in_prefs;
@@ -987,10 +1018,10 @@ TEST_F(PermissionRequestManagerTest, DISABLED_TestCrowdDenyHoldbackChance) {
   };
 
   GURL url("https://spammy.com");
-  CrowdDenyPreloadData::GetInstance()
-      ->set_origin_notification_user_experience_for_testing(
-          url::Origin::Create(url),
-          CrowdDenyPreloadData::SiteReputation::UNSOLICITED_PROMPTS);
+
+  SetUpPreloadDataForUrl(
+      url, CrowdDenyPreloadData::SiteReputation::UNSOLICITED_PROMPTS);
+  SetUpSafeBrowsingMetadataForUrl(url, true);
 
   for (const auto& test : kTestCases) {
     base::HistogramTester histograms;
@@ -1022,3 +1053,41 @@ TEST_F(PermissionRequestManagerTest, DISABLED_TestCrowdDenyHoldbackChance) {
         1);
   }
 }
+
+TEST_F(PermissionRequestManagerTest, PreloadDataNeedsSafeBrowsingConfirmation) {
+  const struct {
+    SiteReputation preload_data_reputation;
+    bool safe_browsing_unsolicited_notifications;
+    bool expect_quiet_ui;
+  } kTestCases[] = {
+      {CrowdDenyPreloadData::SiteReputation::UNSOLICITED_PROMPTS, true, true},
+      {CrowdDenyPreloadData::SiteReputation::UNSOLICITED_PROMPTS, false, false},
+      {CrowdDenyPreloadData::SiteReputation::ACCEPTABLE, true, false},
+      {CrowdDenyPreloadData::SiteReputation::UNKNOWN, true, false},
+      {CrowdDenyPreloadData::SiteReputation::UNKNOWN, false, false},
+  };
+
+  const GURL url("https://spammy.com");
+
+  base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndEnableFeatureWithParameters(
+      features::kQuietNotificationPrompts,
+      {{QuietNotificationPermissionUiConfig::kEnableAdaptiveActivation, "true"},
+       {QuietNotificationPermissionUiConfig::kEnableCrowdDenyTriggering,
+        "true"},
+       {QuietNotificationPermissionUiConfig::kCrowdDenyHoldBackChance, "0"}});
+
+  for (const auto& test : kTestCases) {
+    SetUpPreloadDataForUrl(url, test.preload_data_reputation);
+    SetUpSafeBrowsingMetadataForUrl(
+        url, test.safe_browsing_unsolicited_notifications);
+
+    MockPermissionRequest request(
+        "request", PermissionRequestType::PERMISSION_NOTIFICATIONS, url);
+
+    manager_->AddRequest(&request);
+    WaitForBubbleToBeShown();
+    EXPECT_EQ(test.expect_quiet_ui, manager_->ShouldCurrentRequestUseQuietUI());
+    Closing();
+  }
+}

chrome/test/BUILD.gn

@@ -98,6 +98,8 @@ static_library("test_support") {
   sources = [
     "../browser/autofill/automated_tests/cache_replayer.cc",
     "../browser/autofill/automated_tests/cache_replayer.h",
+    "../browser/permissions/crowd_deny_fake_safe_browsing_database_manager.cc",
+    "../browser/permissions/crowd_deny_fake_safe_browsing_database_manager.h",
     "base/chrome_render_view_host_test_harness.cc",
     "base/chrome_render_view_host_test_harness.h",
     "base/chrome_test_launcher.cc",