Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

chrome/browser/ui/webui/options/content_settings_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/content_settings_handler.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 744 matching lines @@
   UpdateAllExceptionsViewsFromModel();
   UpdateAllChooserExceptionsViewsFromModel();
   UpdateProtectedContentExceptionsButton();
 
   // Fullscreen and mouselock settings are ignored, but still stored. Always
   // show the per-site settings (to give users the ability to view and delete
   // exceptions), but hide the global settings.
   // TODO(mgiuca): Remove this function and the global setting UI
   // (https://crbug.com/610900). Then, delete all the per-site data and remove
   // this content setting entirely (https://crbug.com/591896).
-  web_ui()->CallJavascriptFunction("ContentSettings.setExclusiveAccessVisible",
-                                   base::FundamentalValue(true),
-                                   base::FundamentalValue(false));
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "ContentSettings.setExclusiveAccessVisible", base::FundamentalValue(true),
+      base::FundamentalValue(false));
 }
 
 void ContentSettingsHandler::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     std::string resource_identifier) {
   const ContentSettingsDetails details(
       primary_pattern, secondary_pattern, content_type, resource_identifier);
   // TODO(estade): we pretend update_all() is always true.
@@ skipping 10 matching lines @@
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       HostContentSettingsMap* settings_map =
           HostContentSettingsMapFactory::GetForProfile(profile);
       if (profile->IsOffTheRecord() &&
           observer_.IsObserving(settings_map)) {
-        web_ui()->CallJavascriptFunction(
+        web_ui()->CallJavascriptFunctionUnsafe(
             "ContentSettingsExceptionsArea.OTRProfileDestroyed");
         observer_.Remove(settings_map);
       }
       break;
     }
 
     case chrome::NOTIFICATION_PROFILE_CREATED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       if (profile->IsOffTheRecord()) {
         UpdateAllOTRExceptionsViewsFromModel();
@@ skipping 61 matching lines @@
 
   std::string setting_string =
       content_settings::ContentSettingToString(default_setting);
   DCHECK(!setting_string.empty());
 
   filter_settings.SetString(ContentSettingsTypeToGroupName(type) + ".value",
                             setting_string);
   filter_settings.SetString(
       ContentSettingsTypeToGroupName(type) + ".managedBy", provider_id);
 
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "ContentSettings.setContentFilterSettingsValue", filter_settings);
 }
 
 void ContentSettingsHandler::UpdateMediaSettingsFromPrefs(
     ContentSettingsType type) {
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
   std::string policy_pref = (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
       ? prefs::kAudioCaptureAllowed
       : prefs::kVideoCaptureAllowed;
 
   settings.policy_disable = !prefs->GetBoolean(policy_pref) &&
       prefs->IsManagedPreference(policy_pref);
   settings.default_setting =
       GetContentSettingsMap()->GetDefaultContentSetting(type, NULL);
   settings.default_setting_initialized = true;
 
   UpdateFlashMediaLinksVisibility(type);
   UpdateMediaDeviceDropdownVisibility(type);
 }
 
 void ContentSettingsHandler::UpdateHandlersEnabledRadios() {
   base::FundamentalValue handlers_enabled(
       GetProtocolHandlerRegistry()->enabled());
 
-  web_ui()->CallJavascriptFunction(
-      "ContentSettings.updateHandlersEnabledRadios",
-      handlers_enabled);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "ContentSettings.updateHandlersEnabledRadios", handlers_enabled);
 }
 
 void ContentSettingsHandler::UpdateAllExceptionsViewsFromModel() {
   const ExceptionsInfoMap& exceptions_info_map = GetExceptionsInfoMap();
   for (const auto& exceptions_info_pair : exceptions_info_map)
     UpdateExceptionsViewFromModel(exceptions_info_pair.first);
 
   // Zoom levels are not actually a content type so we need to handle them
   // separately.
   UpdateZoomLevelsExceptionsView();
@@ skipping 83 matching lines @@
       if (j == parent)
         continue;
 
       exceptions.Append(GetGeolocationExceptionForPage(
           primary_pattern, j->first, j->second));
     }
   }
 
   base::StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_GEOLOCATION));
