Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

chrome/browser/ui/webui/local_discovery/local_discovery_ui_handler.cc

 // Copyright 2013 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/local_discovery/local_discovery_ui_handler.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 257 matching lines @@
 
   current_register_operation_ =
       current_http_client_->CreateRegisterOperation(GetSyncAccount(), this);
   current_register_operation_->Start();
 }
 
 void LocalDiscoveryUIHandler::OnPrivetRegisterClaimToken(
     PrivetRegisterOperation* operation,
     const std::string& token,
     const GURL& url) {
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "local_discovery.onRegistrationConfirmedOnPrinter");
   if (!ContainsKey(device_descriptions_, current_http_client_->GetName())) {
     SendRegisterError();
     return;
   }
 
   confirm_api_call_flow_ = CreateApiFlow();
   if (!confirm_api_call_flow_) {
     SendRegisterError();
     return;
   }
   confirm_api_call_flow_->Start(base::WrapUnique<GCDApiFlow::Request>(
       new cloud_print::PrivetConfirmApiCallFlow(
           token, base::Bind(&LocalDiscoveryUIHandler::OnConfirmDone,
                             base::Unretained(this)))));
 }
 
 void LocalDiscoveryUIHandler::OnPrivetRegisterError(
     PrivetRegisterOperation* operation,
     const std::string& action,
     PrivetRegisterOperation::FailureReason reason,
     int printer_http_code,
     const base::DictionaryValue* json) {
   std::string error;
 
   if (reason == PrivetRegisterOperation::FAILURE_JSON_ERROR &&
       json->GetString(cloud_print::kPrivetKeyError, &error)) {
     if (error == cloud_print::kPrivetErrorTimeout) {
-        web_ui()->CallJavascriptFunction(
-            "local_discovery.onRegistrationTimeout");
+      web_ui()->CallJavascriptFunctionUnsafe(
+          "local_discovery.onRegistrationTimeout");
       return;
     }
     if (error == cloud_print::kPrivetErrorCancel) {
-      web_ui()->CallJavascriptFunction(
-            "local_discovery.onRegistrationCanceledPrinter");
+      web_ui()->CallJavascriptFunctionUnsafe(
+          "local_discovery.onRegistrationCanceledPrinter");
       return;
     }
   }
 
   SendRegisterError();
 }
 
 void LocalDiscoveryUIHandler::OnPrivetRegisterDone(
     PrivetRegisterOperation* operation,
     const std::string& device_id) {
@@ skipping 27 matching lines @@
 
   base::StringValue service_key(kKeyPrefixMDns + name);
 
   if (description.id.empty()) {
     info.SetString(kDictionaryKeyServiceName, name);
     info.SetString(kDictionaryKeyDisplayName, description.name);
     info.SetString(kDictionaryKeyDescription, description.description);
     info.SetString(kDictionaryKeyType, description.type);
     info.SetBoolean(kDictionaryKeyIsWifi, false);
 
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "local_discovery.onUnregisteredDeviceUpdate", service_key, info);
   } else {
     std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
 
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "local_discovery.onUnregisteredDeviceUpdate", service_key, *null_value);
   }
 }
 
 void LocalDiscoveryUIHandler::DeviceRemoved(const std::string& name) {
   device_descriptions_.erase(name);
   std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
   base::StringValue name_value(kKeyPrefixMDns + name);
 
-  web_ui()->CallJavascriptFunction("local_discovery.onUnregisteredDeviceUpdate",
-                                   name_value, *null_value);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "local_discovery.onUnregisteredDeviceUpdate", name_value, *null_value);
 }
 
 void LocalDiscoveryUIHandler::DeviceCacheFlushed() {
-  web_ui()->CallJavascriptFunction("local_discovery.onDeviceCacheFlushed");
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "local_discovery.onDeviceCacheFlushed");
   privet_lister_->DiscoverNewDevices(false);
 }
 
 void LocalDiscoveryUIHandler::OnDeviceListReady(
     const CloudPrintPrinterList::DeviceList& devices) {
   cloud_devices_.insert(cloud_devices_.end(), devices.begin(), devices.end());
   ++succeded_list_count_;
   CheckListingDone();
 }
 
 void LocalDiscoveryUIHandler::OnDeviceListUnavailable() {
   ++failed_list_count_;
   CheckListingDone();
 }
 
 void LocalDiscoveryUIHandler::GoogleSigninSucceeded(
     const std::string& account_id,
     const std::string& username,
     const std::string& password) {
   CheckUserLoggedIn();
 }
 
 void LocalDiscoveryUIHandler::GoogleSignedOut(const std::string& account_id,
                                               const std::string& username) {
   CheckUserLoggedIn();
 }
 
 void LocalDiscoveryUIHandler::SendRegisterError() {
-  web_ui()->CallJavascriptFunction("local_discovery.onRegistrationFailed");
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "local_discovery.onRegistrationFailed");
 }
 
 void LocalDiscoveryUIHandler::SendRegisterDone(
     const std::string& service_name) {
   // HACK(noamsml): Generate network traffic so the Windows firewall doesn't
   // block the printer's announcement.
   privet_lister_->DiscoverNewDevices(false);
 
   DeviceDescriptionMap::iterator it = device_descriptions_.find(service_name);
 
   if (it == device_descriptions_.end()) {
     // TODO(noamsml): Handle the case where a printer's record is not present at
     // the end of registration.
     SendRegisterError();
     return;
   }
 
   const DeviceDescription& device = it->second;
   base::DictionaryValue device_value;
 
   device_value.SetString(kDictionaryKeyType, device.type);
   device_value.SetString(kDictionaryKeyID, device.id);
   device_value.SetString(kDictionaryKeyDisplayName, device.name);
   device_value.SetString(kDictionaryKeyDescription, device.description);
   device_value.SetString(kDictionaryKeyServiceName, service_name);
 
-  web_ui()->CallJavascriptFunction("local_discovery.onRegistrationSuccess",
-                                   device_value);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "local_discovery.onRegistrationSuccess", device_value);
 }
 
 void LocalDiscoveryUIHandler::SetIsVisible(bool visible) {
   if (visible == is_visible_)
     return;
 
   g_num_visible += visible ? 1 : -1;
   is_visible_ = visible;
 }
 
