Remove raw base::DictionaryValue::Set

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 1594 matching lines @@
     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;
+    auto details = base::MakeUnique<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);
+    file->Set("details", std::move(details));
 
     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());
@@ skipping 15 matching lines @@
 
   // Append the first element for metadata.
   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;
+  auto keys = base::MakeUnique<base::ListValue>();
   keys->AppendStrings(key_strings);
   metadata->SetString("title", "Trackers");
-  metadata->Set("keys", keys);
+  metadata->Set("keys", std::move(keys));
   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();
@@ skipping 38 matching lines @@
   std::unique_ptr<base::ListValue> files(new base::ListValue);
 
   // Append the first element for metadata.
   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;
+  auto keys = base::MakeUnique<base::ListValue>();
   keys->AppendStrings(key_strings);
   metadata->SetString("title", "Metadata");
-  metadata->Set("keys", keys);
+  metadata->Set("keys", std::move(keys));
   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();
@@ skipping 70 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system