Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

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

 // Copyright (c) 2012 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/browser_options_handler.h"
 
 #include <stddef.h>
 
 #include <set>
 
@@ skipping 1048 matching lines @@
   SetupExtensionControlledIndicators();
 
 #if defined(OS_CHROMEOS)
   SetupAccessibilityFeatures();
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   enable_factory_reset_ = !connector->IsEnterpriseManaged() &&
       !user_manager::UserManager::Get()->IsLoggedInAsGuest() &&
       !user_manager::UserManager::Get()->IsLoggedInAsSupervisedUser();
   if (enable_factory_reset_) {
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "BrowserOptions.enableFactoryResetSection");
   }
 
   Profile* const profile = Profile::FromWebUI(web_ui());
   user_manager::User const* const user =
       chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
 
   OnAccountPictureManagedChanged(
       policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile)
           ->policy_service()
@@ skipping 12 matching lines @@
     OnConsumerManagementStatusChanged();
     consumer_management->AddObserver(this);
   }
 
   if (arc::ArcBridgeService::GetEnabled(
           base::CommandLine::ForCurrentProcess()) &&
       !arc::ArcAuthService::IsOptInVerificationDisabled() &&
       !profile->IsLegacySupervised() && user->HasGaiaAccount() &&
       !user_manager::UserManager::Get()
            ->IsCurrentUserCryptohomeDataEphemeral()) {
-    web_ui()->CallJavascriptFunction("BrowserOptions.showAndroidAppsSection");
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "BrowserOptions.showAndroidAppsSection");
   }
   OnSystemTimezoneAutomaticDetectionPolicyChanged();
 #endif
 }
 
 bool BrowserOptionsHandler::ShouldShowSetDefaultBrowser() {
 #if defined(OS_CHROMEOS)
   // We're always the default browser on ChromeOS.
   return false;
 #else
@@ skipping 77 matching lines @@
                                  l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
 
   base::FundamentalValue is_default(
       status_string_id == IDS_OPTIONS_DEFAULTBROWSER_DEFAULT);
 
   base::FundamentalValue can_be_default(
       !IsDisabledByPolicy(default_browser_policy_) &&
       (status_string_id == IDS_OPTIONS_DEFAULTBROWSER_DEFAULT ||
        status_string_id == IDS_OPTIONS_DEFAULTBROWSER_NOTDEFAULT));
 
-  web_ui()->CallJavascriptFunction(
-      "BrowserOptions.updateDefaultBrowserState",
-      status_string, is_default, can_be_default);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.updateDefaultBrowserState", status_string, is_default,
+      can_be_default);
 }
 #endif  // !defined(OS_CHROMEOS)
 
 void BrowserOptionsHandler::OnTemplateURLServiceChanged() {
   if (!template_url_service_ || !template_url_service_->loaded())
     return;
 
   const TemplateURL* default_url =
       template_url_service_->GetDefaultSearchProvider();
 
   int default_index = -1;
   base::ListValue search_engines;
   TemplateURLService::TemplateURLVector model_urls(
       template_url_service_->GetTemplateURLs());
   for (size_t i = 0; i < model_urls.size(); ++i) {
     if (!model_urls[i]->ShowInDefaultList(
             template_url_service_->search_terms_data()))
       continue;
 
     base::DictionaryValue* entry = new base::DictionaryValue();
     entry->SetString("name", model_urls[i]->short_name());
     entry->SetInteger("index", i);
     search_engines.Append(entry);
     if (model_urls[i] == default_url)
       default_index = i;
   }
 
-  web_ui()->CallJavascriptFunction(
-      "BrowserOptions.updateSearchEngines",
-      search_engines,
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.updateSearchEngines", search_engines,
       base::FundamentalValue(default_index),
       base::FundamentalValue(
           template_url_service_->is_default_search_managed() ||
           template_url_service_->IsExtensionControlledDefaultSearch()));
 
   SetupExtensionControlledIndicators();
 
   HandleRequestHotwordAvailable(nullptr);
   HandleRequestGoogleNowAvailable(nullptr);
 }
