Rename WebUI::CallJavascriptFunction to WebUI::CallJavascriptFunctionUnsafe

chrome/browser/ui/webui/options/certificate_manager_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/certificate_manager_handler.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
@@ skipping 584 matching lines @@
                                      cert);
     return;
   }
 #endif
   ShowCertificateViewer(web_ui()->GetWebContents(), GetParentWindow(), cert);
 }
 
 void CertificateManagerHandler::GetCATrust(const base::ListValue* args) {
   net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert) {
-    web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "CertificateEditCaTrustOverlay.dismiss");
     return;
   }
 
   net::NSSCertDatabase::TrustBits trust_bits =
       certificate_manager_model_->cert_db()->GetCertTrust(cert, net::CA_CERT);
   base::FundamentalValue ssl_value(
       static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_SSL));
   base::FundamentalValue email_value(
       static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_EMAIL));
   base::FundamentalValue obj_sign_value(
       static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_OBJ_SIGN));
-  web_ui()->CallJavascriptFunction(
-      "CertificateEditCaTrustOverlay.populateTrust",
-      ssl_value, email_value, obj_sign_value);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "CertificateEditCaTrustOverlay.populateTrust", ssl_value, email_value,
+      obj_sign_value);
 }
 
 void CertificateManagerHandler::EditCATrust(const base::ListValue* args) {
   net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   bool fail = !cert;
   bool trust_ssl = false;
   bool trust_email = false;
   bool trust_obj_sign = false;
   fail |= !CallbackArgsToBool(args, 1, &trust_ssl);
   fail |= !CallbackArgsToBool(args, 2, &trust_email);
   fail |= !CallbackArgsToBool(args, 3, &trust_obj_sign);
   if (fail) {
     LOG(ERROR) << "EditCATrust args fail";
-    web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "CertificateEditCaTrustOverlay.dismiss");
     return;
   }
 
   bool result = certificate_manager_model_->SetCertTrust(
       cert,
       net::CA_CERT,
       trust_ssl * net::NSSCertDatabase::TRUSTED_SSL +
           trust_email * net::NSSCertDatabase::TRUSTED_EMAIL +
           trust_obj_sign * net::NSSCertDatabase::TRUSTED_OBJ_SIGN);
