Remove raw base::DictionaryValue::Set in //content

content/renderer/media/peer_connection_tracker.cc

 // Copyright (c) 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 "content/renderer/media/peer_connection_tracker.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/values.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebRTCAnswerOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
 #include "third_party/WebKit/public/platform/WebRTCOfferOptions.h"
@@ skipping 211 matching lines @@
     GET_STRING_OF_STATE(ICEGatheringStateGathering)
     GET_STRING_OF_STATE(ICEGatheringStateComplete)
     default:
       NOTREACHED();
       break;
   }
   return result;
 }
 
 // Builds a DictionaryValue from the StatsReport.
-// The caller takes the ownership of the returned value.
 // Note:
 // The format must be consistent with what webrtc_internals.js expects.
 // If you change it here, you must change webrtc_internals.js as well.
-static base::DictionaryValue* GetDictValueStats(const StatsReport& report) {
+static std::unique_ptr<base::DictionaryValue> GetDictValueStats(
+    const StatsReport& report) {
   if (report.values().empty())
     return NULL;
 
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  dict->SetDouble("timestamp", report.timestamp());
-
-  base::ListValue* values = new base::ListValue();
-  dict->Set("values", values);
+  auto values = base::MakeUnique<base::ListValue>();
 
   for (const auto& v : report.values()) {
     const StatsReport::ValuePtr& value = v.second;
     values->AppendString(value->display_name());
     switch (value->type()) {
       case StatsReport::Value::kInt:
         values->AppendInteger(value->int_val());
         break;
       case StatsReport::Value::kFloat:
         values->AppendDouble(value->float_val());
         break;
       case StatsReport::Value::kString:
         values->AppendString(value->string_val());
         break;
       case StatsReport::Value::kStaticString:
         values->AppendString(value->static_string_val());
         break;
       case StatsReport::Value::kBool:
         values->AppendBoolean(value->bool_val());
         break;
       case StatsReport::Value::kInt64:  // int64_t isn't supported, so use
                                         // string.
       case StatsReport::Value::kId:
       default:
         values->AppendString(value->ToString());
         break;
     }
   }
 
+  auto dict = base::MakeUnique<base::DictionaryValue>();
+  dict->SetDouble("timestamp", report.timestamp());
+  dict->Set("values", std::move(values));
+
   return dict;
 }
 
 // Builds a DictionaryValue from the StatsReport.
 // The caller takes the ownership of the returned value.
 static std::unique_ptr<base::DictionaryValue> GetDictValue(
     const StatsReport& report) {
-  std::unique_ptr<base::DictionaryValue> stats, result;
-
-  stats.reset(GetDictValueStats(report));
+  std::unique_ptr<base::DictionaryValue> stats = GetDictValueStats(report);
   if (!stats)
     return NULL;
 
-  result.reset(new base::DictionaryValue());
   // Note:
   // The format must be consistent with what webrtc_internals.js expects.
   // If you change it here, you must change webrtc_internals.js as well.
-  result->Set("stats", stats.release());
+  auto result = base::MakeUnique<base::DictionaryValue>();
+  result->Set("stats", std::move(stats));
   result->SetString("id", report.id()->ToString());
   result->SetString("type", report.TypeToString());
 
   return result;
 }
 
 class InternalStatsObserver : public webrtc::StatsObserver {
  public:
   InternalStatsObserver(int lid)
       : lid_(lid), main_thread_(base::ThreadTaskRunnerHandle::Get()) {}
@@ skipping 426 matching lines @@
   DCHECK(main_thread_.CalledOnValidThread());
   SendTarget()->Send(new PeerConnectionTrackerHost_UpdatePeerConnection(
       local_id, std::string(callback_type), value));
 }
 
 void PeerConnectionTracker::OverrideSendTargetForTesting(RenderThread* target) {
   send_target_for_test_ = target;
 }
 
 }  // namespace content