base::ListValue::Append cleanup: pass unique_ptr instead of the released pointer.

components/browser_sync/browser/profile_sync_service.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 "components/browser_sync/browser/profile_sync_service.h"
 
 #include <stddef.h>
 #include <cstddef>
 #include <map>
 #include <utility>
@@ skipping 1875 matching lines @@
   ModelTypeSet& throttled_types(detailed_status.throttled_types);
   ModelTypeSet registered = GetRegisteredDataTypes();
   std::unique_ptr<base::DictionaryValue> type_status_header(
       new base::DictionaryValue());
 
   type_status_header->SetString("name", "Model Type");
   type_status_header->SetString("status", "header");
   type_status_header->SetString("value", "Group Type");
   type_status_header->SetString("num_entries", "Total Entries");
   type_status_header->SetString("num_live", "Live Entries");
-  result->Append(type_status_header.release());
+  result->Append(std::move(type_status_header));
 
   std::unique_ptr<base::DictionaryValue> type_status;
   for (ModelTypeSet::Iterator it = registered.First(); it.Good(); it.Inc()) {
     ModelType type = it.Get();
 
     type_status.reset(new base::DictionaryValue());
     type_status->SetString("name", ModelTypeToString(type));
 
     if (error_map.find(type) != error_map.end()) {
       const syncer::SyncError &error = error_map.find(type)->second;
@@ skipping 36 matching lines @@
       type_status->SetString("status", "warning");
       type_status->SetString("value", "Disabled by User");
     }
 
     int live_count = detailed_status.num_entries_by_type[type] -
         detailed_status.num_to_delete_entries_by_type[type];
     type_status->SetInteger("num_entries",
                             detailed_status.num_entries_by_type[type]);
     type_status->SetInteger("num_live", live_count);
 
-    result->Append(type_status.release());
+    result->Append(std::move(type_status));
   }
   return result.release();
 }
 
 void ProfileSyncService::ConsumeCachedPassphraseIfPossible() {
   // If no cached passphrase, or sync backend hasn't started up yet, just exit.
   // If the backend isn't running yet, OnBackendInitialized() will call this
   // method again after the backend starts up.
   if (cached_passphrase_.empty() || !IsBackendInitialized())
     return;
@@ skipping 299 matching lines @@
 
   for (size_t i = 0; i < node_lists.size() && i < types.size(); ++i) {
     const ModelType type = types[i];
     base::ListValue* node_list = node_lists[i];
 
     // Add these results to our list.
     std::unique_ptr<base::DictionaryValue> type_dict(
         new base::DictionaryValue());
     type_dict->SetString("type", ModelTypeToString(type));
     type_dict->Set("nodes", node_list);
-    result_accumulator_->Append(type_dict.release());
+    result_accumulator_->Append(std::move(type_dict));
 
     // Remember that this part of the request is satisfied.
     awaiting_types_.Remove(type);
   }
 
   if (awaiting_types_.Empty()) {
     callback_.Run(std::move(result_accumulator_));
     callback_.Reset();
   }
 }
@@ skipping 251 matching lines @@
 }
 
 std::string ProfileSyncService::unrecoverable_error_message() const {
   return unrecoverable_error_message_;
 }
 
 tracked_objects::Location ProfileSyncService::unrecoverable_error_location()
     const {
   return unrecoverable_error_location_;
 }