-  web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "CertificateEditCaTrustOverlay.dismiss");
   if (!result) {
     // TODO(mattm): better error messages?
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_SET_TRUST_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   }
 }
 
 void CertificateManagerHandler::EditServer(const base::ListValue* args) {
   NOTIMPLEMENTED();
@@ skipping 21 matching lines @@
       reinterpret_cast<void*>(EXPORT_PERSONAL_FILE_SELECTED));
 }
 
 void CertificateManagerHandler::ExportAllPersonal(const base::ListValue* args) {
   NOTIMPLEMENTED();
 }
 
 void CertificateManagerHandler::ExportPersonalFileSelected(
     const base::FilePath& path) {
   file_path_ = path;
-  web_ui()->CallJavascriptFunction(
+  web_ui()->CallJavascriptFunctionUnsafe(
       "CertificateManager.exportPersonalAskPassword");
 }
 
 void CertificateManagerHandler::ExportPersonalPasswordSelected(
     const base::ListValue* args) {
   if (!args->GetString(0, &password_)) {
-    web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
 
   // Currently, we don't support exporting more than one at a time.  If we do,
   // this would need to either change this to use UnlockSlotsIfNecessary or
   // change UnlockCertSlotIfNecessary to take a CertificateList.
   DCHECK_EQ(selected_cert_list_.size(), 1U);
 
   // TODO(mattm): do something smarter about non-extractable keys
   chrome::UnlockCertSlotIfNecessary(
       selected_cert_list_[0].get(),
       chrome::kCryptoModulePasswordCertExport,
       net::HostPortPair(),  // unused.
       GetParentWindow(),
       base::Bind(&CertificateManagerHandler::ExportPersonalSlotsUnlocked,
                  base::Unretained(this)));
 }
 
 void CertificateManagerHandler::ExportPersonalSlotsUnlocked() {
   std::string output;
   int num_exported = certificate_manager_model_->cert_db()->ExportToPKCS12(
       selected_cert_list_,
       password_,
       &output);
   if (!num_exported) {
-    web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_PKCS12_EXPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
     ImportExportCleanup();
     return;
   }
   file_access_provider_->StartWrite(
       file_path_,
       output,
       base::Bind(&CertificateManagerHandler::ExportPersonalFileWritten,
                  base::Unretained(this)),
       &tracker_);
 }
 
 void CertificateManagerHandler::ExportPersonalFileWritten(
     const int* write_errno, const int* bytes_written) {
-  web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+  web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
   ImportExportCleanup();
   if (*write_errno) {
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_PKCS12_EXPORT_ERROR_TITLE),
         l10n_util::GetStringFUTF8(IDS_CERT_MANAGER_WRITE_ERROR_FORMAT,
                                   UTF8ToUTF16(
                                       base::safe_strerror(*write_errno))));
   }
 }
 
 void CertificateManagerHandler::StartImportPersonal(
     const base::ListValue* args) {
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   if (!args->GetBoolean(0, &use_hardware_backed_)) {
     // Unable to retrieve the hardware backed attribute from the args,
     // so bail.
-    web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
   file_type_info.extensions.resize(1);
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("p12"));
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("pfx"));
   file_type_info.extensions[0].push_back(FILE_PATH_LITERAL("crt"));
   file_type_info.extension_description_overrides.push_back(
       l10n_util::GetStringUTF16(IDS_CERT_USAGE_SSL_CLIENT));
   file_type_info.include_all_files = true;