@@ skipping 122 matching lines @@
 
     profile_info_list->Append(profile_value);
   }
 
   return profile_info_list;
 }
 
 void BrowserOptionsHandler::SendProfilesInfo() {
   if (!ShouldShowMultiProfilesUserList())
     return;
-  web_ui()->CallJavascriptFunction("BrowserOptions.setProfilesInfo",
-                                   *GetProfilesInfoList());
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.setProfilesInfo",
+                                         *GetProfilesInfoList());
 }
 
 void BrowserOptionsHandler::DeleteProfile(const base::ListValue* args) {
   DCHECK(args);
   const base::Value* file_path_value;
   if (!args->Get(0, &file_path_value)) {
     NOTREACHED();
     return;
   }
 
@@ skipping 11 matching lines @@
 void BrowserOptionsHandler::ObserveThemeChanged() {
   Profile* profile = Profile::FromWebUI(web_ui());
   ThemeService* theme_service = ThemeServiceFactory::GetForProfile(profile);
   bool is_system_theme = false;
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   bool profile_is_supervised = profile->IsSupervised();
   is_system_theme = theme_service->UsingSystemTheme();
   base::FundamentalValue native_theme_enabled(!is_system_theme &&
                                               !profile_is_supervised);
-  web_ui()->CallJavascriptFunction("BrowserOptions.setNativeThemeButtonEnabled",
-                                   native_theme_enabled);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.setNativeThemeButtonEnabled", native_theme_enabled);
 #endif
 
   bool is_classic_theme = !is_system_theme &&
                           theme_service->UsingDefaultTheme();
   base::FundamentalValue enabled(!is_classic_theme);
-  web_ui()->CallJavascriptFunction("BrowserOptions.setThemesResetButtonEnabled",
-                                   enabled);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.setThemesResetButtonEnabled", enabled);
 }
 
 void BrowserOptionsHandler::ThemesReset(const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   content::RecordAction(UserMetricsAction("Options_ThemesReset"));
   ThemeServiceFactory::GetForProfile(profile)->UseDefaultTheme();
 }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 void BrowserOptionsHandler::ThemesSetNative(const base::ListValue* args) {
   content::RecordAction(UserMetricsAction("Options_GtkThemeSet"));
   Profile* profile = Profile::FromWebUI(web_ui());
   ThemeServiceFactory::GetForProfile(profile)->UseSystemTheme();
 }
 #endif
 
 #if defined(OS_CHROMEOS)
 void BrowserOptionsHandler::UpdateAccountPicture() {
   std::string email =
       user_manager::UserManager::Get()->GetLoggedInUser()->email();
   if (!email.empty()) {
-    web_ui()->CallJavascriptFunction("BrowserOptions.updateAccountPicture");
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "BrowserOptions.updateAccountPicture");
     base::StringValue email_value(email);
-    web_ui()->CallJavascriptFunction("BrowserOptions.updateAccountPicture",
-                                     email_value);
-    web_ui()->CallJavascriptFunction(
-        "AccountsOptions.getInstance().updateAccountPicture",
-        email_value);
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "BrowserOptions.updateAccountPicture", email_value);
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "AccountsOptions.getInstance().updateAccountPicture", email_value);
   }
 }
 
 void BrowserOptionsHandler::OnAccountPictureManagedChanged(bool managed) {
-  web_ui()->CallJavascriptFunction("BrowserOptions.setAccountPictureManaged",
-                                   base::FundamentalValue(managed));
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.setAccountPictureManaged",
+      base::FundamentalValue(managed));
 }
 
 void BrowserOptionsHandler::OnWallpaperManagedChanged(bool managed) {
-  web_ui()->CallJavascriptFunction("BrowserOptions.setWallpaperManaged",
-                                   base::FundamentalValue(managed));
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.setWallpaperManaged",
+                                         base::FundamentalValue(managed));
 }
 
 void BrowserOptionsHandler::OnSystemTimezonePolicyChanged() {
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setSystemTimezoneManaged",
       base::FundamentalValue(chromeos::system::HasSystemTimezonePolicy()));
 }
 
 void BrowserOptionsHandler::OnSystemTimezoneAutomaticDetectionPolicyChanged() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableSystemTimezoneAutomaticDetectionPolicy)) {
     return;
   }
 
   PrefService* prefs = g_browser_process->local_state();
   const bool is_managed = prefs->IsManagedPreference(
       prefs::kSystemTimezoneAutomaticDetectionPolicy);
   const int value =
       prefs->GetInteger(prefs::kSystemTimezoneAutomaticDetectionPolicy);
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setSystemTimezoneAutomaticDetectionManaged",
       base::FundamentalValue(is_managed), base::FundamentalValue(value));
 }
 #endif
 
 std::unique_ptr<base::DictionaryValue>
 BrowserOptionsHandler::GetSyncStateDictionary() {
   // The items which are to be written into |sync_status| are also described in
   // chrome/browser/resources/options/browser_options.js in @typedef
   // for SyncStatus. Please update it whenever you add or remove any keys here.
@@ skipping 68 matching lines @@
                                          void* params) {
   content::RecordAction(UserMetricsAction("Options_SetDownloadDirectory"));
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   pref_service->SetFilePath(prefs::kDownloadDefaultDirectory, path);
   pref_service->SetFilePath(prefs::kSaveFileDefaultDirectory, path);
 }
 
 #if defined(OS_CHROMEOS)
 void BrowserOptionsHandler::TouchpadExists(bool exists) {
   base::FundamentalValue val(exists);
-  web_ui()->CallJavascriptFunction("BrowserOptions.showTouchpadControls", val);
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.showTouchpadControls",
+                                         val);
 }
 
 void BrowserOptionsHandler::MouseExists(bool exists) {
   base::FundamentalValue val(exists);
-  web_ui()->CallJavascriptFunction("BrowserOptions.showMouseControls", val);
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.showMouseControls",
+                                         val);
 }
 
 void BrowserOptionsHandler::OnUserImagePolicyChanged(
     const base::Value* previous_policy,
     const base::Value* current_policy) {
   const bool had_policy = previous_policy;
   const bool has_policy = current_policy;
   if (had_policy != has_policy)
     OnAccountPictureManagedChanged(has_policy);
 }
