Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

chrome/browser/ui/webui/print_preview/print_preview_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/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 #include <stddef.h>
 
 #include <map>
@@ skipping 690 matching lines @@
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&EnumeratePrintersOnFileThread,
                  base::Unretained(results)),
       base::Bind(&PrintPreviewHandler::SetupPrinterList,
                  weak_factory_.GetWeakPtr(),
                  base::Owned(results)));
 }
 
 void PrintPreviewHandler::HandleGetPrivetPrinters(const base::ListValue* args) {
   if (!PrivetPrintingEnabled())
-    return web_ui()->CallJavascriptFunction("onPrivetPrinterSearchDone");
+    return web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrinterSearchDone");
 #if defined(ENABLE_SERVICE_DISCOVERY)
   using local_discovery::ServiceDiscoverySharedClient;
   scoped_refptr<ServiceDiscoverySharedClient> service_discovery =
       ServiceDiscoverySharedClient::GetInstance();
   StartPrivetLister(service_discovery);
 #endif  // ENABLE_SERVICE_DISCOVERY
 }
 
 void PrintPreviewHandler::HandleStopGetPrivetPrinters(
     const base::ListValue* args) {
@@ skipping 199 matching lines @@
     int width = 0;
     int height = 0;
     if (!settings->GetString(printing::kSettingDeviceName, &printer_name) ||
         !settings->GetString(printing::kSettingTicket, &print_ticket) ||
         !settings->GetString(printing::kSettingCapabilities, &capabilities) ||
         !settings->GetInteger(printing::kSettingPageWidth, &width) ||
         !settings->GetInteger(printing::kSettingPageHeight, &height) ||
         width <= 0 || height <= 0) {
       NOTREACHED();
       base::FundamentalValue http_code_value(-1);
-      web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
+      web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
+                                             http_code_value);
       return;
     }
 
     PrintToPrivetPrinter(
         printer_name, print_ticket, capabilities, gfx::Size(width, height));
     return;
   }
 #endif
 
   if (print_with_extension) {
@@ skipping 340 matching lines @@
                               chrome::IsRunningInForcedAppMode());
   if (prefs) {
     const std::string rules_str =
         prefs->GetString(prefs::kPrintPreviewDefaultDestinationSelectionRules);
     if (!rules_str.empty())
       initial_settings.SetString(kDefaultDestinationSelectionRules, rules_str);
   }
 
   if (print_preview_ui()->source_is_modifiable())
     GetNumberFormatAndMeasurementSystem(&initial_settings);