@@ skipping 11 matching lines @@
   file_access_provider_->StartRead(
       path, base::Bind(&CertificateManagerHandler::ImportPersonalFileRead,
                        base::Unretained(this)),
       &tracker_);
 }
 
 void CertificateManagerHandler::ImportPersonalFileRead(
     const int* read_errno, const std::string* data) {
   if (*read_errno) {
     ImportExportCleanup();
-    web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_IMPORT_ERROR_TITLE),
         l10n_util::GetStringFUTF8(IDS_CERT_MANAGER_READ_ERROR_FORMAT,
                                   UTF8ToUTF16(
                                       base::safe_strerror(*read_errno))));
     return;
   }
 
   file_data_ = *data;
 
   if (CouldBePFX(file_data_)) {
-    web_ui()->CallJavascriptFunction(
+    web_ui()->CallJavascriptFunctionUnsafe(
         "CertificateManager.importPersonalAskPassword");
     return;
   }
 
   // Non .p12/.pfx files are assumed to be single/chain certificates without
   // private key data. The default extension according to spec is '.crt',
   // however other extensions are also used in some places to represent these
   // certificates.
   int result = certificate_manager_model_->ImportUserCert(file_data_);
   ImportExportCleanup();
-  web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+  web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
   int string_id;
   switch (result) {
     case net::OK:
       return;
     case net::ERR_NO_PRIVATE_KEY_FOR_CERT:
       string_id = IDS_CERT_MANAGER_IMPORT_MISSING_KEY;
       break;
     case net::ERR_CERT_INVALID:
       string_id = IDS_CERT_MANAGER_IMPORT_INVALID_FILE;
       break;
     default:
       string_id = IDS_CERT_MANAGER_UNKNOWN_ERROR;
       break;
   }
   ShowError(
       l10n_util::GetStringUTF8(IDS_CERT_MANAGER_IMPORT_ERROR_TITLE),
       l10n_util::GetStringUTF8(string_id));
 }
 
 void CertificateManagerHandler::ImportPersonalPasswordSelected(
     const base::ListValue* args) {
   if (!args->GetString(0, &password_)) {
-    web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
     ImportExportCleanup();
     return;
   }
 
   if (use_hardware_backed_) {
     module_ = certificate_manager_model_->cert_db()->GetPrivateModule();
   } else {
     module_ = certificate_manager_model_->cert_db()->GetPublicModule();
   }
 
@@ skipping 10 matching lines @@
 
 void CertificateManagerHandler::ImportPersonalSlotUnlocked() {
   // Determine if the private key should be unextractable after the import.
   // We do this by checking the value of |use_hardware_backed_| which is set
   // to true if importing into a hardware module. Currently, this only happens
   // for Chrome OS when the "Import and Bind" option is chosen.
   bool is_extractable = !use_hardware_backed_;
   int result = certificate_manager_model_->ImportFromPKCS12(
       module_.get(), file_data_, password_, is_extractable);
   ImportExportCleanup();
-  web_ui()->CallJavascriptFunction("CertificateRestoreOverlay.dismiss");
+  web_ui()->CallJavascriptFunctionUnsafe("CertificateRestoreOverlay.dismiss");
   int string_id;
   switch (result) {
     case net::OK:
       return;
     case net::ERR_PKCS12_IMPORT_BAD_PASSWORD:
       // TODO(mattm): if the error was a bad password, we should reshow the
       // password dialog after the user dismisses the error dialog.
       string_id = IDS_CERT_MANAGER_BAD_PASSWORD;
       break;
     case net::ERR_PKCS12_IMPORT_INVALID_MAC:
@@ skipping 134 matching lines @@
     return;
   }
 
   scoped_refptr<net::X509Certificate> root_cert =
       certificate_manager_model_->cert_db()->FindRootInList(
           selected_cert_list_);
 
   // TODO(mattm): check here if root_cert is not a CA cert and show error.
 
   base::StringValue cert_name(root_cert->subject().GetDisplayName());
-  web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.showImport",
-                                   cert_name);
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "CertificateEditCaTrustOverlay.showImport", cert_name);
 }
 
 void CertificateManagerHandler::ImportCATrustSelected(
     const base::ListValue* args) {
   bool fail = false;
   bool trust_ssl = false;
   bool trust_email = false;
   bool trust_obj_sign = false;
   fail |= !CallbackArgsToBool(args, 0, &trust_ssl);
   fail |= !CallbackArgsToBool(args, 1, &trust_email);
   fail |= !CallbackArgsToBool(args, 2, &trust_obj_sign);
   if (fail) {
     LOG(ERROR) << "ImportCATrustSelected args fail";
     ImportExportCleanup();
-    web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
+    web_ui()->CallJavascriptFunctionUnsafe(
+        "CertificateEditCaTrustOverlay.dismiss");
     return;
   }
 
   // TODO(mattm): add UI for setting explicit distrust, too.
   // http://crbug.com/128411
   net::NSSCertDatabase::ImportCertFailureList not_imported;
   bool result = certificate_manager_model_->ImportCACerts(
       selected_cert_list_,
       trust_ssl * net::NSSCertDatabase::TRUSTED_SSL +
           trust_email * net::NSSCertDatabase::TRUSTED_EMAIL +
           trust_obj_sign * net::NSSCertDatabase::TRUSTED_OBJ_SIGN,
       &not_imported);
-  web_ui()->CallJavascriptFunction("CertificateEditCaTrustOverlay.dismiss");
+  web_ui()->CallJavascriptFunctionUnsafe(
+      "CertificateEditCaTrustOverlay.dismiss");
   if (!result) {
     ShowError(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CA_IMPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_UNKNOWN_ERROR));
   } else if (!not_imported.empty()) {
     ShowImportErrors(
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CA_IMPORT_ERROR_TITLE),
         not_imported);
   }
   ImportExportCleanup();
