Add handler to support display of Safe Browsing policy managed settings

As part of the Friendly Settings privacy settings redesign a new Safe
Browsing control was introduced. This controls offered a new way of
interacting with existing Safe Browsing settings and supported the new
"Enhanced" SB mode.

This CL adds a C++ handler to provide the current managed state of the
new controls for immediate display by JavaScript.

Bug: 1061947
Change-Id: Ib52d2a8f52747fcb19d45dc950cabd548e72210e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2124750
Commit-Queue: Theodore Olsauskas-Warren <sauski@google.com>
Reviewed-by: Martin Šrámek <msramek@chromium.org>
Reviewed-by: dpapad <dpapad@chromium.org>
Cr-Commit-Position: refs/heads/master@{#755350}

chrome/browser/resources/settings/privacy_page/safe_browsing_browser_proxy.js

@@ -5,7 +5,7 @@
 /** @fileoverview Handles Safe Browsing settings updates */
 
 // clang-format on
-// #import {addSingletonGetter} from 'chrome://resources/js/cr.m.js';
+// #import {addSingletonGetter, sendWithPromise} from 'chrome://resources/js/cr.m.js';
 // #import {CrPolicyIndicatorType} from 'chrome://resources/cr_elements/policy/cr_policy_indicator_behavior.m.js';
 // #import {ManagedState} from '../site_settings/site_settings_prefs_browser_proxy.m.js';
 // clang-format off
@@ -32,12 +32,7 @@ cr.define('settings', function() {
   /* #export */ class SafeBrowsingBrowserProxyImpl {
     /** @override */
     getSafeBrowsingRadioManagedState() {
-      const defaultRadioState = {
-        enhanced: {disabled: false, indicator: CrPolicyIndicatorType.NONE},
-        standard: {disabled: false, indicator: CrPolicyIndicatorType.NONE},
-        disabled: {disabled: false, indicator: CrPolicyIndicatorType.NONE},
-      };
-      return Promise.resolve(defaultRadioState); // Unimplemented.
+      return cr.sendWithPromise('getSafeBrowsingRadioManagedState');
     }
   }
 

chrome/browser/ui/BUILD.gn

@@ -1384,6 +1384,8 @@ jumbo_static_library("ui") {
       "webui/settings/protocol_handlers_handler.h",
       "webui/settings/reset_settings_handler.cc",
       "webui/settings/reset_settings_handler.h",
+      "webui/settings/safe_browsing_handler.cc",
+      "webui/settings/safe_browsing_handler.h",
       "webui/settings/safety_check_handler.cc",
       "webui/settings/safety_check_handler.h",
       "webui/settings/search_engines_handler.cc",

chrome/browser/ui/webui/settings/safe_browsing_handler.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/ui/webui/settings/safe_browsing_handler.h"
+
+#include "components/prefs/pref_change_registrar.h"
+#include "components/prefs/pref_service.h"
+#include "components/safe_browsing/core/common/safe_browsing_prefs.h"
+
+namespace settings {
+
+SafeBrowsingHandler::SafeBrowsingHandler(Profile* profile)
+    : profile_(profile) {}
+SafeBrowsingHandler::~SafeBrowsingHandler() = default;
+
+void SafeBrowsingHandler::RegisterMessages() {
+  web_ui()->RegisterMessageCallback(
+      "getSafeBrowsingRadioManagedState",
+      base::BindRepeating(
+          &SafeBrowsingHandler::HandleGetSafeBrowsingRadioManagedState,
+          base::Unretained(this)));
+}
+
+void SafeBrowsingHandler::HandleGetSafeBrowsingRadioManagedState(
+    const base::ListValue* args) {
+  AllowJavascript();
+  CHECK_EQ(1U, args->GetList().size());
+  std::string callback_id = args->GetList()[0].GetString();
+
+  auto state = GetSafeBrowsingRadioManagedState(profile_);
+
+  base::Value result(base::Value::Type::DICTIONARY);
+  // TODO(crbug.com/1063265): Move managed state functions out of site_settings.
+  result.SetKey(kSafeBrowsingEnhanced,
+                site_settings::GetValueForManagedState(state.enhanced));
+  result.SetKey(kSafeBrowsingStandard,
+                site_settings::GetValueForManagedState(state.standard));
+  result.SetKey(kSafeBrowsingDisabled,
+                site_settings::GetValueForManagedState(state.disabled));
+
+  ResolveJavascriptCallback(base::Value(callback_id), result);
+}
+
+SafeBrowsingRadioManagedState
+SafeBrowsingHandler::GetSafeBrowsingRadioManagedState(Profile* profile) {
+  // Create a default managed state that is updated based on preferences.
+  SafeBrowsingRadioManagedState managed_state;
+
+  // Computing the effective Safe Browsing managed state requires inspecting
+  // three different preferences. It is possible that these may be in
+  // temporarily conflicting managed states. The enabled preference is always
+  // taken as the canonical source of management.
+  const PrefService::Preference* enabled_pref =
+      profile->GetPrefs()->FindPreference(prefs::kSafeBrowsingEnabled);
+  const bool enabled_enforced = !enabled_pref->IsUserModifiable();
+  const bool enabled_recommended =
+      (enabled_pref && enabled_pref->GetRecommendedValue());
+  const bool enabled_recommended_on =
+      enabled_recommended && enabled_pref->GetRecommendedValue()->GetBool();
+  const auto enabled_policy_indicator =
+      site_settings::GetPolicyIndicatorFromPref(enabled_pref);
+
+  // The enhanced preference may have a recommended setting. This only takes
+  // effect if the enabled preference also has a recommended setting.
+  const PrefService::Preference* enhanced_pref =
+      profile->GetPrefs()->FindPreference(prefs::kSafeBrowsingEnhanced);
+  const bool enhanced_recommended_on =
+      enhanced_pref->GetRecommendedValue() &&
+      enhanced_pref->GetRecommendedValue()->GetBool();
+
+  // A forcefully disabled reporting preference will disallow enhanced from
+  // being selected and thus it must also be considered.
+  const PrefService::Preference* reporting_pref =
+      profile->GetPrefs()->FindPreference(
+          prefs::kSafeBrowsingScoutReportingEnabled);
+  const bool reporting_on = reporting_pref->GetValue()->GetBool();
+  const bool reporting_enforced = !reporting_pref->IsUserModifiable();
+  const auto reporting_policy_indicator =
+      site_settings::GetPolicyIndicatorFromPref(reporting_pref);
+
+  if (!enabled_enforced && !enabled_recommended && !reporting_enforced) {
+    // No relevant policies are applied, return the default state.
+    return managed_state;
+  }
+  if (enabled_enforced) {
+    // All radio controls are managed.
+    managed_state.enhanced.disabled = true;
+    managed_state.enhanced.indicator = enabled_policy_indicator;
+    managed_state.standard.disabled = true;
+    managed_state.standard.indicator = enabled_policy_indicator;
+    managed_state.disabled.disabled = true;
+    managed_state.disabled.indicator = enabled_policy_indicator;
+    return managed_state;
+  }
+  if (enabled_recommended) {
+    if (enhanced_recommended_on) {
+      managed_state.enhanced.indicator = enabled_policy_indicator;
+    } else if (enabled_recommended_on) {
+      managed_state.standard.indicator = enabled_policy_indicator;
+    } else {
+      managed_state.disabled.indicator = enabled_policy_indicator;
+    }
+    return managed_state;
+  }
+  if (reporting_enforced && !reporting_on) {
+    // Disable enhanced protection when reporting has been enforced off.
+    managed_state.enhanced.disabled = true;
+    managed_state.enhanced.indicator = reporting_policy_indicator;
+    return managed_state;
+  }
+
+  return managed_state;
+}
+
+}  // namespace settings

chrome/browser/ui/webui/settings/safe_browsing_handler.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_UI_WEBUI_SETTINGS_SAFE_BROWSING_HANDLER_H_
+#define CHROME_BROWSER_UI_WEBUI_SETTINGS_SAFE_BROWSING_HANDLER_H_
+
+#include "chrome/browser/ui/webui/settings/settings_page_ui_handler.h"
+#include "chrome/browser/ui/webui/site_settings_helper.h"
+
+#include "chrome/browser/profiles/profile.h"
+
+namespace settings {
+
+constexpr char kSafeBrowsingEnhanced[] = "enhanced";
+constexpr char kSafeBrowsingStandard[] = "standard";
+constexpr char kSafeBrowsingDisabled[] = "disabled";
+
+struct SafeBrowsingRadioManagedState {
+  site_settings::ManagedState enhanced;
+  site_settings::ManagedState standard;
+  site_settings::ManagedState disabled;
+};
+
+// Settings page UI handler that provides representation of Safe Browsing
+// settings.
+class SafeBrowsingHandler : public SettingsPageUIHandler {
+ public:
+  explicit SafeBrowsingHandler(Profile* profile);
+  ~SafeBrowsingHandler() override;
+
+  // WebUIMessageHandler implementation.
+  void RegisterMessages() override;
+
+  // Calculate and return the current Safe Browsing radio buttons.
+  void HandleGetSafeBrowsingRadioManagedState(const base::ListValue* args);
+
+ private:
+  friend class SafeBrowsingHandlerTest;
+  FRIEND_TEST_ALL_PREFIXES(SafeBrowsingHandlerTest, GenerateRadioManagedState);
+  FRIEND_TEST_ALL_PREFIXES(SafeBrowsingHandlerTest, ProvideRadioManagedState);
+
+  // SettingsPageUIHandler implementation.
+  void OnJavascriptAllowed() override {}
+  void OnJavascriptDisallowed() override {}
+
+  // Calculate the current Safe Browsing control state for the provided profile.
+  static SafeBrowsingRadioManagedState GetSafeBrowsingRadioManagedState(
+      Profile* profile);
+
+  Profile* profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingHandler);
+};
+
+}  // namespace settings
+
+#endif  // CHROME_BROWSER_UI_WEBUI_SETTINGS_SAFE_BROWSING_HANDLER_H_

chrome/browser/ui/webui/settings/safe_browsing_handler_unittest.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/ui/webui/settings/safe_browsing_handler.h"
+
+#include <memory>
+#include <string>
+
+#include "base/values.h"
+#include "chrome/test/base/chrome_render_view_host_test_harness.h"
+#include "chrome/test/base/testing_profile.h"
+#include "components/prefs/pref_service.h"
+#include "components/safe_browsing/core/common/safe_browsing_prefs.h"
+#include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "content/public/test/browser_task_environment.h"
+#include "content/public/test/test_web_ui.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace settings {
+
+class SafeBrowsingHandlerTest : public testing::Test {
+ public:
+  void SetUp() override {
+    handler_ = std::make_unique<SafeBrowsingHandler>(profile());
+    handler()->set_web_ui(web_ui());
+    handler()->AllowJavascript();
+    web_ui()->ClearTrackedCalls();
+  }
+
+  TestingProfile* profile() { return &profile_; }
+  content::TestWebUI* web_ui() { return &web_ui_; }
+  SafeBrowsingHandler* handler() { return handler_.get(); }
+
+ private:
+  content::BrowserTaskEnvironment task_environment_;
+  std::unique_ptr<SafeBrowsingHandler> handler_;
+  TestingProfile profile_;
+  content::TestWebUI web_ui_;
+};
+
+// All of the possible managed states for a boolean preference that can be
+// both enforced and recommended.
+// TODO(crbug.com/1063265): Remove duplication with site_settings_helper.
+enum class PrefSetting {
+  kEnforcedOff,
+  kEnforcedOn,
+  kRecommendedOff,
+  kRecommendedOn,
+  kNotSet,
+};
+
+// Possible preference sources supported by TestingPrefService.
+// TODO(crbug.com/1063265): Remove duplication with site_settings_helper.
+enum class PrefSource {
+  kExtension,
+  kDevicePolicy,
+  kRecommended,
+  kNone,
+};
+
+void AssertRadioManagedStateEqual(const SafeBrowsingRadioManagedState& a,
+                                  const SafeBrowsingRadioManagedState& b) {
+  ASSERT_EQ(a.enhanced.disabled, b.enhanced.disabled);
+  ASSERT_EQ(a.enhanced.indicator, b.enhanced.indicator);
+  ASSERT_EQ(a.standard.disabled, b.standard.disabled);
+  ASSERT_EQ(a.standard.indicator, b.standard.indicator);
+  ASSERT_EQ(a.disabled.disabled, b.disabled.disabled);
+  ASSERT_EQ(a.disabled.indicator, b.disabled.indicator);
+}
+
+struct RadioManagedStateTestCase {
+  PrefSetting safe_browsing_enhanced;
+  PrefSetting safe_browsing_enabled;
+  PrefSetting safe_browsing_reporting;
+  PrefSource preference_source;
+  SafeBrowsingRadioManagedState expected_result;
+};
+
+const std::vector<RadioManagedStateTestCase> test_cases = {
+    {PrefSetting::kNotSet,
+     PrefSetting::kNotSet,
+     PrefSetting::kNotSet,
+     PrefSource::kNone,
+     {{false, site_settings::PolicyIndicatorType::kNone},
+      {false, site_settings::PolicyIndicatorType::kNone},
+      {false, site_settings::PolicyIndicatorType::kNone}}},
+    {PrefSetting::kEnforcedOn,
+     PrefSetting::kEnforcedOn,
+     PrefSetting::kNotSet,
+     PrefSource::kExtension,
+     {{true, site_settings::PolicyIndicatorType::kExtension},
+      {true, site_settings::PolicyIndicatorType::kExtension},
+      {true, site_settings::PolicyIndicatorType::kExtension}}},
+    {PrefSetting::kEnforcedOff,
+     PrefSetting::kEnforcedOff,
+     PrefSetting::kNotSet,
+     PrefSource::kDevicePolicy,
+     {{true, site_settings::PolicyIndicatorType::kDevicePolicy},
+      {true, site_settings::PolicyIndicatorType::kDevicePolicy},
+      {true, site_settings::PolicyIndicatorType::kDevicePolicy}}},
+    {PrefSetting::kEnforcedOff,
+     PrefSetting::kEnforcedOn,
+     PrefSetting::kNotSet,
+     PrefSource::kExtension,
+     {{true, site_settings::PolicyIndicatorType::kExtension},
+      {true, site_settings::PolicyIndicatorType::kExtension},
+      {true, site_settings::PolicyIndicatorType::kExtension}}},
+    {PrefSetting::kRecommendedOn,
+     PrefSetting::kRecommendedOn,
+     PrefSetting::kNotSet,
+     PrefSource::kRecommended,
+     {{false, site_settings::PolicyIndicatorType::kRecommended},
+      {false, site_settings::PolicyIndicatorType::kNone},
+      {false, site_settings::PolicyIndicatorType::kNone}}},
+    {PrefSetting::kRecommendedOff,
+     PrefSetting::kRecommendedOn,
+     PrefSetting::kNotSet,
+     PrefSource::kRecommended,
+     {{false, site_settings::PolicyIndicatorType::kNone},
+      {false, site_settings::PolicyIndicatorType::kRecommended},
+      {false, site_settings::PolicyIndicatorType::kNone}}},
+    {PrefSetting::kRecommendedOff,
+     PrefSetting::kRecommendedOff,
+     PrefSetting::kNotSet,
+     PrefSource::kRecommended,
+     {{false, site_settings::PolicyIndicatorType::kNone},
+      {false, site_settings::PolicyIndicatorType::kNone},
+      {false, site_settings::PolicyIndicatorType::kRecommended}}},
+    {PrefSetting::kNotSet,
+     PrefSetting::kNotSet,
+     PrefSetting::kEnforcedOff,
+     PrefSource::kDevicePolicy,
+     {{true, site_settings::PolicyIndicatorType::kDevicePolicy},
+      {false, site_settings::PolicyIndicatorType::kNone},
+      {false, site_settings::PolicyIndicatorType::kNone}}}};
+
+void SetupTestConditions(TestingProfile* profile,
+                         const RadioManagedStateTestCase& test_case) {
+  sync_preferences::TestingPrefServiceSyncable* prefs =
+      profile->GetTestingPrefService();
+  const std::map<const char*, PrefSetting> pref_to_setting = {
+      {prefs::kSafeBrowsingEnhanced, test_case.safe_browsing_enhanced},
+      {prefs::kSafeBrowsingEnabled, test_case.safe_browsing_enabled},
+      {prefs::kSafeBrowsingScoutReportingEnabled,
+       test_case.safe_browsing_reporting}};
+
+  for (const auto& pref_setting : pref_to_setting) {
+    if (pref_setting.second == PrefSetting::kNotSet) {
+      continue;
+    }
+    auto pref_value = std::make_unique<base::Value>(
+        pref_setting.second == PrefSetting::kRecommendedOn ||
+        pref_setting.second == PrefSetting::kEnforcedOn);
+    if (test_case.preference_source == PrefSource::kExtension) {
+      prefs->SetExtensionPref(pref_setting.first, std::move(pref_value));
+    } else if (test_case.preference_source == PrefSource::kDevicePolicy) {
+      prefs->SetManagedPref(pref_setting.first, std::move(pref_value));
+    } else if (test_case.preference_source == PrefSource::kRecommended) {
+      prefs->SetRecommendedPref(pref_setting.first, std::move(pref_value));
+    }
+  }
+}
+
+TEST_F(SafeBrowsingHandlerTest, GenerateRadioManagedState) {
+  int count = 0;
+  for (const auto& test_case : test_cases) {
+    TestingProfile profile;
+    SCOPED_TRACE(base::StringPrintf("Test case %d", count++));
+    SetupTestConditions(&profile, test_case);
+    AssertRadioManagedStateEqual(
+        handler()->GetSafeBrowsingRadioManagedState(&profile),
+        test_case.expected_result);
+  }
+}
+
+TEST_F(SafeBrowsingHandlerTest, ProvideRadioManagedState) {
+  // Test that the handler correctly wraps the generated result.
+  const std::string kNone = "none";
+  const std::string kDevicePolicy = "devicePolicy";
+  const std::string kCallbackId = "callback";
+  const std::vector<std::string> kRadioNames = {"enhanced", "standard",
+                                                "disabled"};
+
+  // Check that the default radio state is handled correctly.
+  base::ListValue get_args;
+  get_args.AppendString(kCallbackId);
+  handler()->HandleGetSafeBrowsingRadioManagedState(&get_args);
+  {
+    const content::TestWebUI::CallData& data = *web_ui()->call_data().back();
+    EXPECT_EQ("cr.webUIResponse", data.function_name());
+    EXPECT_EQ(kCallbackId, data.arg1()->GetString());
+    ASSERT_TRUE(data.arg2()->GetBool());
+    for (const auto& control_name : kRadioNames) {
+      auto* control_state = data.arg3()->FindPath(control_name);
+      ASSERT_FALSE(control_state->FindKey("disabled")->GetBool());
+      ASSERT_EQ(kNone, control_state->FindKey("indicator")->GetString());
+    }
+  }
+
+  // Create a fully managed state and check it is returned correctly.
+  sync_preferences::TestingPrefServiceSyncable* pref_service =
+      profile()->GetTestingPrefService();
+  pref_service->SetManagedPref(prefs::kSafeBrowsingEnhanced,
+                               std::make_unique<base::Value>(true));
+  pref_service->SetManagedPref(prefs::kSafeBrowsingEnabled,
+                               std::make_unique<base::Value>(true));
+
+  handler()->HandleGetSafeBrowsingRadioManagedState(&get_args);
+  {
+    const content::TestWebUI::CallData& data = *web_ui()->call_data().back();
+    EXPECT_EQ("cr.webUIResponse", data.function_name());
+    EXPECT_EQ(kCallbackId, data.arg1()->GetString());
+    ASSERT_TRUE(data.arg2()->GetBool());
+    for (const auto& control_name : kRadioNames) {
+      auto* control_state = data.arg3()->FindPath(control_name);
+      ASSERT_TRUE(control_state->FindKey("disabled")->GetBool());
+      ASSERT_EQ(kDevicePolicy,
+                control_state->FindKey("indicator")->GetString());
+    }
+  }
+}
+
+}  // namespace settings

chrome/browser/ui/webui/settings/settings_ui.cc

@@ -43,6 +43,7 @@
 #include "chrome/browser/ui/webui/settings/profile_info_handler.h"
 #include "chrome/browser/ui/webui/settings/protocol_handlers_handler.h"
 #include "chrome/browser/ui/webui/settings/reset_settings_handler.h"
+#include "chrome/browser/ui/webui/settings/safe_browsing_handler.h"
 #include "chrome/browser/ui/webui/settings/safety_check_handler.h"
 #include "chrome/browser/ui/webui/settings/search_engines_handler.h"
 #include "chrome/browser/ui/webui/settings/settings_clear_browsing_data_handler.h"
@@ -205,6 +206,7 @@ SettingsUI::SettingsUI(content::WebUI* web_ui)
   AddSettingsPageUIHandler(std::make_unique<PeopleHandler>(profile));
   AddSettingsPageUIHandler(std::make_unique<ProfileInfoHandler>(profile));
   AddSettingsPageUIHandler(std::make_unique<ProtocolHandlersHandler>());
+  AddSettingsPageUIHandler(std::make_unique<SafeBrowsingHandler>(profile));
   AddSettingsPageUIHandler(std::make_unique<SearchEnginesHandler>(profile));
   AddSettingsPageUIHandler(std::make_unique<SecureDnsHandler>());
   AddSettingsPageUIHandler(std::make_unique<SiteSettingsHandler>(

chrome/browser/ui/webui/settings/site_settings_handler.cc

@@ -347,15 +347,6 @@ int GetNumCookieExceptionsOfTypes(HostContentSettingsMap* map,
       });
 }
 
-base::Value GetValueForManagedState(const site_settings::ManagedState& state) {
-  base::Value value(base::Value::Type::DICTIONARY);
-  value.SetKey(site_settings::kDisabled, base::Value(state.disabled));
-  value.SetKey(
-      site_settings::kPolicyIndicator,
-      base::Value(site_settings::PolicyIndicatorTypeToString(state.indicator)));
-  return value;
-}
-
 std::string GetCookieSettingDescription(Profile* profile) {
   HostContentSettingsMap* map =
       HostContentSettingsMapFactory::GetForProfile(profile);
@@ -835,17 +826,21 @@ void SiteSettingsHandler::HandleGetCookieControlsManagedState(
   auto managed_states = site_settings::GetCookieControlsManagedState(profile_);
 
   base::Value result(base::Value::Type::DICTIONARY);
-  result.SetKey(site_settings::kAllowAll,
-                GetValueForManagedState(managed_states.allow_all));
   result.SetKey(
-      site_settings::kBlockThirdPartyIncognito,
-      GetValueForManagedState(managed_states.block_third_party_incognito));
-  result.SetKey(site_settings::kBlockThirdParty,
-                GetValueForManagedState(managed_states.block_third_party));
-  result.SetKey(site_settings::kBlockAll,
-                GetValueForManagedState(managed_states.block_all));
-  result.SetKey(site_settings::kSessionOnly,
-                GetValueForManagedState(managed_states.session_only));
+      site_settings::kAllowAll,
+      site_settings::GetValueForManagedState(managed_states.allow_all));
+  result.SetKey(site_settings::kBlockThirdPartyIncognito,
+                site_settings::GetValueForManagedState(
+                    managed_states.block_third_party_incognito));
+  result.SetKey(
+      site_settings::kBlockThirdParty,
+      site_settings::GetValueForManagedState(managed_states.block_third_party));
+  result.SetKey(
+      site_settings::kBlockAll,
+      site_settings::GetValueForManagedState(managed_states.block_all));
+  result.SetKey(
+      site_settings::kSessionOnly,
+      site_settings::GetValueForManagedState(managed_states.session_only));
 
   ResolveJavascriptCallback(base::Value(callback_id), result);
 }

chrome/browser/ui/webui/site_settings_helper.cc

@@ -358,26 +358,6 @@ PolicyIndicatorType GetPolicyIndicatorFromSettingSource(
   }
 }
 
-PolicyIndicatorType GetPolicyIndicatorFromPref(
-    const PrefService::Preference* pref) {
-  if (!pref) {
-    return PolicyIndicatorType::kNone;
-  }
-  if (pref->IsExtensionControlled()) {
-    return PolicyIndicatorType::kExtension;
-  }
-  if (pref->IsManagedByCustodian()) {
-    return PolicyIndicatorType::kParent;
-  }
-  if (pref->IsManaged()) {
-    return PolicyIndicatorType::kDevicePolicy;
-  }
-  if (pref->GetRecommendedValue()) {
-    return PolicyIndicatorType::kRecommended;
-  }
-  return PolicyIndicatorType::kNone;
-}
-
 }  // namespace
 
 bool HasRegisteredGroupName(ContentSettingsType type) {
@@ -431,6 +411,15 @@ std::string SiteSettingSourceToString(const SiteSettingSource source) {
   return kSiteSettingSourceStringMapping[static_cast<int>(source)].source_str;
 }
 
+base::Value GetValueForManagedState(const site_settings::ManagedState& state) {
+  base::Value value(base::Value::Type::DICTIONARY);
+  value.SetKey(site_settings::kDisabled, base::Value(state.disabled));
+  value.SetKey(
+      site_settings::kPolicyIndicator,
+      base::Value(site_settings::PolicyIndicatorTypeToString(state.indicator)));
+  return value;
+}
+
 // Add an "Allow"-entry to the list of |exceptions| for a |url_pattern| from
 // the web extent of a hosted |app|.
 void AddExceptionForHostedApp(const std::string& url_pattern,
@@ -992,4 +981,24 @@ std::string PolicyIndicatorTypeToString(const PolicyIndicatorType type) {
       .indicator_str;
 }
 
+PolicyIndicatorType GetPolicyIndicatorFromPref(
+    const PrefService::Preference* pref) {
+  if (!pref) {
+    return PolicyIndicatorType::kNone;
+  }
+  if (pref->IsExtensionControlled()) {
+    return PolicyIndicatorType::kExtension;
+  }
+  if (pref->IsManagedByCustodian()) {
+    return PolicyIndicatorType::kParent;
+  }
+  if (pref->IsManaged()) {
+    return PolicyIndicatorType::kDevicePolicy;
+  }
+  if (pref->GetRecommendedValue()) {
+    return PolicyIndicatorType::kRecommended;
+  }
+  return PolicyIndicatorType::kNone;
+}
+
 }  // namespace site_settings

chrome/browser/ui/webui/site_settings_helper.h

@@ -17,6 +17,7 @@
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/content_settings/core/common/content_settings_types.h"
+#include "components/prefs/pref_service.h"
 #include "extensions/common/extension.h"
 
 class HostContentSettingsMap;
@@ -116,9 +117,6 @@ struct CookieControlsManagedState {
   ManagedState session_only;
 };
 
-// Concerts a PolicyIndicatorType to its string identifier.
-std::string PolicyIndicatorTypeToString(const PolicyIndicatorType type);
-
 // Returns whether a group name has been registered for the given type.
 bool HasRegisteredGroupName(ContentSettingsType type);
 
@@ -133,6 +131,9 @@ std::vector<ContentSettingsType> ContentSettingsTypesFromGroupNames(
 // Converts a SiteSettingSource to its string identifier.
 std::string SiteSettingSourceToString(const SiteSettingSource source);
 
+// Converts a ManagedState to a base::Value suitable for sending to JavaScript.
+base::Value GetValueForManagedState(const ManagedState& state);
+
 // Helper function to construct a dictionary for an exception.
 std::unique_ptr<base::DictionaryValue> GetExceptionForPage(
     const ContentSettingsPattern& pattern,
@@ -230,6 +231,13 @@ base::Value GetChooserExceptionListFromProfile(
 // Returns the cookie controls manage state for a given profile.
 CookieControlsManagedState GetCookieControlsManagedState(Profile* profile);
 
+// Concerts a PolicyIndicatorType to its string identifier.
+std::string PolicyIndicatorTypeToString(const PolicyIndicatorType type);
+
+// Returns the appropriate indicator for the source of a preference.
+PolicyIndicatorType GetPolicyIndicatorFromPref(
+    const PrefService::Preference* pref);
+
 }  // namespace site_settings
 
 #endif  // CHROME_BROWSER_UI_WEBUI_SITE_SETTINGS_HELPER_H_

chrome/test/BUILD.gn

@@ -4142,6 +4142,7 @@ test("unit_tests") {
       "../browser/ui/webui/settings/people_handler_unittest.cc",
       "../browser/ui/webui/settings/profile_info_handler_unittest.cc",
       "../browser/ui/webui/settings/reset_settings_handler_unittest.cc",
+      "../browser/ui/webui/settings/safe_browsing_handler_unittest.cc",
       "../browser/ui/webui/settings/safety_check_handler_unittest.cc",
       "../browser/ui/webui/settings/settings_cookies_view_handler_unittest.cc",
       "../browser/ui/webui/settings/settings_manage_profile_handler_unittest.cc",