Rewrite simple uses of base::ListValue::Append() taking a raw pointer var.

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>
 #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"
@@ skipping 1114 matching lines @@
           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);
 
   {
-    base::ListValue* nodes = new base::ListValue;
+    std::unique_ptr<base::ListValue> nodes(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;
+      std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
       dict->SetString(kKeyId, OrgNameToId(i->first));
       dict->SetString(kNameId, i->first);
 
       // Populate second level (certs).
       base::ListValue* subnodes = new base::ListValue;
       for (net::CertificateList::const_iterator org_cert_it = i->second.begin();
            org_cert_it != i->second.end(); ++org_cert_it) {
-        base::DictionaryValue* cert_dict = new base::DictionaryValue;
+        std::unique_ptr<base::DictionaryValue> cert_dict(
+            new base::DictionaryValue);
         net::X509Certificate* cert = org_cert_it->get();
         cert_dict->SetString(kKeyId, cert_id_map_->CertToId(cert));
         cert_dict->SetString(kNameId, certificate_manager_model_->GetColumnText(
             *cert, CertificateManagerModel::COL_SUBJECT_NAME));
         cert_dict->SetBoolean(
             kReadOnlyId,
             certificate_manager_model_->cert_db()->IsReadOnly(cert));
         // Policy-installed certificates with web trust are trusted.
         bool policy_trusted =
             IsPolicyInstalledWithWebTrust(web_trust_certs, cert);
         cert_dict->SetBoolean(
             kUntrustedId,
             !policy_trusted &&
                 certificate_manager_model_->cert_db()->IsUntrusted(cert));
         cert_dict->SetBoolean(kPolicyTrustedId, policy_trusted);
         // TODO(hshi): This should be determined by testing for PKCS #11
         // CKA_EXTRACTABLE attribute. We may need to use the NSS function
         // PK11_ReadRawAttribute to do that.
         cert_dict->SetBoolean(
             kExtractableId,
             !certificate_manager_model_->IsHardwareBacked(cert));
         // TODO(mattm): Other columns.
-        subnodes->Append(cert_dict);
+        subnodes->Append(std::move(cert_dict));
       }
       std::sort(subnodes->begin(), subnodes->end(), comparator);
 
       dict->Set(kSubNodesId, subnodes);
-      nodes->Append(dict);
+      nodes->Append(std::move(dict));
     }
     std::sort(nodes->begin(), nodes->end(), comparator);
 
     base::ListValue args;
     args.AppendString(tree_name);
-    args.Append(nodes);
+    args.Append(std::move(nodes));
     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));
@@ skipping 12 matching lines @@
     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;
+    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(dict);
+    cert_error_list.Append(std::move(dict));
   }
 
   base::StringValue title_value(title);
   base::StringValue 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