-  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
-                                   type_string, exceptions);
+  web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
+                                         type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 }
 
 void ContentSettingsHandler::UpdateNotificationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui());
   ContentSettingsForOneType settings;
   DesktopNotificationProfileUtil::GetNotificationsSettings(profile, &settings);
@@ skipping 18 matching lines @@
 
     exceptions.Append(
         GetNotificationExceptionForPage(i->primary_pattern,
                                         i->secondary_pattern,
                                         i->setting,
                                         i->source));
   }
 
   base::StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
-  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
-                                   type_string, exceptions);
+  web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
+                                         type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
 void ContentSettingsHandler::CompareMediaExceptionsWithFlash(
     ContentSettingsType type) {
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
 
@@ skipping 47 matching lines @@
 void ContentSettingsHandler::UpdateAllOTRChooserExceptionsViewsFromModel() {
   for (const ChooserTypeNameEntry& chooser_type : kChooserTypeGroupNames)
     UpdateOTRChooserExceptionsViewFromModel(chooser_type);
 }
 
 void ContentSettingsHandler::UpdateChooserExceptionsViewFromModel(
     const ChooserTypeNameEntry& chooser_type) {
   base::ListValue exceptions;
   GetChooserExceptionsFromProfile(false, chooser_type, &exceptions);
   base::StringValue type_string(chooser_type.name);
-  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
-                                   exceptions);
+  web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
+                                         type_string, exceptions);
 
   UpdateOTRChooserExceptionsViewFromModel(chooser_type);
 }
 
 void ContentSettingsHandler::UpdateOTRChooserExceptionsViewFromModel(
     const ChooserTypeNameEntry& chooser_type) {
   if (!Profile::FromWebUI(web_ui())->HasOffTheRecordProfile())
     return;
 
   base::ListValue exceptions;
   GetChooserExceptionsFromProfile(true, chooser_type, &exceptions);
   base::StringValue type_string(chooser_type.name);
-  web_ui()->CallJavascriptFunction("ContentSettings.setOTRExceptions",
-                                   type_string, exceptions);
+  web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setOTRExceptions",
+                                         type_string, exceptions);
 }
 
 void ContentSettingsHandler::UpdateZoomLevelsExceptionsView() {
   base::ListValue zoom_levels_exceptions;
 
   content::HostZoomMap* host_zoom_map =
       content::HostZoomMap::GetDefaultForBrowserContext(
           GetBrowserContext(web_ui()));
   content::HostZoomMap::ZoomLevelVector zoom_levels(
       host_zoom_map->GetAllZoomLevels());
@@ skipping 46 matching lines @@
         kZoom,
         l10n_util::GetStringFUTF16(IDS_ZOOM_PERCENT,
                                    base::IntToString16(zoom_percent)));
     exception->SetString(
         site_settings::kSource, site_settings::kPreferencesSource);
     // Append the new entry to the list and map.
     zoom_levels_exceptions.Append(exception.release());
   }
 
   base::StringValue type_string(kZoomContentType);
-  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions",
-                                   type_string, zoom_levels_exceptions);
+  web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
+                                         type_string, zoom_levels_exceptions);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   base::ListValue exceptions;
   site_settings::GetExceptionsFromHostContentSettingsMap(
       GetContentSettingsMap(), type, web_ui(), &exceptions);
   base::StringValue type_string(ContentSettingsTypeToGroupName(type));
