Refactor ContextualNotificationPermissionUiSelector.

This CL introduces no behavior changes, it just moves from a model with:

  (UiToUse + QuietUiReason)

to:

  Decision = (QuietUiReason + WarningReason),

where either being base::nullopt indicates that the normal UI should be
used, or no warning should be printed, respectively.

Bug: 1087005, 1081233
Change-Id: I90563d2fc245f2f25a132566f394d74dd22c2f70
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2218309
Commit-Queue: Balazs Engedy <engedy@chromium.org>
Reviewed-by: Balazs Engedy <engedy@chromium.org>
Reviewed-by: Evan Stade <estade@chromium.org>
Reviewed-by: Andy Paicu <andypaicu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#772654}

chrome/browser/permissions/contextual_notification_permission_ui_selector.cc

@@ -28,9 +28,9 @@
 
 namespace {
 
-using UiToUse = ContextualNotificationPermissionUiSelector::UiToUse;
 using QuietUiReason = ContextualNotificationPermissionUiSelector::QuietUiReason;
-using UiToUseWithReason = std::pair<UiToUse, base::Optional<QuietUiReason>>;
+using WarningReason = ContextualNotificationPermissionUiSelector::WarningReason;
+using Decision = ContextualNotificationPermissionUiSelector::Decision;
 
 // Records a histogram sample for NotificationUserExperienceQuality.
 void RecordNotificationUserExperienceQuality(
@@ -53,8 +53,9 @@ void RecordWarningOnlyState(bool value) {
 
 // Attempts to decide which UI to use based on preloaded site reputation data,
 // or returns base::nullopt if not possible. |site_reputation| can be nullptr.
-base::Optional<UiToUseWithReason> GetUiToUseBasedOnSiteReputation(
+base::Optional<Decision> GetDecisionBasedOnSiteReputation(
     const CrowdDenyPreloadData::SiteReputation* site_reputation) {
+  using Config = QuietNotificationPermissionUiConfig;
   if (!site_reputation) {
     RecordNotificationUserExperienceQuality(
         CrowdDenyPreloadData::SiteReputation::UNKNOWN);
@@ -66,27 +67,29 @@ base::Optional<UiToUseWithReason> GetUiToUseBasedOnSiteReputation(
   RecordWarningOnlyState(site_reputation->warning_only());
 
   switch (site_reputation->notification_ux_quality()) {
-    case CrowdDenyPreloadData::SiteReputation::ACCEPTABLE:
-      return std::make_pair(UiToUse::kNormalUi, base::nullopt);
-    case CrowdDenyPreloadData::SiteReputation::UNSOLICITED_PROMPTS:
-      if (!QuietNotificationPermissionUiConfig::IsCrowdDenyTriggeringEnabled())
-        return base::nullopt;
+    case CrowdDenyPreloadData::SiteReputation::ACCEPTABLE: {
+      return Decision::UseNormalUiAndShowNoWarning();
+    }
+    case CrowdDenyPreloadData::SiteReputation::UNSOLICITED_PROMPTS: {
       if (site_reputation->warning_only())
-        return std::make_pair(UiToUse::kNormalUi, base::nullopt);
-      return std::make_pair(UiToUse::kQuietUi,
-                            QuietUiReason::kTriggeredByCrowdDeny);
-    case CrowdDenyPreloadData::SiteReputation::ABUSIVE_PROMPTS:
-      if (!QuietNotificationPermissionUiConfig::
-              IsAbusiveRequestBlockingEnabled()) {
+        return Decision::UseNormalUiAndShowNoWarning();
+      if (!Config::IsCrowdDenyTriggeringEnabled())
         return base::nullopt;
+      return Decision(QuietUiReason::kTriggeredByCrowdDeny,
+                      Decision::ShowNoWarning());
     }
+    case CrowdDenyPreloadData::SiteReputation::ABUSIVE_PROMPTS: {
       if (site_reputation->warning_only())
-        return std::make_pair(UiToUse::kNormalUi, base::nullopt);
-      return std::make_pair(UiToUse::kQuietUi,
-                            QuietUiReason::kTriggeredDueToAbusiveRequests);
-    case CrowdDenyPreloadData::SiteReputation::UNKNOWN:
+        return Decision::UseNormalUiAndShowNoWarning();
+      if (!Config::IsAbusiveRequestBlockingEnabled())
+        return base::nullopt;
+      return Decision(QuietUiReason::kTriggeredDueToAbusiveRequests,
+                      Decision::ShowNoWarning());
+    }
+    case CrowdDenyPreloadData::SiteReputation::UNKNOWN: {
       return base::nullopt;
     }
+  }
 
   NOTREACHED();
   return base::nullopt;
@@ -125,7 +128,7 @@ void ContextualNotificationPermissionUiSelector::SelectUiToUse(
   DCHECK(callback_);
 
   if (!base::FeatureList::IsEnabled(features::kQuietNotificationPrompts)) {
-    Notify(UiToUse::kNormalUi, base::nullopt);
+    Notify(Decision::UseNormalUiAndShowNoWarning());
     return;
   }
 
@@ -146,15 +149,16 @@ ContextualNotificationPermissionUiSelector::
 
 void ContextualNotificationPermissionUiSelector::EvaluatePerSiteTriggers(
     const url::Origin& origin) {
-  auto ui_to_use_with_reason = GetUiToUseBasedOnSiteReputation(
+  base::Optional<Decision> decision = GetDecisionBasedOnSiteReputation(
       CrowdDenyPreloadData::GetInstance()->GetReputationDataForSite(origin));
-  if (!ui_to_use_with_reason ||
-      ui_to_use_with_reason->first == UiToUse::kNormalUi) {
-    OnPerSiteTriggersEvaluated(UiToUse::kNormalUi, base::nullopt);
+
+  // If the PreloadData suggests this is an unacceptable site, ping Safe
+  // Browsing to verify; but do not ping if it is not warranted.
+  if (!decision || (!decision->quiet_ui_reason && !decision->warning_reason)) {
+    OnPerSiteTriggersEvaluated(Decision::UseNormalUiAndShowNoWarning());
     return;
   }
 
-  // PreloadData suggests an unacceptable site, ping Safe Browsing to verify.
   DCHECK(!safe_browsing_request_);
   DCHECK(g_browser_process->safe_browsing_service());
 
@@ -165,11 +169,11 @@ void ContextualNotificationPermissionUiSelector::EvaluatePerSiteTriggers(
       base::DefaultClock::GetInstance(), origin,
       base::BindOnce(&ContextualNotificationPermissionUiSelector::
                          OnSafeBrowsingVerdictReceived,
-                     base::Unretained(this), *ui_to_use_with_reason->second));
+                     base::Unretained(this), *decision));
 }
 
 void ContextualNotificationPermissionUiSelector::OnSafeBrowsingVerdictReceived(
-    QuietUiReason candidate_quiet_ui_reason,
+    Decision candidate_decision,
     CrowdDenySafeBrowsingRequest::Verdict verdict) {
   DCHECK(safe_browsing_request_);
   DCHECK(callback_);
@@ -178,39 +182,34 @@ void ContextualNotificationPermissionUiSelector::OnSafeBrowsingVerdictReceived(
 
   switch (verdict) {
     case CrowdDenySafeBrowsingRequest::Verdict::kAcceptable:
-      OnPerSiteTriggersEvaluated(UiToUse::kNormalUi, base::nullopt);
+      OnPerSiteTriggersEvaluated(Decision::UseNormalUiAndShowNoWarning());
       break;
     case CrowdDenySafeBrowsingRequest::Verdict::kUnacceptable:
-      OnPerSiteTriggersEvaluated(UiToUse::kQuietUi, candidate_quiet_ui_reason);
+      if (candidate_decision.quiet_ui_reason &&
+          ShouldHoldBackQuietUI(*(candidate_decision.quiet_ui_reason))) {
+        candidate_decision.quiet_ui_reason.reset();
+      }
+      OnPerSiteTriggersEvaluated(candidate_decision);
       break;
   }
 }
 
 void ContextualNotificationPermissionUiSelector::OnPerSiteTriggersEvaluated(
-    UiToUse ui_to_use,
-    base::Optional<QuietUiReason> quiet_ui_reason) {
-  if (ui_to_use == UiToUse::kQuietUi &&
-      !ShouldHoldBackQuietUI(*quiet_ui_reason)) {
-    Notify(UiToUse::kQuietUi, quiet_ui_reason);
-    return;
-  }
-
+    Decision decision) {
   // Still show the quiet UI if it is enabled for all sites, even if per-site
   // conditions did not trigger showing the quiet UI on this origin.
-  if (profile_->GetPrefs()->GetBoolean(
+  if (!decision.quiet_ui_reason &&
+      profile_->GetPrefs()->GetBoolean(
           prefs::kEnableQuietNotificationPermissionUi)) {
-    Notify(UiToUse::kQuietUi, QuietUiReason::kEnabledInPrefs);
-    return;
+    decision.quiet_ui_reason = QuietUiReason::kEnabledInPrefs;
   }
 
-  Notify(UiToUse::kNormalUi, base::nullopt);
+  Notify(decision);
 }
 
 void ContextualNotificationPermissionUiSelector::Notify(
-    UiToUse ui_to_use,
-    base::Optional<QuietUiReason> quiet_ui_reason) {
-  DCHECK_EQ(ui_to_use == UiToUse::kQuietUi, !!quiet_ui_reason);
-  std::move(callback_).Run(ui_to_use, quiet_ui_reason);
+    const Decision& decision) {
+  std::move(callback_).Run(decision);
 }
 
 // static

chrome/browser/permissions/contextual_notification_permission_ui_selector.h

@@ -52,13 +52,10 @@ class ContextualNotificationPermissionUiSelector
 
   void EvaluatePerSiteTriggers(const url::Origin& origin);
   void OnSafeBrowsingVerdictReceived(
-      QuietUiReason candidate_quiet_ui_reason,
+      Decision candidate_decision,
       CrowdDenySafeBrowsingRequest::Verdict verdict);
-  void OnPerSiteTriggersEvaluated(
-      UiToUse ui_to_use,
-      base::Optional<QuietUiReason> quiet_ui_reason);
-
-  void Notify(UiToUse ui_to_use, base::Optional<QuietUiReason> quiet_ui_reason);
+  void OnPerSiteTriggersEvaluated(Decision decision);
+  void Notify(const Decision& decision);
 
   Profile* profile_;
 

chrome/browser/permissions/contextual_notification_permission_ui_selector_unittest.cc

@@ -33,6 +33,11 @@
 
 namespace {
 
+using QuietUiReason = ContextualNotificationPermissionUiSelector::QuietUiReason;
+using WarningReason = ContextualNotificationPermissionUiSelector::WarningReason;
+using Decision = ContextualNotificationPermissionUiSelector::Decision;
+using SiteReputation = chrome_browser_crowd_deny::SiteReputation;
+
 constexpr char kTestDomainUnknown[] = "unknown.com";
 constexpr char kTestDomainAcceptable[] = "acceptable.com";
 constexpr char kTestDomainSpammy[] = "spammy.com";
@@ -66,11 +71,6 @@ constexpr const char* kAllTestingOrigins[] = {
 
 class ContextualNotificationPermissionUiSelectorTest : public testing::Test {
  public:
-  using UiToUse = ContextualNotificationPermissionUiSelector::UiToUse;
-  using QuietUiReason =
-      ContextualNotificationPermissionUiSelector::QuietUiReason;
-  using SiteReputation = chrome_browser_crowd_deny::SiteReputation;
-
   ContextualNotificationPermissionUiSelectorTest()
       : testing_profile_(std::make_unique<TestingProfile>()),
         contextual_selector_(testing_profile_.get()) {}
@@ -175,17 +175,22 @@ class ContextualNotificationPermissionUiSelectorTest : public testing::Test {
 
   void QueryAndExpectDecisionForUrl(
       const GURL& origin,
-      UiToUse ui_to_use,
-      base::Optional<QuietUiReason> quiet_ui_reason) {
+      base::Optional<QuietUiReason> quiet_ui_reason,
+      base::Optional<WarningReason> warning_reason) {
     permissions::MockPermissionRequest mock_request(
         std::string(),
         permissions::PermissionRequestType::PERMISSION_NOTIFICATIONS, origin);
     base::MockCallback<
         ContextualNotificationPermissionUiSelector::DecisionMadeCallback>
         mock_callback;
-    EXPECT_CALL(mock_callback, Run(ui_to_use, quiet_ui_reason));
+    Decision actual_decison(base::nullopt, base::nullopt);
+    EXPECT_CALL(mock_callback, Run)
+        .WillRepeatedly(testing::SaveArg<0>(&actual_decison));
     contextual_selector_.SelectUiToUse(&mock_request, mock_callback.Get());
     task_environment_.RunUntilIdle();
+    testing::Mock::VerifyAndClearExpectations(&mock_callback);
+    EXPECT_EQ(quiet_ui_reason, actual_decison.quiet_ui_reason);
+    EXPECT_EQ(warning_reason, actual_decison.warning_reason);
   }
 
  private:
@@ -225,8 +230,8 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest,
     SCOPED_TRACE("Quiet UI disabled in prefs, Safe Browsing verdicts negative");
     for (const auto* origin_string : kAllTestingOrigins) {
       SCOPED_TRACE(origin_string);
-      QueryAndExpectDecisionForUrl(GURL(origin_string), UiToUse::kNormalUi,
-                                   base::nullopt);
+      QueryAndExpectDecisionForUrl(GURL(origin_string), Decision::UseNormalUi(),
+                                   Decision::ShowNoWarning());
     }
   }
 
@@ -237,8 +242,9 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest,
     SCOPED_TRACE("Quiet UI enabled in prefs, Safe Browsing verdicts negative");
     for (const auto* origin_string : kAllTestingOrigins) {
       SCOPED_TRACE(origin_string);
-      QueryAndExpectDecisionForUrl(GURL(origin_string), UiToUse::kQuietUi,
-                                   QuietUiReason::kEnabledInPrefs);
+      QueryAndExpectDecisionForUrl(GURL(origin_string),
+                                   QuietUiReason::kEnabledInPrefs,
+                                   Decision::ShowNoWarning());
     }
   }
 
@@ -248,27 +254,29 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest,
 
     const struct {
       const char* origin_string;
-      UiToUse expected_ui;
-      base::Optional<QuietUiReason> expected_ui_reason;
+      base::Optional<QuietUiReason> expected_ui_reason =
+          Decision::UseNormalUi();
+      base::Optional<WarningReason> expected_warning_reason =
+          Decision::ShowNoWarning();
     } kTestCases[] = {
-        {kTestOriginNoData, UiToUse::kNormalUi, base::nullopt},
-        {kTestOriginUnknown, UiToUse::kNormalUi, base::nullopt},
-        {kTestOriginAcceptable, UiToUse::kNormalUi, base::nullopt},
-        {kTestOriginSpammy, UiToUse::kQuietUi,
-         QuietUiReason::kTriggeredByCrowdDeny},
-        {kTestOriginSpammyWarn, UiToUse::kNormalUi, base::nullopt},
-        {kTestOriginAbusivePrompts, UiToUse::kQuietUi,
+        {kTestOriginNoData},
+        {kTestOriginUnknown},
+        {kTestOriginAcceptable},
+        {kTestOriginSpammy, QuietUiReason::kTriggeredByCrowdDeny},
+        {kTestOriginSpammyWarn},
+        {kTestOriginAbusivePrompts,
          QuietUiReason::kTriggeredDueToAbusiveRequests},
-        {kTestOriginSubDomainOfAbusivePrompts, UiToUse::kQuietUi,
+        {kTestOriginSubDomainOfAbusivePrompts,
          QuietUiReason::kTriggeredDueToAbusiveRequests},
-        {kTestOriginAbusivePromptsWarn, UiToUse::kNormalUi, base::nullopt},
+        {kTestOriginAbusivePromptsWarn},
     };
 
     SCOPED_TRACE("Quiet UI disabled in prefs, Safe Browsing verdicts positive");
     for (const auto& test : kTestCases) {
       SCOPED_TRACE(test.origin_string);
-      QueryAndExpectDecisionForUrl(GURL(test.origin_string), test.expected_ui,
-                                   test.expected_ui_reason);
+      QueryAndExpectDecisionForUrl(GURL(test.origin_string),
+                                   test.expected_ui_reason,
+                                   test.expected_warning_reason);
     }
   }
 
@@ -278,30 +286,29 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest,
 
     const struct {
       const char* origin_string;
-      UiToUse expected_ui;
-      base::Optional<QuietUiReason> expected_ui_reason;
+      base::Optional<QuietUiReason> expected_ui_reason =
+          Decision::UseNormalUi();
+      base::Optional<WarningReason> expected_warning_reason =
+          Decision::ShowNoWarning();
     } kTestCases[] = {
-        {kTestOriginNoData, UiToUse::kQuietUi, QuietUiReason::kEnabledInPrefs},
-        {kTestOriginUnknown, UiToUse::kQuietUi, QuietUiReason::kEnabledInPrefs},
-        {kTestOriginAcceptable, UiToUse::kQuietUi,
-         QuietUiReason::kEnabledInPrefs},
-        {kTestOriginSpammy, UiToUse::kQuietUi,
-         QuietUiReason::kTriggeredByCrowdDeny},
-        {kTestOriginSpammyWarn, UiToUse::kQuietUi,
-         QuietUiReason::kEnabledInPrefs},
-        {kTestOriginAbusivePrompts, UiToUse::kQuietUi,
+        {kTestOriginNoData, QuietUiReason::kEnabledInPrefs},
+        {kTestOriginUnknown, QuietUiReason::kEnabledInPrefs},
+        {kTestOriginAcceptable, QuietUiReason::kEnabledInPrefs},
+        {kTestOriginSpammy, QuietUiReason::kTriggeredByCrowdDeny},
+        {kTestOriginSpammyWarn, QuietUiReason::kEnabledInPrefs},
+        {kTestOriginAbusivePrompts,
          QuietUiReason::kTriggeredDueToAbusiveRequests},
-        {kTestOriginSubDomainOfAbusivePrompts, UiToUse::kQuietUi,
+        {kTestOriginSubDomainOfAbusivePrompts,
          QuietUiReason::kTriggeredDueToAbusiveRequests},
-        {kTestOriginAbusivePromptsWarn, UiToUse::kQuietUi,
-         QuietUiReason::kEnabledInPrefs},
+        {kTestOriginAbusivePromptsWarn, QuietUiReason::kEnabledInPrefs},
     };
 
     SCOPED_TRACE("Quiet UI enabled in prefs, Safe Browsing verdicts positive");
     for (const auto& test : kTestCases) {
       SCOPED_TRACE(test.origin_string);
-      QueryAndExpectDecisionForUrl(GURL(test.origin_string), test.expected_ui,
-                                   test.expected_ui_reason);
+      QueryAndExpectDecisionForUrl(GURL(test.origin_string),
+                                   test.expected_ui_reason,
+                                   test.expected_warning_reason);
     }
   }
 }
@@ -316,8 +323,8 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest, FeatureDisabled) {
 
   for (const auto* origin_string : kAllTestingOrigins) {
     SCOPED_TRACE(origin_string);
-    QueryAndExpectDecisionForUrl(GURL(origin_string), UiToUse::kNormalUi,
-                                 base::nullopt);
+    QueryAndExpectDecisionForUrl(GURL(origin_string), Decision::UseNormalUi(),
+                                 Decision::ShowNoWarning());
   }
 }
 
@@ -335,8 +342,9 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest, AllTriggersDisabled) {
 
   for (const auto* origin_string : kAllTestingOrigins) {
     SCOPED_TRACE(origin_string);
-    QueryAndExpectDecisionForUrl(GURL(origin_string), UiToUse::kQuietUi,
-                                 QuietUiReason::kEnabledInPrefs);
+    QueryAndExpectDecisionForUrl(GURL(origin_string),
+                                 QuietUiReason::kEnabledInPrefs,
+                                 Decision::ShowNoWarning());
   }
 }
 
@@ -355,21 +363,22 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest, OnlyCrowdDenyEnabled) {
 
   const struct {
     const char* origin_string;
-    UiToUse expected_ui;
-    base::Optional<QuietUiReason> expected_ui_reason;
+    base::Optional<QuietUiReason> expected_ui_reason = Decision::UseNormalUi();
+    base::Optional<WarningReason> expected_warning_reason =
+        Decision::ShowNoWarning();
   } kTestCases[] = {
-      {kTestOriginSpammy, UiToUse::kQuietUi,
-       QuietUiReason::kTriggeredByCrowdDeny},
-      {kTestOriginSpammyWarn, UiToUse::kNormalUi, base::nullopt},
-      {kTestOriginAbusivePrompts, UiToUse::kNormalUi, base::nullopt},
-      {kTestOriginSubDomainOfAbusivePrompts, UiToUse::kNormalUi, base::nullopt},
-      {kTestOriginAbusivePromptsWarn, UiToUse::kNormalUi, base::nullopt},
+      {kTestOriginSpammy, QuietUiReason::kTriggeredByCrowdDeny},
+      {kTestOriginSpammyWarn},
+      {kTestOriginAbusivePrompts},
+      {kTestOriginSubDomainOfAbusivePrompts},
+      {kTestOriginAbusivePromptsWarn},
   };
 
   for (const auto& test : kTestCases) {
     SCOPED_TRACE(test.origin_string);
-    QueryAndExpectDecisionForUrl(GURL(test.origin_string), test.expected_ui,
-                                 test.expected_ui_reason);
+    QueryAndExpectDecisionForUrl(GURL(test.origin_string),
+                                 test.expected_ui_reason,
+                                 test.expected_warning_reason);
   }
 }
 
@@ -389,22 +398,24 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest,
 
   const struct {
     const char* origin_string;
-    UiToUse expected_ui;
-    base::Optional<QuietUiReason> expected_ui_reason;
+    base::Optional<QuietUiReason> expected_ui_reason = Decision::UseNormalUi();
+    base::Optional<WarningReason> expected_warning_reason =
+        Decision::ShowNoWarning();
   } kTestCases[] = {
-      {kTestOriginSpammy, UiToUse::kNormalUi, base::nullopt},
-      {kTestOriginSpammyWarn, UiToUse::kNormalUi, base::nullopt},
-      {kTestOriginAbusivePrompts, UiToUse::kQuietUi,
+      {kTestOriginSpammy},
+      {kTestOriginSpammyWarn},
+      {kTestOriginAbusivePrompts,
        QuietUiReason::kTriggeredDueToAbusiveRequests},
-      {kTestOriginSubDomainOfAbusivePrompts, UiToUse::kQuietUi,
+      {kTestOriginSubDomainOfAbusivePrompts,
        QuietUiReason::kTriggeredDueToAbusiveRequests},
-      {kTestOriginAbusivePromptsWarn, UiToUse::kNormalUi, base::nullopt},
+      {kTestOriginAbusivePromptsWarn},
   };
 
   for (const auto& test : kTestCases) {
     SCOPED_TRACE(test.origin_string);
-    QueryAndExpectDecisionForUrl(GURL(test.origin_string), test.expected_ui,
-                                 test.expected_ui_reason);
+    QueryAndExpectDecisionForUrl(GURL(test.origin_string),
+                                 test.expected_ui_reason,
+                                 test.expected_warning_reason);
   }
 }
 
@@ -413,17 +424,16 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest,
   const struct {
     std::string holdback_chance;
     bool enabled_in_prefs;
-    UiToUse expected_ui;
     base::Optional<QuietUiReason> expected_ui_reason;
     bool expected_histogram_bucket;
   } kTestCases[] = {
       // 100% chance to holdback, the UI used should be the normal UI.
-      {"1.0", false, UiToUse::kNormalUi, base::nullopt, true},
+      {"1.0", false, Decision::UseNormalUi(), true},
       // 0% chance to holdback, the UI used should be the quiet UI.
-      {"0.0", false, UiToUse::kQuietUi, QuietUiReason::kTriggeredByCrowdDeny},
+      {"0.0", false, QuietUiReason::kTriggeredByCrowdDeny},
       // 100% chance to holdback but the quiet UI is enabled by the user in
       // prefs, the UI used should be the quiet UI.
-      {"1.0", true, UiToUse::kQuietUi, QuietUiReason::kEnabledInPrefs, true},
+      {"1.0", true, QuietUiReason::kEnabledInPrefs, true},
   };
 
   LoadTestPreloadData();
@@ -439,19 +449,26 @@ TEST_F(ContextualNotificationPermissionUiSelectorTest,
         features::kQuietNotificationPrompts,
         {{Config::kEnableAdaptiveActivation, "true"},
          {Config::kEnableAbusiveRequestBlocking, "true"},
+         {Config::kEnableAbusiveRequestWarning, "true"},
          {Config::kEnableCrowdDenyTriggering, "true"},
          {Config::kCrowdDenyHoldBackChance, test.holdback_chance}});
 
     SetQuietUiEnabledInPrefs(test.enabled_in_prefs);
 
     base::HistogramTester histograms;
-    QueryAndExpectDecisionForUrl(GURL(kTestOriginSpammy), test.expected_ui,
-                                 test.expected_ui_reason);
+    QueryAndExpectDecisionForUrl(GURL(kTestOriginSpammy),
+                                 test.expected_ui_reason,
+                                 Decision::ShowNoWarning());
 
     // The hold-back should not apply to other per-site triggers.
     QueryAndExpectDecisionForUrl(GURL(kTestOriginAbusivePrompts),
-                                 UiToUse::kQuietUi,
-                                 QuietUiReason::kTriggeredDueToAbusiveRequests);
+                                 QuietUiReason::kTriggeredDueToAbusiveRequests,
+                                 Decision::ShowNoWarning());
+    QueryAndExpectDecisionForUrl(GURL(kTestOriginAbusivePromptsWarn),
+                                 test.enabled_in_prefs
+                                     ? QuietUiReason::kEnabledInPrefs
+                                     : Decision::UseNormalUi(),
+                                 Decision::ShowNoWarning());
 
     auto expected_bucket = static_cast<base::HistogramBase::Sample>(
         test.expected_histogram_bucket);

chrome/browser/ui/views/location_bar/content_setting_bubble_dialog_browsertest.cc

@@ -56,7 +56,8 @@ class TestQuietNotificationPermissionUiSelector
   // permissions::NotificationPermissionUiSelector:
   void SelectUiToUse(permissions::PermissionRequest* request,
                      DecisionMadeCallback callback) override {
-    std::move(callback).Run(UiToUse::kQuietUi, simulated_reason_for_quiet_ui_);
+    std::move(callback).Run(
+        Decision(simulated_reason_for_quiet_ui_, base::nullopt));
   }
 
  private:

components/permissions/BUILD.gn

@@ -12,6 +12,7 @@ source_set("permissions") {
     "contexts/window_placement_permission_context.h",
     "features.cc",
     "features.h",
+    "notification_permission_ui_selector.cc",
     "notification_permission_ui_selector.h",
     "permission_context_base.cc",
     "permission_context_base.h",

components/permissions/notification_permission_ui_selector.cc

+// Copyright 2020 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 "components/permissions/notification_permission_ui_selector.h"
+
+namespace permissions {
+
+NotificationPermissionUiSelector::Decision::Decision(
+    base::Optional<QuietUiReason> quiet_ui_reason,
+    base::Optional<WarningReason> warning_reason)
+    : quiet_ui_reason(quiet_ui_reason), warning_reason(warning_reason) {}
+NotificationPermissionUiSelector::Decision::~Decision() = default;
+
+NotificationPermissionUiSelector::Decision::Decision(const Decision&) = default;
+NotificationPermissionUiSelector::Decision&
+NotificationPermissionUiSelector::Decision::operator=(const Decision&) =
+    default;
+
+// static
+NotificationPermissionUiSelector::Decision
+NotificationPermissionUiSelector::Decision::UseNormalUiAndShowNoWarning() {
+  return Decision(UseNormalUi(), ShowNoWarning());
+}
+
+}  // namespace permissions

components/permissions/notification_permission_ui_selector.h

@@ -5,30 +5,58 @@
 #ifndef COMPONENTS_PERMISSIONS_NOTIFICATION_PERMISSION_UI_SELECTOR_H_
 #define COMPONENTS_PERMISSIONS_NOTIFICATION_PERMISSION_UI_SELECTOR_H_
 
+#include "base/callback_forward.h"
+#include "base/optional.h"
 #include "components/permissions/permission_request.h"
 
 namespace permissions {
 
 // The interface for implementations that decide if the quiet prompt UI should
-// be used to display a notification permission |request|.
+// be used to display a notification permission |request|, whether a warning
+// should be printed to the Dev Tools console, and the reasons for both.
 //
 // Implementations of interface are expected to have long-lived instances that
 // can support multiple requests, but only one at a time.
 class NotificationPermissionUiSelector {
  public:
-  enum class UiToUse {
-    kNormalUi,
-    kQuietUi,
-  };
-
   enum class QuietUiReason {
     kEnabledInPrefs,
     kTriggeredByCrowdDeny,
     kTriggeredDueToAbusiveRequests,
   };
 
-  using DecisionMadeCallback =
-      base::OnceCallback<void(UiToUse, base::Optional<QuietUiReason>)>;
+  enum class WarningReason {
+    kAbusiveRequests,
+  };
+
+  struct Decision {
+    Decision(base::Optional<QuietUiReason> quiet_ui_reason,
+             base::Optional<WarningReason> warning_reason);
+    ~Decision();
+
+    Decision(const Decision&);
+    Decision& operator=(const Decision&);
+
+    static constexpr base::Optional<QuietUiReason> UseNormalUi() {
+      return base::nullopt;
+    }
+
+    static constexpr base::Optional<WarningReason> ShowNoWarning() {
+      return base::nullopt;
+    }
+
+    static Decision UseNormalUiAndShowNoWarning();
+
+    // The reason for showing the quiet UI, or `base::nullopt` if the normal UI
+    // should be used.
+    base::Optional<QuietUiReason> quiet_ui_reason;
+
+    // The reason for printing a warning to the console, or `base::nullopt` if
+    // no warning should be printed.
+    base::Optional<WarningReason> warning_reason;
+  };
+
+  using DecisionMadeCallback = base::OnceCallback<void(const Decision&)>;
 
   virtual ~NotificationPermissionUiSelector() {}
 

components/permissions/permission_request_manager.cc

@@ -371,7 +371,8 @@ void PermissionRequestManager::DequeueRequestIfNeeded() {
             &PermissionRequestManager::OnSelectedUiToUseForNotifications,
             weak_factory_.GetWeakPtr()));
   } else {
-    current_request_ui_to_use_ = UiToUse::kNormalUi;
+    current_request_ui_to_use_ =
+        UiDecision(UiDecision::UseNormalUi(), UiDecision::ShowNoWarning());
     ScheduleShowBubble();
   }
 }
@@ -479,7 +480,6 @@ void PermissionRequestManager::FinalizeBubble(
 
   current_request_view_shown_to_user_ = false;
   current_request_ui_to_use_.reset();
-  current_request_quiet_ui_reason_.reset();
 
   if (view_)
     DeleteBubble();
@@ -579,12 +579,12 @@ bool PermissionRequestManager::ShouldCurrentRequestUseQuietUI() const {
   // ContentSettingImageModel might call into this method if the user switches
   // between tabs while the |notification_permission_ui_selector_| is pending.
   return current_request_ui_to_use_ &&
-         *current_request_ui_to_use_ == UiToUse::kQuietUi;
+         current_request_ui_to_use_->quiet_ui_reason;
 }
 
 PermissionRequestManager::QuietUiReason
 PermissionRequestManager::ReasonForUsingQuietUi() const {
-  return *current_request_quiet_ui_reason_;
+  return *(current_request_ui_to_use_->quiet_ui_reason);
 }
 
 bool PermissionRequestManager::IsRequestInProgress() const {
@@ -602,10 +602,8 @@ void PermissionRequestManager::NotifyBubbleRemoved() {
 }
 
 void PermissionRequestManager::OnSelectedUiToUseForNotifications(
-    UiToUse ui_to_use,
-    base::Optional<QuietUiReason> quiet_ui_reason) {
-  current_request_ui_to_use_ = ui_to_use;
-  current_request_quiet_ui_reason_ = quiet_ui_reason;
+    const UiDecision& decision) {
+  current_request_ui_to_use_ = decision;
   ScheduleShowBubble();
 }
 

components/permissions/permission_request_manager.h

@@ -54,8 +54,9 @@ class PermissionRequestManager
 
   enum AutoResponseType { NONE, ACCEPT_ALL, DENY_ALL, DISMISS };
 
-  using UiToUse = NotificationPermissionUiSelector::UiToUse;
+  using UiDecision = NotificationPermissionUiSelector::Decision;
   using QuietUiReason = NotificationPermissionUiSelector::QuietUiReason;
+  using WarningReason = NotificationPermissionUiSelector::WarningReason;
 
   ~PermissionRequestManager() override;
 
@@ -80,6 +81,7 @@ class PermissionRequestManager
   // directly by the user in notifications settings, or via automatic logic that
   // might trigger the current request to use the quiet UI.
   bool ShouldCurrentRequestUseQuietUI() const;
+
   // If |ShouldCurrentRequestUseQuietUI| return true, this will provide a reason
   // as to why the quiet UI needs to be used.
   QuietUiReason ReasonForUsingQuietUi() const;
@@ -180,9 +182,7 @@ class PermissionRequestManager
   void NotifyBubbleAdded();
   void NotifyBubbleRemoved();
 
-  void OnSelectedUiToUseForNotifications(
-      UiToUse ui_to_use,
-      base::Optional<QuietUiReason> quiet_ui_reason);
+  void OnSelectedUiToUseForNotifications(const UiDecision& decision);
 
   PermissionPromptDisposition DetermineCurrentRequestUIDispositionForUMA();
 
@@ -226,14 +226,9 @@ class PermissionRequestManager
   bool current_request_view_shown_to_user_ = false;
 
   // Whether to use the normal or quiet UI to display the current permission
-  // |requests_|, or nullopt if  we are still waiting on the result from the
-  // |notification_permission_ui_selector_|.
-  base::Optional<UiToUse> current_request_ui_to_use_;
-
-  // The reason for using the quiet UI to display the current permission
-  // |requests_|, or nullopt if we are still waiting for the response from the
-  // |notification_permission_ui_selector_| or we are using the normal UI.
-  base::Optional<QuietUiReason> current_request_quiet_ui_reason_;
+  // |requests_|, and whether to show warnings. This will be nullopt if we are
+  // still waiting on the result from |notification_permission_ui_selector_|.
+  base::Optional<UiDecision> current_request_ui_to_use_;
 
   // Whether the bubble is being destroyed by this class, rather than in
   // response to a UI event. In this case, callbacks from the bubble itself

components/permissions/permission_request_manager_unittest.cc

@@ -23,6 +23,10 @@
 
 namespace permissions {
 
+namespace {
+using QuietUiReason = NotificationPermissionUiSelector::QuietUiReason;
+}
+
 class PermissionRequestManagerTest : public content::RenderViewHostTestHarness {
  public:
   PermissionRequestManagerTest()
@@ -541,34 +545,34 @@ TEST_F(PermissionRequestManagerTest, UMAForTabSwitching) {
 class MockNotificationPermissionUiSelector
     : public NotificationPermissionUiSelector {
  public:
-  explicit MockNotificationPermissionUiSelector(UiToUse ui_to_use, bool async) {
-    ui_to_use_ = ui_to_use;
+  explicit MockNotificationPermissionUiSelector(
+      base::Optional<QuietUiReason> quiet_ui_reason,
+      bool async) {
+    quiet_ui_reason_ = quiet_ui_reason;
     async_ = async;
   }
 
   void SelectUiToUse(PermissionRequest* request,
                      DecisionMadeCallback callback) override {
-    base::Optional<QuietUiReason> reason;
-    if (ui_to_use_ == UiToUse::kQuietUi)
-      reason = QuietUiReason::kEnabledInPrefs;
+    Decision decision(quiet_ui_reason_, Decision::ShowNoWarning());
     if (async_) {
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::BindOnce(std::move(callback), ui_to_use_, reason));
+          FROM_HERE, base::BindOnce(std::move(callback), decision));
     } else {
-      std::move(callback).Run(ui_to_use_, reason);
+      std::move(callback).Run(decision);
     }
   }
 
   static void CreateForManager(PermissionRequestManager* manager,
-                               UiToUse ui_to_use,
+                               base::Optional<QuietUiReason> quiet_ui_reason,
                                bool async) {
     manager->set_notification_permission_ui_selector_for_testing(
-        std::make_unique<MockNotificationPermissionUiSelector>(ui_to_use,
+        std::make_unique<MockNotificationPermissionUiSelector>(quiet_ui_reason,
                                                                async));
   }
 
  private:
-  UiToUse ui_to_use_;
+  base::Optional<QuietUiReason> quiet_ui_reason_;
   bool async_;
 };
 
@@ -576,7 +580,8 @@ TEST_F(PermissionRequestManagerTest,
        UiSelectorNotUsedForPermissionsOtherThanNotification) {
   for (auto* request : {&request_mic_, &request_camera_, &request_ptz_}) {
     MockNotificationPermissionUiSelector::CreateForManager(
-        manager_, NotificationPermissionUiSelector::UiToUse::kQuietUi,
+        manager_,
+        NotificationPermissionUiSelector::QuietUiReason::kEnabledInPrefs,
         false /* async */);
 
     manager_->AddRequest(request);
@@ -593,20 +598,20 @@ TEST_F(PermissionRequestManagerTest,
 }
 
 TEST_F(PermissionRequestManagerTest, UiSelectorUsedForNotifications) {
-  using UiToUse = NotificationPermissionUiSelector::UiToUse;
   const struct {
-    NotificationPermissionUiSelector::UiToUse ui_to_use;
+    base::Optional<NotificationPermissionUiSelector::QuietUiReason>
+        quiet_ui_reason;
     bool async;
   } kTests[] = {
-      {UiToUse::kQuietUi, true},
-      {UiToUse::kNormalUi, true},
-      {UiToUse::kQuietUi, false},
-      {UiToUse::kNormalUi, false},
+      {QuietUiReason::kEnabledInPrefs, true},
+      {NotificationPermissionUiSelector::Decision::UseNormalUi(), true},
+      {QuietUiReason::kEnabledInPrefs, false},
+      {NotificationPermissionUiSelector::Decision::UseNormalUi(), false},
   };
 
   for (const auto& test : kTests) {
     MockNotificationPermissionUiSelector::CreateForManager(
-        manager_, test.ui_to_use, test.async);
+        manager_, test.quiet_ui_reason, test.async);
 
     MockPermissionRequest request(
         "foo", PermissionRequestType::PERMISSION_NOTIFICATIONS,
@@ -618,7 +623,7 @@ TEST_F(PermissionRequestManagerTest, UiSelectorUsedForNotifications) {
     EXPECT_TRUE(prompt_factory_->is_visible());
     EXPECT_TRUE(
         prompt_factory_->RequestTypeSeen(request.GetPermissionRequestType()));
-    EXPECT_EQ(test.ui_to_use == UiToUse::kQuietUi,
+    EXPECT_EQ(!!test.quiet_ui_reason,
               manager_->ShouldCurrentRequestUseQuietUI());
     Accept();
 
@@ -628,9 +633,9 @@ TEST_F(PermissionRequestManagerTest, UiSelectorUsedForNotifications) {
 
 TEST_F(PermissionRequestManagerTest,
        UiSelectionHappensSeparatelyForEachRequest) {
-  using UiToUse = NotificationPermissionUiSelector::UiToUse;
+  using QuietUiReason = NotificationPermissionUiSelector::QuietUiReason;
   MockNotificationPermissionUiSelector::CreateForManager(
-      manager_, UiToUse::kQuietUi, true);
+      manager_, QuietUiReason::kEnabledInPrefs, true);
   MockPermissionRequest request1(
       "request1", PermissionRequestType::PERMISSION_NOTIFICATIONS,
       PermissionRequestGestureType::GESTURE);
@@ -643,7 +648,8 @@ TEST_F(PermissionRequestManagerTest,
       "request2", PermissionRequestType::PERMISSION_NOTIFICATIONS,
       PermissionRequestGestureType::GESTURE);
   MockNotificationPermissionUiSelector::CreateForManager(
-      manager_, UiToUse::kNormalUi, true);
+      manager_, NotificationPermissionUiSelector::Decision::UseNormalUi(),
+      true);
   manager_->AddRequest(&request2);
   WaitForBubbleToBeShown();
   EXPECT_FALSE(manager_->ShouldCurrentRequestUseQuietUI());