Remove base::StringValue

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>
 
@@ skipping 993 matching lines @@
         l10n_util::GetStringUTF8(IDS_CERT_MANAGER_CERT_PARSE_ERROR));
     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());
+  base::Value cert_name(root_cert->subject().GetDisplayName());
   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;
@@ skipping 159 matching lines @@
     base::ListValue args;
     args.AppendString(tree_name);
     args.Append(std::move(nodes));
     web_ui()->CallJavascriptFunctionUnsafe("CertificateManager.onPopulateTree",
                                            args);
   }
 }
 
 void CertificateManagerHandler::ShowError(const std::string& title,
                                           const std::string& error) const {
-  auto title_value = base::MakeUnique<base::StringValue>(title);
-  auto error_value = base::MakeUnique<base::StringValue>(error);
+  auto title_value = base::MakeUnique<base::Value>(title);
+  auto error_value = base::MakeUnique<base::Value>(error);
   auto ok_title_value =
-      base::MakeUnique<base::StringValue>(l10n_util::GetStringUTF8(IDS_OK));
+      base::MakeUnique<base::Value>(l10n_util::GetStringUTF8(IDS_OK));
   auto cancel_title_value = base::Value::CreateNullValue();
   auto ok_callback_value = base::Value::CreateNullValue();
   auto cancel_callback_value = base::Value::CreateNullValue();
   std::vector<const base::Value*> args = {
       title_value.get(),       error_value.get(),
       ok_title_value.get(),    cancel_title_value.get(),
       ok_callback_value.get(), cancel_callback_value.get()};
   web_ui()->CallJavascriptFunctionUnsafe("AlertOverlay.show", args);
 }
 
@@ skipping 11 matching lines @@
 
   base::ListValue cert_error_list;
   for (size_t i = 0; i < not_imported.size(); ++i) {
     const net::NSSCertDatabase::ImportCertFailure& failure = not_imported[i];
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
     dict->SetString(kNameId, failure.certificate->subject().GetDisplayName());
     dict->SetString(kErrorId, NetErrorToString(failure.net_error));
     cert_error_list.Append(std::move(dict));
   }
 
-  base::StringValue title_value(title);
-  base::StringValue error_value(error);
+  base::Value title_value(title);
+  base::Value error_value(error);
   web_ui()->CallJavascriptFunctionUnsafe("CertificateImportErrorOverlay.show",
                                          title_value, error_value,
                                          cert_error_list);
 }
 
 gfx::NativeWindow CertificateManagerHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 }  // namespace options