-  web_ui()->CallJavascriptFunction("setInitialSettings", initial_settings);
+  web_ui()->CallJavascriptFunctionUnsafe("setInitialSettings",
+                                         initial_settings);
 
   if (PrintPreviewDistiller::IsEnabled()) {
     using dom_distiller::url_utils::IsUrlDistillable;
     WebContents* initiator = GetInitiator();
     if (initiator && IsUrlDistillable(initiator->GetLastCommittedURL()))
-      web_ui()->CallJavascriptFunction("allowDistillPage");
+      web_ui()->CallJavascriptFunctionUnsafe("allowDistillPage");
   }
 }
 
 void PrintPreviewHandler::ClosePreviewDialog() {
   print_preview_ui()->OnClosePrintPreviewDialog();
 }
 
 void PrintPreviewHandler::SendAccessToken(const std::string& type,
                                           const std::string& access_token) {
   VLOG(1) << "Get getAccessToken finished";
-  web_ui()->CallJavascriptFunction("onDidGetAccessToken",
-                                   base::StringValue(type),
-                                   base::StringValue(access_token));
+  web_ui()->CallJavascriptFunctionUnsafe("onDidGetAccessToken",
+                                         base::StringValue(type),
+                                         base::StringValue(access_token));
 }
 
 void PrintPreviewHandler::SendPrinterCapabilities(
     const std::string& printer_name,
     std::unique_ptr<base::DictionaryValue> settings_info) {
   if (!settings_info) {
     VLOG(1) << "Get printer capabilities failed";
-    web_ui()->CallJavascriptFunction("failedToGetPrinterCapabilities",
-                                     base::StringValue(printer_name));
+    web_ui()->CallJavascriptFunctionUnsafe("failedToGetPrinterCapabilities",
+                                           base::StringValue(printer_name));
     return;
   }
   VLOG(1) << "Get printer capabilities finished";
-  web_ui()->CallJavascriptFunction("updateWithPrinterCapabilities",
-                                   *settings_info);
+  web_ui()->CallJavascriptFunctionUnsafe("updateWithPrinterCapabilities",
+                                         *settings_info);
 }
 
 void PrintPreviewHandler::SetupPrinterList(const base::ListValue* printers) {
   if (!has_logged_printers_count_) {
     UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters", printers->GetSize());
     has_logged_printers_count_ = true;
   }
 
-  web_ui()->CallJavascriptFunction("setPrinters", *printers);
+  web_ui()->CallJavascriptFunctionUnsafe("setPrinters", *printers);
 }
 
 void PrintPreviewHandler::SendCloudPrintEnabled() {
   Profile* profile = Profile::FromBrowserContext(
       preview_web_contents()->GetBrowserContext());
   PrefService* prefs = profile->GetPrefs();
   if (prefs->GetBoolean(prefs::kCloudPrintSubmitEnabled)) {
     base::DictionaryValue settings;
     settings.SetString(kCloudPrintUrl,
                        GURL(cloud_devices::GetCloudPrintURL()).spec());
     settings.SetBoolean(kAppKioskMode, chrome::IsRunningInForcedAppMode());
-    web_ui()->CallJavascriptFunction("setUseCloudPrint", settings);
+    web_ui()->CallJavascriptFunctionUnsafe("setUseCloudPrint", settings);
   }
 }
 
 void PrintPreviewHandler::SendCloudPrintJob(const base::RefCountedBytes* data) {
   // BASE64 encode the job data.
   const base::StringPiece raw_data(reinterpret_cast<const char*>(data->front()),
                                    data->size());
   std::string base64_data;
   base::Base64Encode(raw_data, &base64_data);
   base::StringValue data_value(base64_data);
 
-  web_ui()->CallJavascriptFunction("printToCloud", data_value);
+  web_ui()->CallJavascriptFunctionUnsafe("printToCloud", data_value);
 }
 
 WebContents* PrintPreviewHandler::GetInitiator() const {
   printing::PrintPreviewDialogController* dialog_controller =
       printing::PrintPreviewDialogController::GetInstance();
   if (!dialog_controller)
     return NULL;
   return dialog_controller->GetInitiator(preview_web_contents());
 }
 