@@ skipping 12 matching lines @@
   UMA_HISTOGRAM_ENUMERATION(
       "Reset.ChromeOS.PowerwashDialogShown",
       chromeos::reset::DIALOG_FROM_OPTIONS,
       chromeos::reset::DIALOG_VIEW_TYPE_SIZE);
 }
 
 void BrowserOptionsHandler::OnConsumerManagementStatusChanged() {
   const std::string& status = g_browser_process->platform_part()->
       browser_policy_connector_chromeos()->GetConsumerManagementService()->
           GetStatusString();
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setConsumerManagementStatus", base::StringValue(status));
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 void BrowserOptionsHandler::UpdateSyncState() {
-  web_ui()->CallJavascriptFunction("BrowserOptions.updateSyncState",
-                                   *GetSyncStateDictionary());
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.updateSyncState",
+                                         *GetSyncStateDictionary());
 
   // A change in sign-in state also affects how hotwording and audio history are
   // displayed. Hide all hotwording and re-display properly.
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAllHotwordSectionsVisible",
       base::FundamentalValue(false));
   HandleRequestHotwordAvailable(nullptr);
 }
 
 void BrowserOptionsHandler::OnSigninAllowedPrefChange() {
   UpdateSyncState();
 }
 
 void BrowserOptionsHandler::HandleAutoOpenButton(const base::ListValue* args) {
@@ skipping 80 matching lines @@
       CURRENT_TAB, ui::PAGE_TRANSITION_LINK, false);
   web_ui()->GetWebContents()->OpenURL(params);
 }
 
 #endif
 
 void BrowserOptionsHandler::SetHotwordAudioHistorySectionVisible(
     const base::string16& audio_history_state,
     bool success, bool logging_enabled) {
   bool visible = logging_enabled && success;
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAudioHistorySectionVisible",
-      base::FundamentalValue(visible),
-      base::StringValue(audio_history_state));
+      base::FundamentalValue(visible), base::StringValue(audio_history_state));
 }
 
 void BrowserOptionsHandler::HandleRequestGoogleNowAvailable(
     const base::ListValue* args) {
   bool is_search_provider_google = false;
   if (template_url_service_ && template_url_service_->loaded()) {
     const TemplateURL* default_url =
         template_url_service_->GetDefaultSearchProvider();
     if (default_url && default_url->HasGoogleBaseURLs(
             template_url_service_->search_terms_data())) {
       is_search_provider_google = true;
     }
   }
 
   std::string group = base::FieldTrialList::FindFullName("GoogleNowExtension");
   bool has_field_trial = !group.empty() && group != "Disabled";
 
   bool should_show = is_search_provider_google && has_field_trial;
-  web_ui()->CallJavascriptFunction(
-      "BrowserOptions.setNowSectionVisible",
-      base::FundamentalValue(should_show));
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.setNowSectionVisible",
+                                         base::FundamentalValue(should_show));
 }
 
 void BrowserOptionsHandler::HandleRequestHotwordAvailable(
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   bool is_search_provider_google = false;
   // The check for default search provider is only valid if the
   // |template_url_service_| has loaded already.
   if (template_url_service_ && template_url_service_->loaded()) {
@@ skipping 10 matching lines @@
       if (hotword_service)
         hotword_service->DisableHotwordPreferences();
     }
   }
 
   // |is_search_provider_google| may be false because |template_url_service_|
   // does not exist yet or because the user selected a different search
   // provider. In either case it does not make sense to show the hotwording
   // options.
   if (!is_search_provider_google) {
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "BrowserOptions.setAllHotwordSectionsVisible",
         base::FundamentalValue(false));
     return;
   }
 
   // Don't need to check the field trial here since |IsHotwordAllowed| also
   // checks it.
   if (HotwordServiceFactory::IsHotwordAllowed(profile)) {
     // Update the current error value.
     HotwordServiceFactory::IsServiceAvailable(profile);
     int error = HotwordServiceFactory::GetCurrentError(profile);
 
     std::string function_name;
     bool always_on = false;
     SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
     bool authenticated = signin && signin->IsAuthenticated();
     if (HotwordServiceFactory::IsAlwaysOnAvailable() && authenticated) {
       function_name = "BrowserOptions.showHotwordAlwaysOnSection";
       always_on = true;
       // Show the retrain link if always-on is enabled.
       if (profile->GetPrefs()->GetBoolean(
               prefs::kHotwordAlwaysOnSearchEnabled)) {
-        web_ui()->CallJavascriptFunction(
+        web_ui()->CallJavascriptFunctionUnsafe(
             "BrowserOptions.setHotwordRetrainLinkVisible",
             base::FundamentalValue(true));
       }
     } else {
       function_name = "BrowserOptions.showHotwordNoDspSection";
     }
 
     // Audio history should be displayed if it's enabled regardless of the
     // hotword error state if the user is signed in. If the user is not signed
     // in, audio history is meaningless. This is only displayed if always-on
@@ skipping 10 matching lines @@
       if (hotword_service) {
         hotword_service->GetAudioHistoryHandler()->GetAudioHistoryEnabled(
             base::Bind(
                 &BrowserOptionsHandler::SetHotwordAudioHistorySectionVisible,
                 weak_ptr_factory_.GetWeakPtr(),
                 audio_history_state));
       }
     }
 
     if (!error) {
-      web_ui()->CallJavascriptFunction(function_name);
+      web_ui()->CallJavascriptFunctionUnsafe(function_name);
     } else {
       base::string16 hotword_help_url =
           base::ASCIIToUTF16(chrome::kHotwordLearnMoreURL);
       base::StringValue error_message(l10n_util::GetStringUTF16(error));
       if (error == IDS_HOTWORD_GENERIC_ERROR_MESSAGE) {
         error_message = base::StringValue(
             l10n_util::GetStringFUTF16(error, hotword_help_url));
       }
-      web_ui()->CallJavascriptFunction(function_name, error_message);
+      web_ui()->CallJavascriptFunctionUnsafe(function_name, error_message);
     }
   }
 }
 
 void BrowserOptionsHandler::HandleLaunchHotwordAudioVerificationApp(
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   bool retrain = false;
   bool success = args->GetBoolean(0, &retrain);
@@ skipping 61 matching lines @@
 
   // Perform sign out. Current chrome process will then terminate, new one will
   // be launched (as if it was a restart).
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 void BrowserOptionsHandler::SetupAccessibilityFeatures() {
   PrefService* pref_service = g_browser_process->local_state();
   base::FundamentalValue virtual_keyboard_enabled(
       pref_service->GetBoolean(prefs::kAccessibilityVirtualKeyboardEnabled));
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setVirtualKeyboardCheckboxState",
       virtual_keyboard_enabled);
 }
 #endif
 
 void BrowserOptionsHandler::SetupMetricsReportingSettingVisibility() {
 #if defined(GOOGLE_CHROME_BUILD)
   // Don't show the reporting setting if we are in the guest mode.
   if (Profile::FromWebUI(web_ui())->IsGuestSession()) {
     base::FundamentalValue visible(false);
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "BrowserOptions.setMetricsReportingSettingVisibility", visible);
   }
 #endif
 }
 
 void BrowserOptionsHandler::SetupNetworkPredictionControl() {
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
 
   base::DictionaryValue dict;
   dict.SetInteger("value",
                   pref_service->GetInteger(prefs::kNetworkPredictionOptions));
   dict.SetBoolean("disabled",
                   !pref_service->IsUserModifiablePreference(
                       prefs::kNetworkPredictionOptions));
 
-  web_ui()->CallJavascriptFunction("BrowserOptions.setNetworkPredictionValue",
-                                   dict);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.setNetworkPredictionValue", dict);
 }
 
 void BrowserOptionsHandler::SetupFontSizeSelector() {
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   const PrefService::Preference* default_font_size =
       pref_service->FindPreference(prefs::kWebKitDefaultFontSize);
   const PrefService::Preference* default_fixed_font_size =
       pref_service->FindPreference(prefs::kWebKitDefaultFixedFontSize);
 
   base::DictionaryValue dict;
@@ skipping 11 matching lines @@
   // This is a poor man's version of CoreOptionsHandler::CreateValueForPref,
   // adapted to consider two prefs. It may be better to refactor
   // CreateValueForPref so it can be called from here.
   if (default_font_size->IsManaged() || default_fixed_font_size->IsManaged()) {
       dict.SetString("controlledBy", "policy");
   } else if (default_font_size->IsExtensionControlled() ||
              default_fixed_font_size->IsExtensionControlled()) {
       dict.SetString("controlledBy", "extension");
   }
 
-  web_ui()->CallJavascriptFunction("BrowserOptions.setFontSize", dict);
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.setFontSize", dict);
 }
 
 void BrowserOptionsHandler::SetupPageZoomSelector() {
   double default_zoom_level =
       content::HostZoomMap::GetDefaultForBrowserContext(
           Profile::FromWebUI(web_ui()))->GetDefaultZoomLevel();
   double default_zoom_factor =
       content::ZoomLevelToZoomFactor(default_zoom_level);
 
   // Generate a vector of zoom factors from an array of known presets along with
@@ skipping 14 matching lines @@
     double factor = *i;
     int percent = static_cast<int>(factor * 100 + 0.5);
     option->Append(new base::StringValue(
         l10n_util::GetStringFUTF16Int(IDS_ZOOM_PERCENT, percent)));
     option->Append(new base::FundamentalValue(factor));
     bool selected = content::ZoomValuesEqual(factor, default_zoom_factor);
     option->Append(new base::FundamentalValue(selected));
     zoom_factors_value.Append(option);
   }
 
