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

content/browser/webrtc/webrtc_internals.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/browser/webrtc/webrtc_internals.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/browser/webrtc/webrtc_internals_ui_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/service_manager_connection.h"
 #include "device/wake_lock/public/interfaces/wake_lock_provider.mojom.h"
@@ skipping 15 matching lines @@
 namespace content {
 
 namespace {
 
 base::LazyInstance<WebRTCInternals>::Leaky g_webrtc_internals =
     LAZY_INSTANCE_INITIALIZER;
 
 // Makes sure that |dict| has a ListValue under path "log".
 base::ListValue* EnsureLogList(base::DictionaryValue* dict) {
   base::ListValue* log = NULL;
-  if (!dict->GetList("log", &log)) {
-    log = new base::ListValue();
-    dict->Set("log", log);
-  }
+  if (!dict->GetList("log", &log))
+    log = dict->SetList("log", base::MakeUnique<base::ListValue>());
   return log;
 }
 
 // Removes the log entry associated with a given record.
 void FreeLogList(base::Value* value) {
   DCHECK(value->IsType(base::Value::Type::DICTIONARY));
   auto* dict = static_cast<base::DictionaryValue*>(value);
   dict->Remove("log", nullptr);
 }
 
@@ skipping 123 matching lines @@
   if (!record)
     return;
 
   if (type == "stop")
     MaybeClosePeerConnection(record);
 
   // Don't update entries if there aren't any observers.
   if (!observers_.might_have_observers())
     return;
 
-  std::unique_ptr<base::DictionaryValue> log_entry(new base::DictionaryValue());
+  auto log_entry = base::MakeUnique<base::DictionaryValue>();
 
   double epoch_time = base::Time::Now().ToJsTime();
   string time = base::DoubleToString(epoch_time);
   log_entry->SetString("time", time);
   log_entry->SetString("type", type);
   log_entry->SetString("value", value);
 
-  std::unique_ptr<base::DictionaryValue> update(new base::DictionaryValue());
+  auto update = base::MakeUnique<base::DictionaryValue>();
   update->SetInteger("pid", static_cast<int>(pid));
   update->SetInteger("lid", lid);
   update->MergeDictionary(log_entry.get());
 
   SendUpdate("updatePeerConnection", std::move(update));
 
   // Append the update to the end of the log.
   EnsureLogList(record)->Append(std::move(log_entry));
 }
 
 void WebRTCInternals::OnAddStats(base::ProcessId pid, int lid,
                                  const base::ListValue& value) {
   if (!observers_.might_have_observers())
     return;
 
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("pid", static_cast<int>(pid));
   dict->SetInteger("lid", lid);
 
-  dict->Set("reports", value.CreateDeepCopy());
+  dict->Set("reports", base::MakeUnique<base::Value>(value));
 
   SendUpdate("addStats", std::move(dict));
 }
 
 void WebRTCInternals::OnGetUserMedia(int rid,
                                      base::ProcessId pid,
                                      const std::string& origin,
                                      bool audio,
                                      bool video,
                                      const std::string& audio_constraints,
                                      const std::string& video_constraints) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("rid", rid);
   dict->SetInteger("pid", static_cast<int>(pid));
   dict->SetString("origin", origin);
   if (audio)
     dict->SetString("audio", audio_constraints);
   if (video)
     dict->SetString("video", video_constraints);
 
   if (observers_.might_have_observers())
     SendUpdate("addGetUserMedia", dict->CreateDeepCopy());
@@ skipping 359 matching lines @@
 
     if (this_pid == static_cast<int>(pid) && this_lid == lid) {
       if (index)
         *index = i;
       return record;
     }
   }
   return nullptr;
 }
 }  // namespace content