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

chrome/browser/sync_file_system/drive_backend/metadata_database.cc

 // Copyright 2013 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/sync_file_system/drive_backend/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 #include <utility>
 
@@ skipping 1583 matching lines @@
   while (!stack.empty()) {
     int64_t tracker_id = stack.back();
     stack.pop_back();
     AppendContents(index_->GetFileTrackerIDsByParent(tracker_id), &stack);
 
     FileTracker tracker;
     if (!index_->GetFileTracker(tracker_id, &tracker)) {
       NOTREACHED();
       continue;
     }
-    base::DictionaryValue* file = new base::DictionaryValue;
+    std::unique_ptr<base::DictionaryValue> file(new base::DictionaryValue);
 
     base::FilePath path = BuildDisplayPathForTracker(tracker);
     file->SetString("path", path.AsUTF8Unsafe());
     if (tracker.has_synced_details()) {
       file->SetString("title", tracker.synced_details().title());
       file->SetString("type",
                       FileKindToString(tracker.synced_details().file_kind()));
     }
 
     base::DictionaryValue* details = new base::DictionaryValue;
     details->SetString("file_id", tracker.file_id());
     if (tracker.has_synced_details() &&
         tracker.synced_details().file_kind() == FILE_KIND_FILE)
       details->SetString("md5", tracker.synced_details().md5());
     details->SetString("active", tracker.active() ? "true" : "false");
     details->SetString("dirty", tracker.dirty() ? "true" : "false");
 
     file->Set("details", details);
 
-    files->Append(file);
+    files->Append(std::move(file));
   }
 
   return files;
 }
 
 std::unique_ptr<base::ListValue> MetadataDatabase::DumpDatabase() {
   std::unique_ptr<base::ListValue> list(new base::ListValue);
   list->Append(DumpTrackers());
   list->Append(DumpMetadata());
   return list;
 }
 
 bool MetadataDatabase::HasNewerFileMetadata(const std::string& file_id,
                                             int64_t change_id) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata))
     return false;
   DCHECK(metadata.has_details());
   return metadata.details().change_id() >= change_id;
 }
 
 std::unique_ptr<base::ListValue> MetadataDatabase::DumpTrackers() {
   std::unique_ptr<base::ListValue> trackers(new base::ListValue);
 
   // Append the first element for metadata.
-  base::DictionaryValue* metadata = new base::DictionaryValue;
+  std::unique_ptr<base::DictionaryValue> metadata(new base::DictionaryValue);
   const char *trackerKeys[] = {
     "tracker_id", "path", "file_id", "tracker_kind", "app_id",
     "active", "dirty", "folder_listing", "demoted",
     "title", "kind", "md5", "etag", "missing", "change_id",
   };
   std::vector<std::string> key_strings(
       trackerKeys, trackerKeys + arraysize(trackerKeys));
   base::ListValue* keys = new base::ListValue;
   keys->AppendStrings(key_strings);
   metadata->SetString("title", "Trackers");
   metadata->Set("keys", keys);
-  trackers->Append(metadata);
+  trackers->Append(std::move(metadata));
 
   // Append tracker data.
   std::vector<int64_t> tracker_ids(index_->GetAllTrackerIDs());
   for (std::vector<int64_t>::const_iterator itr = tracker_ids.begin();
        itr != tracker_ids.end(); ++itr) {
     const int64_t tracker_id = *itr;
     FileTracker tracker;
     if (!index_->GetFileTracker(tracker_id, &tracker)) {
       NOTREACHED();
       continue;
     }
 
-    base::DictionaryValue* dict = new base::DictionaryValue;
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
     base::FilePath path = BuildDisplayPathForTracker(tracker);
     dict->SetString("tracker_id", base::Int64ToString(tracker_id));
     dict->SetString("path", path.AsUTF8Unsafe());
     dict->SetString("file_id", tracker.file_id());
     TrackerKind tracker_kind = tracker.tracker_kind();
     dict->SetString(
         "tracker_kind",
         tracker_kind == TRACKER_KIND_APP_ROOT ? "AppRoot" :
         tracker_kind == TRACKER_KIND_DISABLED_APP_ROOT ? "Disabled App" :
         tracker.tracker_id() == GetSyncRootTrackerID() ? "SyncRoot" :
         "Regular");
     dict->SetString("app_id", tracker.app_id());
     dict->SetString("active", tracker.active() ? "true" : "false");
     dict->SetString("dirty", tracker.dirty() ? "true" : "false");
     dict->SetString("folder_listing",
                     tracker.needs_folder_listing() ? "needed" : "no");
 
     bool is_demoted = index_->IsDemotedDirtyTracker(tracker.tracker_id());
     dict->SetString("demoted", is_demoted ? "true" : "false");
     if (tracker.has_synced_details()) {
       const FileDetails& details = tracker.synced_details();
       dict->SetString("title", details.title());
       dict->SetString("kind", FileKindToString(details.file_kind()));
       dict->SetString("md5", details.md5());
       dict->SetString("etag", details.etag());
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
     }
-    trackers->Append(dict);
+    trackers->Append(std::move(dict));
   }
   return trackers;
 }
 
 std::unique_ptr<base::ListValue> MetadataDatabase::DumpMetadata() {
   std::unique_ptr<base::ListValue> files(new base::ListValue);
 
   // Append the first element for metadata.
-  base::DictionaryValue* metadata = new base::DictionaryValue;
+  std::unique_ptr<base::DictionaryValue> metadata(new base::DictionaryValue);
   const char *fileKeys[] = {
     "file_id", "title", "type", "md5", "etag", "missing",
     "change_id", "parents"
   };
   std::vector<std::string> key_strings(
       fileKeys, fileKeys + arraysize(fileKeys));
   base::ListValue* keys = new base::ListValue;
   keys->AppendStrings(key_strings);
   metadata->SetString("title", "Metadata");
   metadata->Set("keys", keys);
-  files->Append(metadata);
+  files->Append(std::move(metadata));
 
   // Append metadata data.
   std::vector<std::string> metadata_ids(index_->GetAllMetadataIDs());
   for (std::vector<std::string>::const_iterator itr = metadata_ids.begin();
        itr != metadata_ids.end(); ++itr) {
     const std::string& file_id = *itr;
     FileMetadata file;
     if (!index_->GetFileMetadata(file_id, &file)) {
       NOTREACHED();
       continue;
     }
 
-    base::DictionaryValue* dict = new base::DictionaryValue;
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
     dict->SetString("file_id", file_id);
     if (file.has_details()) {
       const FileDetails& details = file.details();
       dict->SetString("title", details.title());
       dict->SetString("type", FileKindToString(details.file_kind()));
       dict->SetString("md5", details.md5());
       dict->SetString("etag", details.etag());
       dict->SetString("missing", details.missing() ? "true" : "false");
       dict->SetString("change_id", base::Int64ToString(details.change_id()));
 
       std::vector<std::string> parents;
       for (int i = 0; i < details.parent_folder_ids_size(); ++i)
         parents.push_back(details.parent_folder_ids(i));
       dict->SetString("parents", base::JoinString(parents, ","));
     }
-    files->Append(dict);
+    files->Append(std::move(dict));
   }
   return files;
 }
 
 void MetadataDatabase::AttachSyncRoot(
     const google_apis::FileResource& sync_root_folder) {
   std::unique_ptr<FileMetadata> sync_root_metadata =
       CreateFileMetadataFromFileResource(GetLargestKnownChangeID(),
                                          sync_root_folder);
   std::unique_ptr<FileTracker> sync_root_tracker =
@@ skipping 40 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system