-  web_ui()->CallJavascriptFunction(
-      "BrowserOptions.setupPageZoomSelector", zoom_factors_value);
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.setupPageZoomSelector",
+                                         zoom_factors_value);
 }
 
 void BrowserOptionsHandler::SetupAutoOpenFileTypes() {
   // Set the hidden state for the AutoOpenFileTypesResetToDefault button.
   // We show the button if the user has any auto-open file types registered.
   DownloadManager* manager = BrowserContext::GetDownloadManager(
       web_ui()->GetWebContents()->GetBrowserContext());
   bool display = manager &&
       DownloadPrefs::FromDownloadManager(manager)->IsAutoOpenUsed();
   base::FundamentalValue value(display);
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAutoOpenFileTypesDisplayed", value);
 }
 
 void BrowserOptionsHandler::SetupProxySettingsSection() {
 #if !defined(OS_CHROMEOS)
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   const PrefService::Preference* proxy_config =
       pref_service->FindPreference(proxy_config::prefs::kProxy);
   bool is_extension_controlled = (proxy_config &&
                                   proxy_config->IsExtensionControlled());
 
   base::FundamentalValue disabled(proxy_config &&
                                   !proxy_config->IsUserModifiable());
   base::FundamentalValue extension_controlled(is_extension_controlled);
-  web_ui()->CallJavascriptFunction("BrowserOptions.setupProxySettingsButton",
-                                   disabled, extension_controlled);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.setupProxySettingsButton", disabled,
+      extension_controlled);
 
 #if defined(OS_WIN)
   SetupExtensionControlledIndicators();
 #endif  // defined(OS_WIN)
 
 #endif  // !defined(OS_CHROMEOS)
 }
 
 void BrowserOptionsHandler::SetupManagingSupervisedUsers() {
   bool has_users = !Profile::FromWebUI(web_ui())->
       GetPrefs()->GetDictionary(prefs::kSupervisedUsers)->empty();
   base::FundamentalValue has_users_value(has_users);
-  web_ui()->CallJavascriptFunction(
-      "BrowserOptions.updateManagesSupervisedUsers",
-      has_users_value);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.updateManagesSupervisedUsers", has_users_value);
 }
 
 void BrowserOptionsHandler::SetupEasyUnlock() {
   base::FundamentalValue is_enabled(
       EasyUnlockService::Get(Profile::FromWebUI(web_ui()))->IsEnabled());
-  web_ui()->CallJavascriptFunction(
-      "BrowserOptions.updateEasyUnlock",
-      is_enabled);
+  web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.updateEasyUnlock",
+                                         is_enabled);
 }
 
 void BrowserOptionsHandler::SetupExtensionControlledIndicators() {
 #if defined(OS_WIN)
   base::DictionaryValue extension_controlled;
 
   // Check if an extension is overriding the Search Engine.
   const extensions::Extension* extension =
       extensions::GetExtensionOverridingSearchEngine(
           Profile::FromWebUI(web_ui()));
@@ skipping 24 matching lines @@
     extension = registry->GetExtensionById(ntp_url.host(),
                                            ExtensionRegistry::ENABLED);
   }
   AppendExtensionData("newTabPage", extension, &extension_controlled);
 
   // Check if an extension is overwriting the proxy setting.
   extension = extensions::GetExtensionOverridingProxy(
       Profile::FromWebUI(web_ui()));
   AppendExtensionData("proxy", extension, &extension_controlled);
 
