WebUI Settings: Generated prefs for the notification content setting.

Added generated preference for the notification content setting
and quieter UI preference.

Bug: 1113642
Change-Id: Ifda4dffc809f5bdcf33ac06b22c8ca2ab54d15df
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2334953Reviewed-by: Martin Šrámek <msramek@chromium.org>
Reviewed-by: Varun Khaneja <vakh@chromium.org>
Reviewed-by: dpapad <dpapad@chromium.org>
Reviewed-by: Theodore Olsauskas-Warren <sauski@google.com>
Reviewed-by: Sean Harrison <harrisonsean@chromium.org>
Commit-Queue: Tymofii Chudakov <tchudakov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#806620}

chrome/browser/BUILD.gn

@@ -3152,6 +3152,8 @@ static_library("browser") {
       "component_updater/soda_ja_jp_component_installer.h",
       "content_settings/generated_cookie_prefs.cc",
       "content_settings/generated_cookie_prefs.h",
+      "content_settings/generated_notification_pref.cc",
+      "content_settings/generated_notification_pref.h",
       "custom_handlers/register_protocol_handler_permission_request.cc",
       "custom_handlers/register_protocol_handler_permission_request.h",
       "device_identity/device_identity_provider.cc",

chrome/browser/content_settings/generated_cookie_prefs.cc

@@ -14,38 +14,12 @@
 #include "components/prefs/pref_service.h"
 
 namespace settings_api = extensions::api::settings_private;
+namespace settings_private = extensions::settings_private;
 
 namespace content_settings {
 
 namespace {
 
-settings_api::ControlledBy GetControlledByForContentSettingSource(
-    SettingSource source) {
-  switch (source) {
-    case SETTING_SOURCE_POLICY:
-      return settings_api::ControlledBy::CONTROLLED_BY_DEVICE_POLICY;
-    case SETTING_SOURCE_EXTENSION:
-      return settings_api::ControlledBy::CONTROLLED_BY_EXTENSION;
-    case SETTING_SOURCE_SUPERVISED:
-      return settings_api::ControlledBy::CONTROLLED_BY_CHILD_RESTRICTION;
-    default:
-      NOTREACHED();
-      return settings_api::ControlledBy::CONTROLLED_BY_DEVICE_POLICY;
-  }
-}
-
-// Adds the provided |value| to the user selectable values of |pref_object|,
-// creating the base::Value vector if required.
-void AddUserSelectableValue(settings_api::PrefObject* pref_object,
-                            CookiePrimarySetting value) {
-  if (!pref_object->user_selectable_values) {
-    pref_object->user_selectable_values =
-        std::make_unique<std::vector<std::unique_ptr<base::Value>>>();
-  }
-  pref_object->user_selectable_values->push_back(
-      std::make_unique<base::Value>(static_cast<int>(value)));
-}
-
 bool IsDefaultCookieContentSettingUserControlled(HostContentSettingsMap* map) {
   std::string content_setting_provider;
   map->GetDefaultContentSetting(ContentSettingsType::COOKIES,
@@ -251,15 +225,15 @@ void GeneratedCookiePrimarySettingPref::ApplyPrimaryCookieSettingManagedState(
   if (content_setting_enforced && content_setting == CONTENT_SETTING_BLOCK) {
     // Preference is fully managed by the content setting.
     pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
-    pref_object->controlled_by =
-        GetControlledByForContentSettingSource(content_setting_source);
+    settings_private::GeneratedPref::ApplyControlledByFromContentSettingSource(
+        pref_object, content_setting_source);
     return;
   }
 
   if (content_setting_enforced && cookie_controls_mode_enforced) {
     // Preference is considered fully managed by the third party preference.
     pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
-    extensions::settings_private::GeneratedPref::ApplyControlledByFromPref(
+    settings_private::GeneratedPref::ApplyControlledByFromPref(
         pref_object, cookie_controls_mode_pref);
     return;
   }
@@ -286,12 +260,14 @@ void GeneratedCookiePrimarySettingPref::ApplyPrimaryCookieSettingManagedState(
   // you can choose between the selected cookie controls setting and "BLOCK"
   if (cookie_controls_mode_enforced) {
     pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
-    extensions::settings_private::GeneratedPref::ApplyControlledByFromPref(
+    settings_private::GeneratedPref::ApplyControlledByFromPref(
         pref_object, cookie_controls_mode_pref);
     auto value = static_cast<CookieControlsMode>(
         cookie_controls_mode_pref->GetValue()->GetInt());
-    AddUserSelectableValue(pref_object, ToCookiePrimarySetting(value));
-    AddUserSelectableValue(pref_object, CookiePrimarySetting::BLOCK_ALL);
+    settings_private::GeneratedPref::AddUserSelectableValue(
+        pref_object, static_cast<int>(ToCookiePrimarySetting(value)));
+    settings_private::GeneratedPref::AddUserSelectableValue(
+        pref_object, static_cast<int>(CookiePrimarySetting::BLOCK_ALL));
     return;
   }
 
@@ -300,14 +276,16 @@ void GeneratedCookiePrimarySettingPref::ApplyPrimaryCookieSettingManagedState(
     DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
            content_setting == CONTENT_SETTING_SESSION_ONLY);
     pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
-    pref_object->controlled_by =
-        GetControlledByForContentSettingSource(content_setting_source);
-
-    AddUserSelectableValue(pref_object, CookiePrimarySetting::ALLOW_ALL);
-    AddUserSelectableValue(pref_object,
-                           CookiePrimarySetting::BLOCK_THIRD_PARTY);
-    AddUserSelectableValue(pref_object,
-                           CookiePrimarySetting::BLOCK_THIRD_PARTY_INCOGNITO);
+    settings_private::GeneratedPref::ApplyControlledByFromContentSettingSource(
+        pref_object, content_setting_source);
+
+    settings_private::GeneratedPref::AddUserSelectableValue(
+        pref_object, static_cast<int>(CookiePrimarySetting::ALLOW_ALL));
+    settings_private::GeneratedPref::AddUserSelectableValue(
+        pref_object, static_cast<int>(CookiePrimarySetting::BLOCK_THIRD_PARTY));
+    settings_private::GeneratedPref::AddUserSelectableValue(
+        pref_object,
+        static_cast<int>(CookiePrimarySetting::BLOCK_THIRD_PARTY_INCOGNITO));
   }
 }
 

chrome/browser/content_settings/generated_notification_pref.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 "chrome/browser/content_settings/generated_notification_pref.h"
+
+#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "chrome/common/extensions/api/settings_private.h"
+#include "components/content_settings/core/browser/content_settings_utils.h"
+#include "components/content_settings/core/common/content_settings.h"
+#include "components/content_settings/core/common/pref_names.h"
+
+namespace settings_api = extensions::api::settings_private;
+typedef extensions::settings_private::GeneratedPref GeneratedPref;
+
+namespace content_settings {
+
+const char kGeneratedNotificationPref[] = "generated.notification";
+
+namespace {
+
+bool IsDefaultNotificationContentSettingUserControlled(
+    HostContentSettingsMap* map) {
+  std::string content_setting_provider;
+  map->GetDefaultContentSetting(ContentSettingsType::NOTIFICATIONS,
+                                &content_setting_provider);
+  auto content_setting_source =
+      HostContentSettingsMap::GetSettingSourceFromProviderName(
+          content_setting_provider);
+  return content_setting_source == SettingSource::SETTING_SOURCE_USER;
+}
+
+}  // namespace
+
+GeneratedNotificationPref::GeneratedNotificationPref(Profile* profile)
+    : profile_(profile) {
+  user_prefs_registrar_.Init(profile->GetPrefs());
+  user_prefs_registrar_.Add(
+      prefs::kEnableQuietNotificationPermissionUi,
+      base::BindRepeating(
+          &GeneratedNotificationPref::OnNotificationPreferencesChanged,
+          base::Unretained(this)));
+
+  host_content_settings_map_ =
+      HostContentSettingsMapFactory::GetForProfile(profile_);
+  content_setting_observer_.Add(host_content_settings_map_);
+}
+
+GeneratedNotificationPref::~GeneratedNotificationPref() = default;
+
+void GeneratedNotificationPref::OnContentSettingChanged(
+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern,
+    ContentSettingsType content_type,
+    const std::string& resource_identifier) {
+  if (content_type == ContentSettingsType::NOTIFICATIONS) {
+    NotifyObservers(kGeneratedNotificationPref);
+  }
+}
+
+void GeneratedNotificationPref::OnNotificationPreferencesChanged() {
+  NotifyObservers(kGeneratedNotificationPref);
+}
+
+extensions::settings_private::SetPrefResult GeneratedNotificationPref::SetPref(
+    const base::Value* value) {
+  if (!value->is_int())
+    return extensions::settings_private::SetPrefResult::PREF_TYPE_MISMATCH;
+
+  auto selection = static_cast<NotificationSetting>(value->GetInt());
+
+  if (selection != NotificationSetting::ASK &&
+      selection != NotificationSetting::QUIETER_MESSAGING &&
+      selection != NotificationSetting::BLOCK) {
+    return extensions::settings_private::SetPrefResult::PREF_TYPE_MISMATCH;
+  }
+
+  auto current_content_setting =
+      host_content_settings_map_->GetDefaultContentSetting(
+          ContentSettingsType::NOTIFICATIONS, nullptr);
+  auto new_content_setting = selection == NotificationSetting::BLOCK
+                                 ? ContentSetting::CONTENT_SETTING_BLOCK
+                                 : ContentSetting::CONTENT_SETTING_ASK;
+
+  // Do not modify content setting if its setting source is not user.
+  // If there's no actual change, the check doesn't apply.
+  if (current_content_setting != new_content_setting &&
+      !IsDefaultNotificationContentSettingUserControlled(
+          host_content_settings_map_)) {
+    return extensions::settings_private::SetPrefResult::PREF_NOT_MODIFIABLE;
+  }
+  if (selection != NotificationSetting::BLOCK) {
+    const PrefService::Preference* quieter_pref =
+        profile_->GetPrefs()->FindPreference(
+            prefs::kEnableQuietNotificationPermissionUi);
+    bool quieter_value = quieter_pref->GetValue()->GetBool();
+    bool new_quieter_value = selection != NotificationSetting::ASK;
+
+    // Do not modify the preference value if the user is unable to change its
+    // value. If there's no actual change, this check doesn't apply.
+    if (quieter_value != new_quieter_value &&
+        !quieter_pref->IsUserModifiable()) {
+      return extensions::settings_private::SetPrefResult::PREF_NOT_MODIFIABLE;
+    }
+    profile_->GetPrefs()->SetBoolean(
+        prefs::kEnableQuietNotificationPermissionUi, new_quieter_value);
+  }
+
+  host_content_settings_map_->SetDefaultContentSetting(
+      ContentSettingsType::NOTIFICATIONS, new_content_setting);
+  return extensions::settings_private::SetPrefResult::SUCCESS;
+}
+
+std::unique_ptr<settings_api::PrefObject>
+GeneratedNotificationPref::GetPrefObject() const {
+  auto pref_object = std::make_unique<settings_api::PrefObject>();
+  pref_object->key = kGeneratedNotificationPref;
+  pref_object->type = settings_api::PREF_TYPE_NUMBER;
+
+  const auto quieter_pref_enabled =
+      profile_->GetPrefs()
+          ->FindPreference(prefs::kEnableQuietNotificationPermissionUi)
+          ->GetValue()
+          ->GetBool();
+  const auto notification_content_setting =
+      host_content_settings_map_->GetDefaultContentSetting(
+          ContentSettingsType::NOTIFICATIONS, nullptr);
+  const auto notification_content_setting_enabled =
+      notification_content_setting != ContentSetting::CONTENT_SETTING_BLOCK;
+
+  if (notification_content_setting_enabled && quieter_pref_enabled) {
+    pref_object->value = std::make_unique<base::Value>(
+        static_cast<int>(NotificationSetting::QUIETER_MESSAGING));
+  } else if (notification_content_setting_enabled) {
+    pref_object->value = std::make_unique<base::Value>(
+        static_cast<int>(NotificationSetting::ASK));
+  } else {
+    DCHECK_EQ(ContentSetting::CONTENT_SETTING_BLOCK,
+              notification_content_setting);
+    pref_object->value = std::make_unique<base::Value>(
+        static_cast<int>(NotificationSetting::BLOCK));
+  }
+
+  ApplyNotificationManagementState(profile_, pref_object.get());
+
+  return pref_object;
+}
+
+/* static */
+void GeneratedNotificationPref::ApplyNotificationManagementState(
+    Profile* profile,
+    settings_api::PrefObject* pref_object) {
+  HostContentSettingsMap* map =
+      HostContentSettingsMapFactory::GetForProfile(profile);
+  std::string content_setting_provider;
+  auto content_setting = map->GetDefaultContentSetting(
+      ContentSettingsType::NOTIFICATIONS, &content_setting_provider);
+  auto content_setting_source =
+      HostContentSettingsMap::GetSettingSourceFromProviderName(
+          content_setting_provider);
+  bool content_setting_enforced =
+      content_setting_source !=
+      content_settings::SettingSource::SETTING_SOURCE_USER;
+
+  const PrefService::Preference* quieter_ui_pref =
+      profile->GetPrefs()->FindPreference(
+          prefs::kEnableQuietNotificationPermissionUi);
+  auto quieter_ui_on = quieter_ui_pref->GetValue()->GetBool();
+  auto quieter_ui_enforced = !quieter_ui_pref->IsUserModifiable();
+  auto quieter_ui_recommended =
+      quieter_ui_pref->GetRecommendedValue() != nullptr;
+  auto quieter_ui_recommended_on =
+      (quieter_ui_recommended &&
+       quieter_ui_pref->GetRecommendedValue()->GetBool());
+
+  if (!content_setting_enforced && !quieter_ui_enforced &&
+      !quieter_ui_recommended) {
+    // No notification setting is enforced or recommended.
+    return;
+  }
+
+  if (content_setting_enforced) {
+    pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
+
+    if (content_setting == CONTENT_SETTING_BLOCK) {
+      // Preference is fully managed by the content setting.
+      GeneratedPref::ApplyControlledByFromContentSettingSource(
+          pref_object, content_setting_source);
+      return;
+    } else if (quieter_ui_enforced) {
+      // Preference is fully managed by the content setting and quieter ui pref.
+      GeneratedPref::ApplyControlledByFromPref(pref_object, quieter_ui_pref);
+      return;
+    }
+    GeneratedPref::ApplyControlledByFromContentSettingSource(
+        pref_object, content_setting_source);
+
+    DCHECK(content_setting_enforced && !quieter_ui_enforced);
+    // Since content setting is enforced but the quieter ui pref is not,
+    // user can choose from 2 options.
+    GeneratedPref::AddUserSelectableValue(
+        pref_object, static_cast<int>(NotificationSetting::ASK));
+    GeneratedPref::AddUserSelectableValue(
+        pref_object, static_cast<int>(NotificationSetting::QUIETER_MESSAGING));
+
+    if (quieter_ui_recommended) {
+      pref_object->recommended_value =
+          std::make_unique<base::Value>(static_cast<int>(
+              quieter_ui_recommended_on ? NotificationSetting::QUIETER_MESSAGING
+                                        : NotificationSetting::ASK));
+    }
+    return;
+  }
+
+  if (quieter_ui_enforced) {
+    // Quieter ui pref is enforced, but the content setting is not, so the user
+    // can choose from 2 options
+    pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
+    GeneratedPref::ApplyControlledByFromPref(pref_object, quieter_ui_pref);
+    GeneratedPref::AddUserSelectableValue(
+        pref_object,
+        static_cast<int>(quieter_ui_on ? NotificationSetting::QUIETER_MESSAGING
+                                       : NotificationSetting::ASK));
+    GeneratedPref::AddUserSelectableValue(
+        pref_object, static_cast<int>(NotificationSetting::BLOCK));
+  }
+  // If neither of notification content setting nor quieter ui preference is
+  // enforced, but quieter ui preference is recommended, then recommended value
+  // is ignored since it's ambiguous given that notification content setting
+  // can be blocked.
+}
+
+}  // namespace content_settings

chrome/browser/content_settings/generated_notification_pref.h

+// 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.
+
+#ifndef CHROME_BROWSER_CONTENT_SETTINGS_GENERATED_NOTIFICATION_PREF_H_
+#define CHROME_BROWSER_CONTENT_SETTINGS_GENERATED_NOTIFICATION_PREF_H_
+
+#include "chrome/browser/extensions/api/settings_private/generated_pref.h"
+
+#include "base/scoped_observer.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/content_settings/core/browser/content_settings_observer.h"
+#include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "components/prefs/pref_change_registrar.h"
+
+namespace content_settings {
+
+extern const char kGeneratedNotificationPref[];
+
+enum class NotificationSetting { ASK, QUIETER_MESSAGING, BLOCK };
+
+// A generated preference which represents the effective Notification setting
+// state based on the Notification content setting and quieter UI user
+// preference.
+class GeneratedNotificationPref
+    : public extensions::settings_private::GeneratedPref,
+      public content_settings::Observer {
+ public:
+  explicit GeneratedNotificationPref(Profile* profile);
+
+  ~GeneratedNotificationPref() override;
+
+  // Generated Preference Interface.
+  extensions::settings_private::SetPrefResult SetPref(
+      const base::Value* value) override;
+  std::unique_ptr<extensions::api::settings_private::PrefObject> GetPrefObject()
+      const override;
+
+  void OnContentSettingChanged(const ContentSettingsPattern& primary_pattern,
+                               const ContentSettingsPattern& secondary_pattern,
+                               ContentSettingsType content_type,
+                               const std::string& resource_identifier) override;
+
+  void OnNotificationPreferencesChanged();
+
+ private:
+  static void ApplyNotificationManagementState(
+      Profile* profile,
+      extensions::api::settings_private::PrefObject* pref_object);
+
+  Profile* const profile_;
+  HostContentSettingsMap* host_content_settings_map_;
+  ScopedObserver<HostContentSettingsMap, content_settings::Observer>
+      content_setting_observer_{this};
+  PrefChangeRegistrar user_prefs_registrar_;
+};
+
+}  // namespace content_settings
+
+#endif  // CHROME_BROWSER_CONTENT_SETTINGS_GENERATED_NOTIFICATION_PREF_H_

chrome/browser/extensions/api/settings_private/generated_pref.cc

@@ -55,5 +55,39 @@ void GeneratedPref::ApplyControlledByFromPref(
   NOTREACHED();
 }
 
+/* static */
+void GeneratedPref::ApplyControlledByFromContentSettingSource(
+    api::settings_private::PrefObject* pref_object,
+    content_settings::SettingSource setting_source) {
+  switch (setting_source) {
+    case content_settings::SETTING_SOURCE_POLICY:
+      pref_object->controlled_by =
+          settings_api::ControlledBy::CONTROLLED_BY_DEVICE_POLICY;
+      break;
+    case content_settings::SETTING_SOURCE_EXTENSION:
+      pref_object->controlled_by =
+          settings_api::ControlledBy::CONTROLLED_BY_EXTENSION;
+      break;
+    case content_settings::SETTING_SOURCE_SUPERVISED:
+      pref_object->controlled_by =
+          settings_api::ControlledBy::CONTROLLED_BY_CHILD_RESTRICTION;
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+/* static */
+void GeneratedPref::AddUserSelectableValue(
+    settings_api::PrefObject* pref_object,
+    int value) {
+  if (!pref_object->user_selectable_values) {
+    pref_object->user_selectable_values =
+        std::make_unique<std::vector<std::unique_ptr<base::Value>>>();
+  }
+  pref_object->user_selectable_values->push_back(
+      std::make_unique<base::Value>(static_cast<int>(value)));
+}
+
 }  // namespace settings_private
 }  // namespace extensions

chrome/browser/extensions/api/settings_private/generated_pref.h

@@ -10,6 +10,7 @@
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "chrome/browser/extensions/api/settings_private/prefs_util_enums.h"
+#include "components/content_settings/core/common/content_settings.h"
 #include "components/prefs/pref_service.h"
 
 namespace base {
@@ -69,6 +70,19 @@ class GeneratedPref {
       api::settings_private::PrefObject* pref_object,
       const PrefService::Preference* pref);
 
+  // Sets controlled_by for |pref_object| base on provided |setting_source|
+  // for a limited subset of controlled_by sources relevant for content
+  // settings.
+  static void ApplyControlledByFromContentSettingSource(
+      api::settings_private::PrefObject* pref_object,
+      content_settings::SettingSource setting_source);
+
+  // Adds the provided |value| to the user selectable values of |pref_object|,
+  // creating the base::Value vector if required.
+  static void AddUserSelectableValue(
+      extensions::api::settings_private::PrefObject* pref_object,
+      int value);
+
  private:
   base::ObserverList<Observer>::Unchecked observers_;
 

chrome/browser/extensions/api/settings_private/generated_pref_test_base.cc

@@ -7,6 +7,27 @@
 namespace extensions {
 namespace settings_private {
 
+void SetPrefFromSource(sync_preferences::TestingPrefServiceSyncable* prefs,
+                       const std::string& pref_name,
+                       settings_private::PrefSetting pref_setting,
+                       settings_private::PrefSource source) {
+  if (pref_setting == settings_private::PrefSetting::kNotSet) {
+    return;
+  }
+  auto pref_value = std::make_unique<base::Value>(
+      pref_setting == settings_private::PrefSetting::kRecommendedOn ||
+      pref_setting == settings_private::PrefSetting::kEnforcedOn);
+  if (source == settings_private::PrefSource::kExtension) {
+    prefs->SetExtensionPref(pref_name, std::move(pref_value));
+  } else if (source == settings_private::PrefSource::kDevicePolicy) {
+    prefs->SetManagedPref(pref_name, std::move(pref_value));
+  } else if (source == settings_private::PrefSource::kRecommended) {
+    prefs->SetRecommendedPref(pref_name, std::move(pref_value));
+  } else {
+    NOTREACHED();
+  }
+}
+
 void TestGeneratedPrefObserver::OnGeneratedPrefChanged(
     const std::string& pref_name) {
   updated_pref_name_ = pref_name;

chrome/browser/extensions/api/settings_private/generated_pref_test_base.h

@@ -8,6 +8,7 @@
 #include "chrome/browser/extensions/api/settings_private/generated_pref.h"
 #include "chrome/common/extensions/api/settings_private.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/test/browser_task_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -36,6 +37,13 @@ enum class PrefSource {
   kNone,
 };
 
+// Sets |pref_name| to |pref_setting|, using the appropriate store in |prefs|
+// for |source|.
+void SetPrefFromSource(sync_preferences::TestingPrefServiceSyncable* prefs,
+                       const std::string& pref_name,
+                       settings_private::PrefSetting pref_setting,
+                       settings_private::PrefSource source);
+
 class TestGeneratedPrefObserver : public GeneratedPref::Observer {
  public:
   void OnGeneratedPrefChanged(const std::string& pref_name) override;

chrome/browser/safe_browsing/generated_safe_browsing_pref_unittest.cc

@@ -163,39 +163,18 @@ const std::vector<SafeBrowsingManagementTestCase> kManagedTestCases = {
      {SafeBrowsingSetting::STANDARD, SafeBrowsingSetting::DISABLED}},
 };
 
-// Sets |pref_name| to |pref_setting|, using the appropriate store in |prefs|
-// for |source|.
-void SetPrefFromSource(sync_preferences::TestingPrefServiceSyncable* prefs,
-                       const std::string& pref_name,
-                       settings_private::PrefSetting pref_setting,
-                       settings_private::PrefSource source) {
-  if (pref_setting == settings_private::PrefSetting::kNotSet) {
-    return;
-  }
-  auto pref_value = std::make_unique<base::Value>(
-      pref_setting == settings_private::PrefSetting::kRecommendedOn ||
-      pref_setting == settings_private::PrefSetting::kEnforcedOn);
-  if (source == settings_private::PrefSource::kExtension) {
-    prefs->SetExtensionPref(pref_name, std::move(pref_value));
-  } else if (source == settings_private::PrefSource::kDevicePolicy) {
-    prefs->SetManagedPref(pref_name, std::move(pref_value));
-  } else if (source == settings_private::PrefSource::kRecommended) {
-    prefs->SetRecommendedPref(pref_name, std::move(pref_value));
-  }
-}
-
 void SetupManagedTestConditions(
     sync_preferences::TestingPrefServiceSyncable* prefs,
     const SafeBrowsingManagementTestCase& test_case) {
-  SetPrefFromSource(prefs, prefs::kSafeBrowsingEnabled,
-                    test_case.safe_browsing_enabled,
-                    test_case.enabled_enhanced_preference_source);
-  SetPrefFromSource(prefs, prefs::kSafeBrowsingEnhanced,
-                    test_case.safe_browsing_enhanced,
-                    test_case.enabled_enhanced_preference_source);
-  SetPrefFromSource(prefs, prefs::kSafeBrowsingScoutReportingEnabled,
-                    test_case.safe_browsing_reporting,
-                    test_case.reporting_preference_source);
+  extensions::settings_private::SetPrefFromSource(
+      prefs, prefs::kSafeBrowsingEnabled, test_case.safe_browsing_enabled,
+      test_case.enabled_enhanced_preference_source);
+  extensions::settings_private::SetPrefFromSource(
+      prefs, prefs::kSafeBrowsingEnhanced, test_case.safe_browsing_enhanced,
+      test_case.enabled_enhanced_preference_source);
+  extensions::settings_private::SetPrefFromSource(
+      prefs, prefs::kSafeBrowsingScoutReportingEnabled,
+      test_case.safe_browsing_reporting, test_case.reporting_preference_source);
 }
 
 void ValidateManagedPreference(

chrome/test/BUILD.gn

@@ -3770,6 +3770,7 @@ test("unit_tests") {
       "../browser/component_updater/soda_en_us_component_installer_unittest.cc",
       "../browser/component_updater/soda_ja_jp_component_installer_unittest.cc",
       "../browser/content_settings/generated_cookie_prefs_unittest.cc",
+      "../browser/content_settings/generated_notification_pref_unittest.cc",
       "../browser/device_identity/device_oauth2_token_service_unittest.cc",
       "../browser/media/feeds/media_feeds_converter_unittest.cc",
       "../browser/media/feeds/media_feeds_fetcher_unittest.cc",