Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

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>
+
 #include <algorithm>
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"  // for FileAccessProvider
 #include "base/i18n/string_compare.h"
 #include "base/id_map.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/posix/safe_strerror.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/certificate_viewer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/certificate_dialogs.h"
@@ skipping 457 matching lines @@
   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);
 
   net::NSSCertDatabase::TrustBits trust_bits =
       certificate_manager_model_->cert_db()->GetCertTrust(cert, net::CA_CERT);
-  scoped_ptr<base::DictionaryValue> ca_trust_info(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> ca_trust_info(
+      new base::DictionaryValue);
   ca_trust_info->SetBoolean(
       kSslField,
       static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_SSL));
   ca_trust_info->SetBoolean(
       kEmailField,
       static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_EMAIL));
   ca_trust_info->SetBoolean(
       kObjSignField,
       static_cast<bool>(trust_bits & net::NSSCertDatabase::TRUSTED_OBJ_SIGN));
   ResolveCallback(*ca_trust_info);
@@ skipping 457 matching lines @@
         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());
   }
 }
 
 void CertificatesHandler::OnCertificateManagerModelCreated(
-    scoped_ptr<CertificateManagerModel> model) {
+    std::unique_ptr<CertificateManagerModel> model) {
   certificate_manager_model_ = std::move(model);
   CertificateManagerModelReady();
 }
 
 void CertificatesHandler::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(
@@ skipping 22 matching lines @@
   }
 
   // We are already waiting for a CertificateManagerModel to be created, no need
   // to do anything.
 }
 
 void CertificatesHandler::PopulateTree(
     const std::string& tab_name,
     net::CertType type,
     const net::CertificateList& web_trust_certs) {
-  scoped_ptr<icu::Collator> collator;
+  std::unique_ptr<icu::Collator> collator;
   UErrorCode error = U_ZERO_ERROR;
   collator.reset(icu::Collator::createInstance(
       icu::Locale(g_browser_process->GetApplicationLocale().c_str()), error));
   if (U_FAILURE(error))
     collator.reset(NULL);
   DictionaryIdComparator comparator(collator.get());
   CertificateManagerModel::OrgGroupingMap map;
 
   certificate_manager_model_->FilterAndBuildOrgGroupingMap(type, &map);
 
   {
-    scoped_ptr<base::ListValue> nodes = make_scoped_ptr(new base::ListValue());
+    std::unique_ptr<base::ListValue> nodes =
+        base::WrapUnique(new base::ListValue());
     for (CertificateManagerModel::OrgGroupingMap::iterator i = map.begin();
          i != map.end(); ++i) {
       // Populate first level (org name).
       base::DictionaryValue* dict = new base::DictionaryValue;
       dict->SetString(kKeyField, OrgNameToId(i->first));
       dict->SetString(kNameField, i->first);
 
       // Populate second level (certs).
       base::ListValue* subnodes = new base::ListValue;
       for (net::CertificateList::const_iterator org_cert_it = i->second.begin();
@@ skipping 44 matching lines @@
 }
 
 void CertificatesHandler::RejectCallback(const base::Value& response) {
   DCHECK(!webui_callback_id_.empty());
   RejectJavascriptCallback(base::StringValue(webui_callback_id_), response);
   webui_callback_id_.clear();
 }
 
 void CertificatesHandler::RejectCallbackWithError(const std::string& title,
                                                   const std::string& error) {
-  scoped_ptr<base::DictionaryValue> error_info(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> error_info(new base::DictionaryValue);
   error_info->SetString(kErrorTitle, title);
   error_info->SetString(kErrorDescription, error);
   RejectCallback(*error_info);
 }
 
 void CertificatesHandler::RejectCallbackWithImportError(
     const std::string& title,
     const net::NSSCertDatabase::ImportCertFailureList& not_imported) {
   std::string error;
   if (selected_cert_list_.size() == 1)
     error = l10n_util::GetStringUTF8(
         IDS_SETTINGS_CERTIFICATE_MANAGER_IMPORT_SINGLE_NOT_IMPORTED);
   else if (not_imported.size() == selected_cert_list_.size())
     error = l10n_util::GetStringUTF8(
         IDS_SETTINGS_CERTIFICATE_MANAGER_IMPORT_ALL_NOT_IMPORTED);
   else
     error = l10n_util::GetStringUTF8(
         IDS_SETTINGS_CERTIFICATE_MANAGER_IMPORT_SOME_NOT_IMPORTED);
 
-  scoped_ptr<base::ListValue> cert_error_list =
-      make_scoped_ptr(new base::ListValue());
+  std::unique_ptr<base::ListValue> cert_error_list =
+      base::WrapUnique(new base::ListValue());
   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(kNameField,
                     failure.certificate->subject().GetDisplayName());
     dict->SetString(kErrorField, NetErrorToString(failure.net_error));
     cert_error_list->Append(dict);
   }
 
-  scoped_ptr<base::DictionaryValue> error_info(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> error_info(new base::DictionaryValue);
   error_info->SetString(kErrorTitle, title);
   error_info->SetString(kErrorDescription, error);
   error_info->Set(kCertificateErrors,
-                  make_scoped_ptr(cert_error_list.release()));
+                  base::WrapUnique(cert_error_list.release()));
   RejectCallback(*error_info);
 }
 
 gfx::NativeWindow CertificatesHandler::GetParentWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 }  // namespace settings