-  web_ui()->CallJavascriptFunction("BrowserOptions.toggleExtensionIndicators",
-                                   extension_controlled);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "BrowserOptions.toggleExtensionIndicators", extension_controlled);
 #endif  // defined(OS_WIN)
 }
 
 void BrowserOptionsHandler::SetupMetricsReportingCheckbox() {
 // As the metrics and crash reporting checkbox only exists for official builds
 // it doesn't need to be set up for non-official builds.
 #if defined(GOOGLE_CHROME_BUILD)
   bool checked =
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled();
   bool policy_managed = IsMetricsReportingPolicyManaged();
@@ skipping 36 matching lines @@
 }
 
 void BrowserOptionsHandler::NotifyUIOfMetricsReportingChange(bool enabled) {
   SetMetricsReportingCheckbox(enabled, IsMetricsReportingPolicyManaged(),
                               !IsDeviceOwnerProfile());
 }
 
 void BrowserOptionsHandler::SetMetricsReportingCheckbox(bool checked,
                                                         bool policy_managed,
                                                         bool owner_managed) {
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setMetricsReportingCheckboxState",
       base::FundamentalValue(checked), base::FundamentalValue(policy_managed),
       base::FundamentalValue(owner_managed));
 }
 
 void BrowserOptionsHandler::OnPolicyUpdated(const policy::PolicyNamespace& ns,
                                             const policy::PolicyMap& previous,
                                             const policy::PolicyMap& current) {
   std::set<std::string> different_keys;
   current.GetDifferingKeys(previous, &different_keys);
   if (ContainsKey(different_keys, policy::key::kMetricsReportingEnabled))
     SetupMetricsReportingCheckbox();
 }
 
 bool BrowserOptionsHandler::IsDeviceOwnerProfile() {
 #if defined(OS_CHROMEOS)
   return chromeos::ProfileHelper::IsOwnerProfile(Profile::FromWebUI(web_ui()));
 #else
   return true;
 #endif
 }
 
 }  // namespace options