Remove base::Value::CreateNullValue

chrome/browser/ui/webui/settings/certificates_handler.cc

 // Copyright 2016 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/settings/certificates_handler.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 440 matching lines @@
   }
 }
 
 void CertificatesHandler::FileSelectionCanceled(void* params) {
   switch (reinterpret_cast<intptr_t>(params)) {
     case EXPORT_PERSONAL_FILE_SELECTED:
     case IMPORT_PERSONAL_FILE_SELECTED:
     case IMPORT_SERVER_FILE_SELECTED:
     case IMPORT_CA_FILE_SELECTED:
       ImportExportCleanup();
-      RejectCallback(*base::Value::CreateNullValue());
+      RejectCallback(base::Value());
       break;
     default:
       NOTREACHED();
   }
 }
 
 void CertificatesHandler::HandleViewCertificate(const base::ListValue* args) {
   net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert)
     return;
@@ skipping 62 matching lines @@
           trust_email * net::NSSCertDatabase::TRUSTED_EMAIL +
           trust_obj_sign * net::NSSCertDatabase::TRUSTED_OBJ_SIGN);
   if (!result) {
     // TODO(mattm): better error messages?
     RejectCallbackWithError(
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_SET_TRUST_ERROR_TITLE),
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_UNKNOWN_ERROR));
   } else {
-    ResolveCallback(*base::Value::CreateNullValue());
+    ResolveCallback(base::Value());
   }
 }
 
 void CertificatesHandler::HandleExportPersonal(const base::ListValue* args) {
   CHECK_EQ(2U, args->GetSize());
   AssignWebUICallbackId(args);
   std::string node_id;
   CHECK(args->GetString(1, &node_id));
 
   net::X509Certificate* cert = cert_id_map_->IdToCert(node_id);
@@ skipping 11 matching lines @@
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_SAVEAS_FILE, base::string16(),
       base::FilePath(), &file_type_info, 1, FILE_PATH_LITERAL("p12"),
       GetParentWindow(),
       reinterpret_cast<void*>(EXPORT_PERSONAL_FILE_SELECTED));
 }
 
 void CertificatesHandler::ExportPersonalFileSelected(
     const base::FilePath& path) {
   file_path_ = path;
-  ResolveCallback(*base::Value::CreateNullValue());
+  ResolveCallback(base::Value());
 }
 
 void CertificatesHandler::HandleExportPersonalPasswordSelected(
     const base::ListValue* args) {
   CHECK_EQ(2U, args->GetSize());
   AssignWebUICallbackId(args);
   CHECK(args->GetString(1, &password_));
 
   // 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
@@ skipping 33 matching lines @@
                                                     const int* bytes_written) {
   ImportExportCleanup();
   if (*write_errno) {
     RejectCallbackWithError(
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_PKCS12_EXPORT_ERROR_TITLE),
         l10n_util::GetStringFUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_WRITE_ERROR_FORMAT,
             UTF8ToUTF16(base::safe_strerror(*write_errno))));
   } else {
-    ResolveCallback(*base::Value::CreateNullValue());
+    ResolveCallback(base::Value());
   }
 }
 
 void CertificatesHandler::HandleImportPersonal(const base::ListValue* args) {
   CHECK_EQ(2U, args->GetSize());
   AssignWebUICallbackId(args);
   CHECK(args->GetBoolean(1, &use_hardware_backed_));
 
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   file_type_info.extensions.resize(1);
@@ skipping 95 matching lines @@
   // 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(
       slot_.get(), file_data_, password_, is_extractable);
   ImportExportCleanup();
   int string_id;
   switch (result) {
     case net::OK:
-      ResolveCallback(*base::Value::CreateNullValue());
+      ResolveCallback(base::Value());
       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_SETTINGS_CERTIFICATE_MANAGER_BAD_PASSWORD;
       break;
     case net::ERR_PKCS12_IMPORT_INVALID_MAC:
       string_id = IDS_SETTINGS_CERTIFICATE_MANAGER_IMPORT_INVALID_MAC;
       break;
     case net::ERR_PKCS12_IMPORT_INVALID_FILE:
@@ skipping 86 matching lines @@
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_SERVER_IMPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_UNKNOWN_ERROR));
   } else if (!not_imported.empty()) {
     RejectCallbackWithImportError(
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_SERVER_IMPORT_ERROR_TITLE),
         not_imported);
   } else {
-    ResolveCallback(*base::Value::CreateNullValue());
+    ResolveCallback(base::Value());
   }
   ImportExportCleanup();
 }
 
 void CertificatesHandler::HandleImportCA(const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
   AssignWebUICallbackId(args);
 
   select_file_dialog_ = ui::SelectFileDialog::Create(
       this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
@@ skipping 71 matching lines @@
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_CA_IMPORT_ERROR_TITLE),
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_UNKNOWN_ERROR));
   } else if (!not_imported.empty()) {
     RejectCallbackWithImportError(
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_CA_IMPORT_ERROR_TITLE),
         not_imported);
   } else {
-    ResolveCallback(*base::Value::CreateNullValue());
+    ResolveCallback(base::Value());
   }
   ImportExportCleanup();
 }
 
 void CertificatesHandler::HandleExportCertificate(const base::ListValue* args) {
   net::X509Certificate* cert = cert_id_map_->CallbackArgsToCert(args);
   if (!cert)
     return;
   ShowCertExportDialog(web_ui()->GetWebContents(), GetParentWindow(), cert);
 }
 
 void CertificatesHandler::HandleDeleteCertificate(const base::ListValue* args) {
   CHECK_EQ(2U, args->GetSize());
   AssignWebUICallbackId(args);
   std::string node_id;
   CHECK(args->GetString(1, &node_id));
 
   net::X509Certificate* cert = cert_id_map_->IdToCert(node_id);
   CHECK(cert);
 
   bool result = certificate_manager_model_->Delete(cert);
   if (!result) {
     // TODO(mattm): better error messages?
     RejectCallbackWithError(
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_DELETE_CERT_ERROR_TITLE),
         l10n_util::GetStringUTF8(
             IDS_SETTINGS_CERTIFICATE_MANAGER_UNKNOWN_ERROR));
   } else {
-    ResolveCallback(*base::Value::CreateNullValue());
+    ResolveCallback(base::Value());
   }
 }
 
 void CertificatesHandler::OnCertificateManagerModelCreated(
     std::unique_ptr<CertificateManagerModel> model) {
   certificate_manager_model_ = std::move(model);
   CertificateManagerModelReady();
 }
 
 void CertificatesHandler::CertificateManagerModelReady() {
@@ skipping 152 matching lines @@
   error_info->Set(kCertificateErrors,
                   base::WrapUnique(cert_error_list.release()));
   RejectCallback(*error_info);
 }
 
 gfx::NativeWindow CertificatesHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 }  // namespace settings