-  web_ui()->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
-                                   exceptions);
+  web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setExceptions",
+                                         type_string, exceptions);
 
   UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
 
   // TODO(koz): The default for fullscreen is always 'ask'.
   // http://crbug.com/104683
   if (type == CONTENT_SETTINGS_TYPE_FULLSCREEN)
     return;
 
 #if defined(OS_CHROMEOS)
   // Also the default for protected contents is managed in another place.
   if (type == CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER)
     return;
 #endif
 
   // The default may also have changed (we won't get a separate notification).
   // If it hasn't changed, this call will be harmless.
   UpdateSettingDefaultFromModel(type);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromOTRHostContentSettingsMap(
     ContentSettingsType type) {
   const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap();
   if (!otr_settings_map)
     return;
   base::ListValue exceptions;
   site_settings::GetExceptionsFromHostContentSettingsMap(
       otr_settings_map, type, web_ui(), &exceptions);
   base::StringValue type_string(ContentSettingsTypeToGroupName(type));
-  web_ui()->CallJavascriptFunction("ContentSettings.setOTRExceptions",
-                                   type_string, exceptions);
+  web_ui()->CallJavascriptFunctionUnsafe("ContentSettings.setOTRExceptions",
+                                         type_string, exceptions);
 }
 
 void ContentSettingsHandler::GetChooserExceptionsFromProfile(
     bool incognito,
     const ChooserTypeNameEntry& chooser_type,
     base::ListValue* exceptions) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (incognito) {
     if (profile->HasOffTheRecordProfile())
       profile = profile->GetOffTheRecordProfile();
@@ skipping 286 matching lines @@
   std::string type_string;
   CHECK(args->GetString(0, &type_string));
   std::string mode_string;
   CHECK(args->GetString(1, &mode_string));
   std::string pattern_string;
   CHECK(args->GetString(2, &pattern_string));
 
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString(pattern_string);
 
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "ContentSettings.patternValidityCheckComplete",
-      base::StringValue(type_string),
-      base::StringValue(mode_string),
+      base::StringValue(type_string), base::StringValue(mode_string),
       base::StringValue(pattern_string),
       base::FundamentalValue(pattern.IsValid()));
 }
 
 // static
 std::string ContentSettingsHandler::ContentSettingsTypeToGroupName(
     ContentSettingsType type) {
   for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
     if (type == kContentSettingsTypeGroupNames[i].type)
       return kContentSettingsTypeGroupNames[i].name;
@@ skipping 56 matching lines @@
 void ContentSettingsHandler::ShowFlashMediaLink(
     LinkType link_type, ContentSettingsType content_type, bool show) {
   MediaSettingsInfo::ForOneType& settings =
       media_settings_->forType(content_type);
 
   bool& show_link = link_type == DEFAULT_SETTING ?
       settings.show_flash_default_link :
       settings.show_flash_exceptions_link;
 
   if (show_link != show) {
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "ContentSettings.showMediaPepperFlashLink",
-        base::StringValue(
-            link_type == DEFAULT_SETTING ? "default" : "exceptions"),
-        base::StringValue(
-            content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC
-                ? "mic"
-                : "camera"),
+        base::StringValue(link_type == DEFAULT_SETTING ? "default"
+                                                       : "exceptions"),
+        base::StringValue(content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC
+                              ? "mic"
+                              : "camera"),
         base::FundamentalValue(show));
     show_link = show;
   }
 }
 
 void ContentSettingsHandler::UpdateFlashMediaLinksVisibility(
     ContentSettingsType type) {
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
   MediaSettingsInfo::ForFlash& flash_settings = media_settings_->forFlash();
 
@@ skipping 35 matching lines @@
           flash_settings.default_setting,
           flash_settings.exceptions)) {
     ShowFlashMediaLink(EXCEPTIONS, type, true);
   }
 }
 
 void ContentSettingsHandler::UpdateMediaDeviceDropdownVisibility(
     ContentSettingsType type) {
   MediaSettingsInfo::ForOneType& settings = media_settings_->forType(type);
 
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "ContentSettings.setDevicesMenuVisibility",
       base::StringValue(ContentSettingsTypeToGroupName(type)),
       base::FundamentalValue(!settings.policy_disable));
 }
 
 void ContentSettingsHandler::UpdateProtectedContentExceptionsButton() {
 #if defined(OS_CHROMEOS)
   // Guests cannot modify exceptions. UIAccountTweaks will disabled the button.
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
     return;
 #endif
 
   // Exceptions apply only when the feature is enabled.
   PrefService* prefs = user_prefs::UserPrefs::Get(GetBrowserContext(web_ui()));
   bool enable_exceptions = prefs->GetBoolean(prefs::kEnableDRM);
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "ContentSettings.enableProtectedContentExceptions",
       base::FundamentalValue(enable_exceptions));
 }
 
 }  // namespace options