Remove raw DictionaryValue::Set in //chrome

chrome/browser/task_profiler/task_profiler_data_serializer.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/task_profiler/task_profiler_data_serializer.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
+#include "base/values.h"
 #include "chrome/common/chrome_content_client.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "content/public/common/process_type.h"
 #include "url/gurl.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 using tracked_objects::BirthOnThreadSnapshot;
 using tracked_objects::DeathDataSnapshot;
@@ skipping 17 matching lines @@
 // Re-serializes the |birth| into |dictionary|.  Prepends the |prefix| to the
 // "thread" and "location" key names in the dictionary.
 void BirthOnThreadSnapshotToValue(const BirthOnThreadSnapshot& birth,
                                   const std::string& prefix,
                                   base::DictionaryValue* dictionary) {
   DCHECK(!prefix.empty());
 
   std::unique_ptr<base::DictionaryValue> location_value(
       new base::DictionaryValue);
   LocationSnapshotToValue(birth.location, location_value.get());
-  dictionary->Set(prefix + "_location", location_value.release());
+  dictionary->Set(prefix + "_location", std::move(location_value));
 
-  dictionary->Set(prefix + "_thread",
-                  new base::Value(birth.sanitized_thread_name));
+  dictionary->SetString(prefix + "_thread", birth.sanitized_thread_name);
 }
 
 // Re-serializes the |death_data| into |dictionary|.
 void DeathDataSnapshotToValue(const DeathDataSnapshot& death_data,
                               base::DictionaryValue* dictionary) {
   dictionary->SetInteger("count", death_data.count);
   dictionary->SetInteger("run_ms", death_data.run_duration_sum);
   dictionary->SetInteger("run_ms_max", death_data.run_duration_max);
   dictionary->SetInteger("run_ms_sample", death_data.run_duration_sample);
   dictionary->SetInteger("queue_ms", death_data.queue_duration_sum);
@@ skipping 11 matching lines @@
   dictionary->SetInteger("max_allocated_bytes", death_data.max_allocated_bytes);
 }
 
 // Re-serializes the |snapshot| into |dictionary|.
 void TaskSnapshotToValue(const TaskSnapshot& snapshot,
                          base::DictionaryValue* dictionary) {
   BirthOnThreadSnapshotToValue(snapshot.birth, "birth", dictionary);
 
   std::unique_ptr<base::DictionaryValue> death_data(new base::DictionaryValue);
   DeathDataSnapshotToValue(snapshot.death_data, death_data.get());
-  dictionary->Set("death_data", death_data.release());
+  dictionary->Set("death_data", std::move(death_data));
 
   dictionary->SetString("death_thread", snapshot.death_sanitized_thread_name);
 }
 
 int AsChromeProcessType(
     metrics::ProfilerEventProto::TrackedObject::ProcessType process_type) {
   switch (process_type) {
     case metrics::ProfilerEventProto::TrackedObject::UNKNOWN:
     case metrics::ProfilerEventProto::TrackedObject::PLUGIN:
       return content::PROCESS_TYPE_UNKNOWN;
@@ skipping 35 matching lines @@
     const ProcessDataPhaseSnapshot& process_data_phase,
     base::ProcessId process_id,
     metrics::ProfilerEventProto::TrackedObject::ProcessType process_type,
     base::DictionaryValue* dictionary) {
   std::unique_ptr<base::ListValue> tasks_list(new base::ListValue);
   for (const auto& task : process_data_phase.tasks) {
     std::unique_ptr<base::DictionaryValue> snapshot(new base::DictionaryValue);
     TaskSnapshotToValue(task, snapshot.get());
     tasks_list->Append(std::move(snapshot));
   }
-  dictionary->Set("list", tasks_list.release());
+  dictionary->Set("list", std::move(tasks_list));
 
   dictionary->SetInteger("process_id", process_id);
   dictionary->SetString("process_type", content::GetProcessTypeNameInEnglish(
                                             AsChromeProcessType(process_type)));
 }
 
 }  // namespace task_profiler