@@ skipping 16 matching lines @@
   }
 
   confirm_api_call_flow_.reset();
   privet_resolution_.reset();
   current_http_client_.reset();
 }
 
 void LocalDiscoveryUIHandler::CheckUserLoggedIn() {
   base::FundamentalValue logged_in_value(!GetSyncAccount().empty());
   base::FundamentalValue is_supervised_value(IsUserSupervisedOrOffTheRecord());
-  web_ui()->CallJavascriptFunction(
-      "local_discovery.setUserLoggedIn", logged_in_value, is_supervised_value);
+  web_ui()->CallJavascriptFunctionUnsafe("local_discovery.setUserLoggedIn",
+                                         logged_in_value, is_supervised_value);
 }
 
 void LocalDiscoveryUIHandler::CheckListingDone() {
   int started = cloud_print_printer_list_ ? 1 : 0;
   if (started > failed_list_count_ + succeded_list_count_)
     return;
 
   if (succeded_list_count_ <= 0) {
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "local_discovery.onCloudDeviceListUnavailable");
     return;
   }
 
   base::ListValue devices_list;
   std::set<std::string> local_ids;
 
   for (const auto& it : device_descriptions_)
     local_ids.insert(it.second.id);
 
   ReadDevicesList(cloud_devices_, local_ids, &devices_list);
 
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "local_discovery.onCloudDeviceListAvailable", devices_list);
   cloud_print_printer_list_.reset();
 }
 
 std::unique_ptr<GCDApiFlow> LocalDiscoveryUIHandler::CreateApiFlow() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
     return std::unique_ptr<GCDApiFlow>();
 
   ProfileOAuth2TokenService* token_service =
@@ skipping 82 matching lines @@
         IDS_LOCAL_DISCOVERY_CLOUD_PRINT_CONNECTOR_DISABLED_LABEL,
         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
   } else {
     label_str = l10n_util::GetStringFUTF16(
         IDS_OPTIONS_CLOUD_PRINT_CONNECTOR_ENABLED_LABEL,
         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT),
         base::UTF8ToUTF16(email));
   }
   base::StringValue label(label_str);
 
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "local_discovery.setupCloudPrintConnectorSection", disabled, label,
       allowed);
 }
 
 void LocalDiscoveryUIHandler::RefreshCloudPrintStatusFromService() {
   auto* service = GetCloudPrintProxyService();
   if (service)
     service->RefreshStatusFromService();
 }
 
 CloudPrintProxyService* LocalDiscoveryUIHandler::GetCloudPrintProxyService() {
   return CloudPrintProxyServiceFactory::GetForProfile(
       Profile::FromWebUI(web_ui()));
 }
 #endif  // defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 
 }  // namespace local_discovery