Show a different banner in chrome://settings for extension-controlled settings.

chrome/browser/ui/webui/options/core_options_handler.cc

 // Copyright (c) 2011 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/options/core_options_handler.h"
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/content_notification_types.h"
 #include "content/common/notification_details.h"
 #include "googleurl/src/gurl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
+namespace {
+
+DictionaryValue* CreateValueForPref(const PrefService::Preference* pref) {
+  DictionaryValue* dict = new DictionaryValue;
+  dict->Set("value", pref->GetValue()->DeepCopy());
+  if (pref->IsManaged()) {
+    dict->SetString("controlledBy", "policy");
+  } else if (pref->IsExtensionControlled()) {
+    dict->SetString("controlledBy", "extension");
+  }
+  dict->SetBoolean("disabled", !pref->IsUserModifiable());
+  return dict;
+}
+
+}  // namespace
+
 CoreOptionsHandler::CoreOptionsHandler()
     : handlers_host_(NULL) {
 }
 
 CoreOptionsHandler::~CoreOptionsHandler() {}
 
 void CoreOptionsHandler::Initialize() {
   clear_plugin_lso_data_enabled_.Init(prefs::kClearPluginLSODataEnabled,
                                       g_browser_process->local_state(),
                                       this);
   UpdateClearPluginLSOData();
 }
 
 void CoreOptionsHandler::GetLocalizedValues(
     DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
   // Main
   localized_strings->SetString("title",
       l10n_util::GetStringUTF16(IDS_SETTINGS_TITLE));
 
   // Managed prefs
-  localized_strings->SetString("managedPrefsBannerText",
-      l10n_util::GetStringUTF16(IDS_OPTIONS_MANAGED_PREFS));
+  localized_strings->SetString("policyManagedPrefsBannerText",
+      l10n_util::GetStringUTF16(IDS_OPTIONS_POLICY_MANAGED_PREFS));
+  localized_strings->SetString("extensionManagedPrefsBannerText",
+      l10n_util::GetStringUTF16(IDS_OPTIONS_EXTENSION_MANAGED_PREFS));
+  localized_strings->SetString("policyAndExtensionManagedPrefsBannerText",
+      l10n_util::GetStringUTF16(IDS_OPTIONS_POLICY_EXTENSION_MANAGED_PREFS));
 
   // Search
   RegisterTitle(localized_strings, "searchPage", IDS_OPTIONS_SEARCH_PAGE_TITLE);
   localized_strings->SetString("searchPlaceholder",
       l10n_util::GetStringUTF16(IDS_OPTIONS_SEARCH_PLACEHOLDER));
   localized_strings->SetString("searchPageNoMatches",
       l10n_util::GetStringUTF16(IDS_OPTIONS_SEARCH_PAGE_NO_MATCHES));
   localized_strings->SetString("searchPageHelpLabel",
       l10n_util::GetStringUTF16(IDS_OPTIONS_SEARCH_PAGE_HELP_LABEL));
   localized_strings->SetString("searchPageHelpTitle",
@@ skipping 66 matching lines @@
 void CoreOptionsHandler::HandleInitialize(const ListValue* args) {
   DCHECK(handlers_host_);
   handlers_host_->InitializeHandlers();
 }
 
 Value* CoreOptionsHandler::FetchPref(const std::string& pref_name) {
   PrefService* pref_service = web_ui_->GetProfile()->GetPrefs();
 
   const PrefService::Preference* pref =
       pref_service->FindPreference(pref_name.c_str());
+  if (!pref)
+    return Value::CreateNullValue();
 
-  Value* return_value;
-  if (pref) {
-    DictionaryValue* dict = new DictionaryValue;
-    dict->Set("value", pref->GetValue()->DeepCopy());
-    dict->SetBoolean("managed", pref->IsManaged());
-    dict->SetBoolean("extensionControlled", pref->IsExtensionControlled());
-    dict->SetBoolean("disabled", !pref->IsUserModifiable());
-    return_value = dict;
-  } else {
-    return_value = Value::CreateNullValue();
-  }
-  return return_value;
+  return CreateValueForPref(pref);
 }
 
 void CoreOptionsHandler::ObservePref(const std::string& pref_name) {
   registrar_.Add(pref_name.c_str(), this);
 }
 
 void CoreOptionsHandler::SetPref(const std::string& pref_name,
                                  const Value* value,
                                  const std::string& metric) {
   PrefService* pref_service = web_ui_->GetProfile()->GetPrefs();
@@ skipping 200 matching lines @@
 void CoreOptionsHandler::NotifyPrefChanged(const std::string* pref_name) {
   if (*pref_name == prefs::kClearPluginLSODataEnabled) {
     // This preference is stored in Local State, not in the user preferences.
     UpdateClearPluginLSOData();
     return;
   }
 
   PrefService* pref_service = web_ui_->GetProfile()->GetPrefs();
   const PrefService::Preference* pref =
       pref_service->FindPreference(pref_name->c_str());
-  if (pref) {
-    for (PreferenceCallbackMap::const_iterator iter =
-        pref_callback_map_.find(*pref_name);
-        iter != pref_callback_map_.end(); ++iter) {
-      const std::wstring& callback_function = iter->second;
-      ListValue result_value;
-      result_value.Append(Value::CreateStringValue(pref_name->c_str()));
+  if (!pref)
+    return;
 
-      DictionaryValue* dict = new DictionaryValue;
-      dict->Set("value", pref->GetValue()->DeepCopy());
-      dict->SetBoolean("managed", pref->IsManaged());
-      dict->SetBoolean("extensionControlled", pref->IsExtensionControlled());
-      dict->SetBoolean("disabled", !pref->IsUserModifiable());
-      result_value.Append(dict);
+  for (PreferenceCallbackMap::const_iterator iter =
+      pref_callback_map_.find(*pref_name);
+      iter != pref_callback_map_.end(); ++iter) {
+    const std::wstring& callback_function = iter->second;
+    ListValue result_value;
+    result_value.Append(Value::CreateStringValue(pref_name->c_str()));
 
-      web_ui_->CallJavascriptFunction(WideToASCII(callback_function),
-                                      result_value);
-    }
+    result_value.Append(CreateValueForPref(pref));
+
+    web_ui_->CallJavascriptFunction(WideToASCII(callback_function),
+                                    result_value);
   }
 }