@@ skipping 76 matching lines @@
 #endif  // ENABLE_BASIC_PRINTING
 
 void PrintPreviewHandler::FileSelected(const base::FilePath& path,
                                        int /* index */,
                                        void* /* params */) {
   // Updating |save_path_| to the newly selected folder.
   printing::StickySettings* sticky_settings = GetStickySettings();
   sticky_settings->StoreSavePath(path.DirName());
   sticky_settings->SaveInPrefs(Profile::FromBrowserContext(
       preview_web_contents()->GetBrowserContext())->GetPrefs());
-  web_ui()->CallJavascriptFunction("fileSelectionCompleted");
+  web_ui()->CallJavascriptFunctionUnsafe("fileSelectionCompleted");
   print_to_pdf_path_ = path;
   PostPrintToPdfTask();
 }
 
 void PrintPreviewHandler::PostPrintToPdfTask() {
   scoped_refptr<base::RefCountedBytes> data;
   base::string16 title;
   if (!GetPreviewDataAndTitle(&data, &title)) {
     NOTREACHED() << "Preview data was checked before file dialog.";
     return;
@@ skipping 42 matching lines @@
   *data = tmp_data;
   *title = print_preview_ui()->initiator_title();
   return true;
 }
 
 #if defined(ENABLE_SERVICE_DISCOVERY)
 
 void PrintPreviewHandler::StartPrivetLister(const scoped_refptr<
     local_discovery::ServiceDiscoverySharedClient>& client) {
   if (!PrivetPrintingEnabled())
-    return web_ui()->CallJavascriptFunction("onPrivetPrinterSearchDone");
+    return web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrinterSearchDone");
 
   Profile* profile = Profile::FromWebUI(web_ui());
   DCHECK(!service_discovery_client_.get() ||
          service_discovery_client_.get() == client.get());
   service_discovery_client_ = client;
   printer_lister_.reset(new cloud_print::PrivetLocalPrinterLister(
       service_discovery_client_.get(), profile->GetRequestContext(), this));
   printer_lister_->Start();
 }
 
 void PrintPreviewHandler::LocalPrinterChanged(
     const std::string& name,
     bool has_local_printing,
     const cloud_print::DeviceDescription& description) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (has_local_printing ||
       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos)) {
     base::DictionaryValue info;
     FillPrinterDescription(name, description, has_local_printing, &info);
-    web_ui()->CallJavascriptFunction("onPrivetPrinterChanged", info);
+    web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrinterChanged", info);
   }
 }
 
 void PrintPreviewHandler::LocalPrinterRemoved(const std::string& name) {
 }
 
 void PrintPreviewHandler::LocalPrinterCacheFlushed() {
 }
 
 void PrintPreviewHandler::PrivetCapabilitiesUpdateClient(
@@ skipping 44 matching lines @@
       privet_http_client_->CreateLocalPrintOperation(this);
 
   privet_local_print_operation_->SetTicket(print_ticket);
   privet_local_print_operation_->SetCapabilities(capabilities);
 
   scoped_refptr<base::RefCountedBytes> data;
   base::string16 title;
 
   if (!GetPreviewDataAndTitle(&data, &title)) {
     base::FundamentalValue http_code_value(-1);
-    web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
+    web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
+                                           http_code_value);
     return;
   }
 
   privet_local_print_operation_->SetJobname(base::UTF16ToUTF8(title));
   privet_local_print_operation_->SetPageSize(page_size);
   privet_local_print_operation_->SetData(data.get());
 
   Profile* profile = Profile::FromWebUI(web_ui());
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfileIfExists(profile);
@@ skipping 21 matching lines @@
   const cloud_print::DeviceDescription* description =
       printer_lister_->GetDeviceDescription(name);
 
   if (!description) {
     SendPrivetCapabilitiesError(name);
     return;
   }
 
   FillPrinterDescription(name, *description, true, &printer_info);
 