@@ skipping 23 matching lines @@
     std::unique_ptr<CertificateManagerModel> model) {
   certificate_manager_model_ = std::move(model);
   CertificateManagerModelReady();
 }
 
 void CertificateManagerHandler::CertificateManagerModelReady() {
   base::FundamentalValue user_db_available_value(
       certificate_manager_model_->is_user_db_available());
   base::FundamentalValue tpm_available_value(
       certificate_manager_model_->is_tpm_available());
-  web_ui()->CallJavascriptFunction("CertificateManager.onModelReady",
-                                   user_db_available_value,
-                                   tpm_available_value);
+  web_ui()->CallJavascriptFunctionUnsafe("CertificateManager.onModelReady",
+                                         user_db_available_value,
+                                         tpm_available_value);
   certificate_manager_model_->Refresh();
 }
 
 void CertificateManagerHandler::Populate(const base::ListValue* args) {
   if (certificate_manager_model_) {
     // Already have a model, the webui must be re-loading.  Just re-run the
     // webui initialization.
     CertificateManagerModelReady();
     return;
   }
@@ skipping 73 matching lines @@
       std::sort(subnodes->begin(), subnodes->end(), comparator);
 
       dict->Set(kSubNodesId, subnodes);
       nodes->Append(dict);
     }
     std::sort(nodes->begin(), nodes->end(), comparator);
 
     base::ListValue args;
     args.AppendString(tree_name);
     args.Append(nodes);
-    web_ui()->CallJavascriptFunction("CertificateManager.onPopulateTree", args);
+    web_ui()->CallJavascriptFunctionUnsafe("CertificateManager.onPopulateTree",
+                                           args);
   }
 }
 
 void CertificateManagerHandler::ShowError(const std::string& title,
                                           const std::string& error) const {
   ScopedVector<const base::Value> args;
   args.push_back(new base::StringValue(title));
   args.push_back(new base::StringValue(error));
   args.push_back(new base::StringValue(l10n_util::GetStringUTF8(IDS_OK)));
   args.push_back(base::Value::CreateNullValue().release());  // cancelTitle
   args.push_back(base::Value::CreateNullValue().release());  // okCallback
   args.push_back(base::Value::CreateNullValue().release());  // cancelCallback
-  web_ui()->CallJavascriptFunction("AlertOverlay.show", args.get());
+  web_ui()->CallJavascriptFunctionUnsafe("AlertOverlay.show", args.get());
 }
 
 void CertificateManagerHandler::ShowImportErrors(
     const std::string& title,
     const net::NSSCertDatabase::ImportCertFailureList& not_imported) const {
   std::string error;
   if (selected_cert_list_.size() == 1)
     error = l10n_util::GetStringUTF8(
         IDS_CERT_MANAGER_IMPORT_SINGLE_NOT_IMPORTED);
   else if (not_imported.size() == selected_cert_list_.size())
     error = l10n_util::GetStringUTF8(IDS_CERT_MANAGER_IMPORT_ALL_NOT_IMPORTED);
   else
     error = l10n_util::GetStringUTF8(IDS_CERT_MANAGER_IMPORT_SOME_NOT_IMPORTED);
 
   base::ListValue cert_error_list;
   for (size_t i = 0; i < not_imported.size(); ++i) {
     const net::NSSCertDatabase::ImportCertFailure& failure = not_imported[i];
     base::DictionaryValue* dict = new base::DictionaryValue;
     dict->SetString(kNameId, failure.certificate->subject().GetDisplayName());
     dict->SetString(kErrorId, NetErrorToString(failure.net_error));
     cert_error_list.Append(dict);
   }
 
   base::StringValue title_value(title);
   base::StringValue error_value(error);
-  web_ui()->CallJavascriptFunction("CertificateImportErrorOverlay.show",
-                                   title_value,
-                                   error_value,
-                                   cert_error_list);
+  web_ui()->CallJavascriptFunctionUnsafe("CertificateImportErrorOverlay.show",
+                                         title_value, error_value,
+                                         cert_error_list);
 }
 
 gfx::NativeWindow CertificateManagerHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 }  // namespace options