Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

chrome/browser/ui/webui/ntp/app_launcher_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/ntp/app_launcher_handler.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 293 matching lines @@
             extension_service_->GetInstalledExtension(*id);
         if (!extension) {
           // Extension could still be downloading or installing.
           return;
         }
 
         base::DictionaryValue app_info;
         CreateAppInfo(extension,
                       extension_service_,
                       &app_info);
-        web_ui()->CallJavascriptFunction("ntp.appMoved", app_info);
+        web_ui()->CallJavascriptFunctionUnsafe("ntp.appMoved", app_info);
       } else {
         HandleGetApps(NULL);
       }
       break;
     }
     case extensions::NOTIFICATION_EXTENSION_INSTALL_ERROR: {
       CrxInstaller* crx_installer = content::Source<CrxInstaller>(source).ptr();
       if (!Profile::FromWebUI(web_ui())->IsSameProfile(
               crx_installer->profile())) {
         return;
@@ skipping 17 matching lines @@
 
   std::unique_ptr<base::DictionaryValue> app_info(GetAppInfo(extension));
   if (!app_info.get())
     return;
 
   visible_apps_.insert(extension->id());
   ExtensionPrefs* prefs = ExtensionPrefs::Get(extension_service_->profile());
   base::FundamentalValue highlight(prefs->IsFromBookmark(extension->id()) &&
                                    attempted_bookmark_app_install_);
   attempted_bookmark_app_install_ = false;
-  web_ui()->CallJavascriptFunction("ntp.appAdded", *app_info, highlight);
+  web_ui()->CallJavascriptFunctionUnsafe("ntp.appAdded", *app_info, highlight);
 }
 
 void AppLauncherHandler::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
   AppRemoved(extension, false);
 }
 
 void AppLauncherHandler::OnExtensionUninstalled(
@@ skipping 80 matching lines @@
 
     const ExtensionSet& terminated_set = registry->terminated_extensions();
     for (ExtensionSet::const_iterator it = terminated_set.begin();
          it != terminated_set.end(); ++it) {
       visible_apps_.insert((*it)->id());
     }
   }
 
   SetAppToBeHighlighted();
   FillAppDictionary(&dictionary);
-  web_ui()->CallJavascriptFunction("ntp.getAppsCallback", dictionary);
+  web_ui()->CallJavascriptFunctionUnsafe("ntp.getAppsCallback", dictionary);
 
   // First time we get here we set up the observer so that we can tell update
   // the apps as they change.
   if (!has_loaded_apps_) {
     base::Closure callback = base::Bind(
         &AppLauncherHandler::OnExtensionPreferenceChanged,
         base::Unretained(this));
     extension_pref_change_registrar_.Init(
         ExtensionPrefs::Get(profile)->pref_service());
     extension_pref_change_registrar_.Add(
@@ skipping 313 matching lines @@
   installer->set_page_ordinal(install_info->page_ordinal);
   installer->InstallWebApp(*web_app);
   attempted_bookmark_app_install_ = true;
 }
 
 void AppLauncherHandler::SetAppToBeHighlighted() {
   if (highlight_app_id_.empty())
     return;
 
   base::StringValue app_id(highlight_app_id_);
-  web_ui()->CallJavascriptFunction("ntp.setAppToBeHighlighted", app_id);
+  web_ui()->CallJavascriptFunctionUnsafe("ntp.setAppToBeHighlighted", app_id);
   highlight_app_id_.clear();
 }
 
 void AppLauncherHandler::OnExtensionPreferenceChanged() {
   base::DictionaryValue dictionary;
   FillAppDictionary(&dictionary);
-  web_ui()->CallJavascriptFunction("ntp.appsPrefChangeCallback", dictionary);
+  web_ui()->CallJavascriptFunctionUnsafe("ntp.appsPrefChangeCallback",
+                                         dictionary);
 }
 
 void AppLauncherHandler::OnLocalStatePreferenceChanged() {
 #if defined(ENABLE_APP_LIST)
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "ntp.appLauncherPromoPrefChangeCallback",
       base::FundamentalValue(g_browser_process->local_state()->GetBoolean(
           prefs::kShowAppLauncherPromo)));
 #endif
 }
 
 void AppLauncherHandler::CleanupAfterUninstall() {
   extension_id_prompting_.clear();
 }
 
@@ skipping 14 matching lines @@
 }
 
 void AppLauncherHandler::ExtensionEnableFlowFinished() {
   DCHECK_EQ(extension_id_prompting_, extension_enable_flow_->extension_id());
 
   // We bounce this off the NTP so the browser can update the apps icon.
   // If we don't launch the app asynchronously, then the app's disabled
   // icon disappears but isn't replaced by the enabled icon, making a poor
   // visual experience.
   base::StringValue app_id(extension_id_prompting_);
-  web_ui()->CallJavascriptFunction("ntp.launchAppAfterEnable", app_id);
+  web_ui()->CallJavascriptFunctionUnsafe("ntp.launchAppAfterEnable", app_id);
 
   extension_enable_flow_.reset();
   extension_id_prompting_ = "";
 }
 
 void AppLauncherHandler::ExtensionEnableFlowAborted(bool user_initiated) {
   DCHECK_EQ(extension_id_prompting_, extension_enable_flow_->extension_id());
 
   // We record the histograms here because ExtensionUninstallCanceled is also
   // called when the extension uninstall dialog is canceled.
@@ skipping 24 matching lines @@
 
 void AppLauncherHandler::AppRemoved(const Extension* extension,
                                     bool is_uninstall) {
   if (!ShouldShow(extension))
     return;
 
   std::unique_ptr<base::DictionaryValue> app_info(GetAppInfo(extension));
   if (!app_info.get())
     return;
 
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "ntp.appRemoved", *app_info, base::FundamentalValue(is_uninstall),
       base::FundamentalValue(!extension_id_prompting_.empty()));
 }
 
 bool AppLauncherHandler::ShouldShow(const Extension* extension) const {
   if (ignore_changes_ || !has_loaded_apps_ || !extension->is_app())
     return false;
 
   Profile* profile = Profile::FromWebUI(web_ui());
   return extensions::ui_util::ShouldDisplayInNewTabPage(extension, profile);
 }