-  web_ui()->CallJavascriptFunction(
-      "onPrivetCapabilitiesSet",
-      printer_info,
-      *capabilities);
+  web_ui()->CallJavascriptFunctionUnsafe("onPrivetCapabilitiesSet",
+                                         printer_info, *capabilities);
 
   privet_capabilities_operation_.reset();
 }
 
 void PrintPreviewHandler::SendPrivetCapabilitiesError(
     const std::string& device_name) {
   base::StringValue name_value(device_name);
-  web_ui()->CallJavascriptFunction(
-      "failedToGetPrivetPrinterCapabilities",
-      name_value);
+  web_ui()->CallJavascriptFunctionUnsafe("failedToGetPrivetPrinterCapabilities",
+                                         name_value);
 }
 
 void PrintPreviewHandler::PrintToPrivetPrinter(const std::string& device_name,
                                                const std::string& ticket,
                                                const std::string& capabilities,
                                                const gfx::Size& page_size) {
   CreatePrivetHTTP(
       device_name,
       base::Bind(&PrintPreviewHandler::PrivetLocalPrintUpdateClient,
                  base::Unretained(this),
@@ skipping 25 matching lines @@
 
 void PrintPreviewHandler::OnPrivetPrintingDone(
     const cloud_print::PrivetLocalPrintOperation* print_operation) {
   ClosePreviewDialog();
 }
 
 void PrintPreviewHandler::OnPrivetPrintingError(
     const cloud_print::PrivetLocalPrintOperation* print_operation,
     int http_code) {
   base::FundamentalValue http_code_value(http_code);
-  web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
+  web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
+                                         http_code_value);
 }
 
 void PrintPreviewHandler::FillPrinterDescription(
     const std::string& name,
     const cloud_print::DeviceDescription& description,
     bool has_local_printing,
     base::DictionaryValue* printer_value) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   printer_value->SetString("serviceName", name);
@@ skipping 12 matching lines @@
   if (extension_printer_handler_)
     return;
 
   extension_printer_handler_ =
       PrinterHandler::CreateForExtensionPrinters(Profile::FromWebUI(web_ui()));
 }
 
 void PrintPreviewHandler::OnGotPrintersForExtension(
     const base::ListValue& printers,
     bool done) {
-  web_ui()->CallJavascriptFunction("onExtensionPrintersAdded", printers,
-                                   base::FundamentalValue(done));
+  web_ui()->CallJavascriptFunctionUnsafe("onExtensionPrintersAdded", printers,
+                                         base::FundamentalValue(done));
 }
 
 void PrintPreviewHandler::OnGotExtensionPrinterInfo(
     const std::string& printer_id,
     const base::DictionaryValue& printer_info) {
   if (printer_info.empty()) {
-    web_ui()->CallJavascriptFunction("failedToResolveProvisionalPrinter",
-                                     base::StringValue(printer_id));
+    web_ui()->CallJavascriptFunctionUnsafe("failedToResolveProvisionalPrinter",
+                                           base::StringValue(printer_id));
     return;
   }
 
-  web_ui()->CallJavascriptFunction("onProvisionalPrinterResolved",
-                                   base::StringValue(printer_id),
-                                   printer_info);
+  web_ui()->CallJavascriptFunctionUnsafe("onProvisionalPrinterResolved",
+                                         base::StringValue(printer_id),
+                                         printer_info);
 }
 
 void PrintPreviewHandler::OnGotExtensionPrinterCapabilities(
     const std::string& printer_id,
     const base::DictionaryValue& capabilities) {
   if (capabilities.empty()) {
-    web_ui()->CallJavascriptFunction("failedToGetExtensionPrinterCapabilities",
-                                     base::StringValue(printer_id));
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "failedToGetExtensionPrinterCapabilities",
+        base::StringValue(printer_id));
     return;
   }
 
-  web_ui()->CallJavascriptFunction("onExtensionCapabilitiesSet",
-                                   base::StringValue(printer_id), capabilities);
+  web_ui()->CallJavascriptFunctionUnsafe("onExtensionCapabilitiesSet",
+                                         base::StringValue(printer_id),
+                                         capabilities);
 }
 
 void PrintPreviewHandler::OnExtensionPrintResult(bool success,
                                                  const std::string& status) {
   if (success) {
     ClosePreviewDialog();
     return;
   }
 
   // TODO(tbarzic): This function works for extension printers case too, but it
   // should be renamed to something more generic.
-  web_ui()->CallJavascriptFunction("onPrivetPrintFailed",
-                                   base::StringValue(status));
+  web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrintFailed",
+                                         base::StringValue(status));
 }
 
 void PrintPreviewHandler::RegisterForGaiaCookieChanges() {
   DCHECK(!gaia_cookie_manager_service_);
   Profile* profile = Profile::FromWebUI(web_ui());
   if (switches::IsEnableAccountConsistency() && !profile->IsOffTheRecord()) {
     gaia_cookie_manager_service_ =
         GaiaCookieManagerServiceFactory::GetForProfile(profile);
     if (gaia_cookie_manager_service_)
       gaia_cookie_manager_service_->AddObserver(this);
   }
 }
 
 void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }