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

content/browser/media/media_internals_proxy.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 "content/browser/media/media_internals_proxy.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 29 matching lines @@
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  NotificationService::AllBrowserContextsAndSources());
 }
 
 void MediaInternalsProxy::Observe(int type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(type, NOTIFICATION_RENDERER_PROCESS_TERMINATED);
   RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
-  CallJavaScriptFunctionOnUIThread("media.onRendererTerminated",
-                                   new base::Value(process->GetID()));
+  CallJavaScriptFunctionOnUIThread(
+      "media.onRendererTerminated",
+      base::MakeUnique<base::Value>(process->GetID()));
 }
 
 void MediaInternalsProxy::Attach(MediaInternalsMessageHandler* handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   handler_ = handler;
   update_callback_ = base::Bind(&MediaInternalsProxy::UpdateUIOnUIThread, this);
   MediaInternals::GetInstance()->AddUpdateCallback(update_callback_);
 
   BrowserThread::PostTask(
@@ skipping 40 matching lines @@
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&MediaInternalsProxy::AddNetEventOnUIThread, this,
                  base::Passed(entry.ToValue())));
 }
 
 MediaInternalsProxy::~MediaInternalsProxy() {}
 
-base::Value* MediaInternalsProxy::GetConstants() {
-  base::DictionaryValue* event_phases = new base::DictionaryValue();
+std::unique_ptr<base::Value> MediaInternalsProxy::GetConstants() {
+  auto event_phases = base::MakeUnique<base::DictionaryValue>();
   event_phases->SetInteger(
       net::NetLog::EventPhaseToString(net::NetLogEventPhase::NONE),
       static_cast<int>(net::NetLogEventPhase::NONE));
   event_phases->SetInteger(
       net::NetLog::EventPhaseToString(net::NetLogEventPhase::BEGIN),
       static_cast<int>(net::NetLogEventPhase::BEGIN));
   event_phases->SetInteger(
       net::NetLog::EventPhaseToString(net::NetLogEventPhase::END),
       static_cast<int>(net::NetLogEventPhase::END));
 
-  base::DictionaryValue* constants = new base::DictionaryValue();
+  auto constants = base::MakeUnique<base::DictionaryValue>();
   constants->Set("eventTypes", net::NetLog::GetEventTypesAsValue());
-  constants->Set("eventPhases", event_phases);
+  constants->Set("eventPhases", std::move(event_phases));
 
-  return constants;
+  return std::move(constants);
 }
 
 void MediaInternalsProxy::ObserveMediaInternalsOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (GetContentClient()->browser()->GetNetLog()) {
     net::NetLog* net_log = GetContentClient()->browser()->GetNetLog();
     net_log->DeprecatedAddObserver(
         this, net::NetLogCaptureMode::IncludeCookiesAndCredentials());
   }
 }
@@ skipping 33 matching lines @@
         base::Bind(&MediaInternalsProxy::SendNetEventsOnUIThread, this),
         base::TimeDelta::FromMilliseconds(
             kMediaInternalsProxyEventDelayMilliseconds));
   }
   pending_net_updates_->Append(std::move(entry));
 }
 
 void MediaInternalsProxy::SendNetEventsOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   CallJavaScriptFunctionOnUIThread("media.onNetUpdate",
-                                   pending_net_updates_.release());
+                                   std::move(pending_net_updates_));
 }
 
 void MediaInternalsProxy::CallJavaScriptFunctionOnUIThread(
-    const std::string& function, base::Value* args) {
+    const std::string& function,
+    std::unique_ptr<base::Value> args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  std::unique_ptr<base::Value> args_value(args);
   std::vector<const base::Value*> args_vector;
-  args_vector.push_back(args_value.get());
+  args_vector.push_back(args.get());
   base::string16 update = WebUI::GetJavascriptCall(function, args_vector);
   UpdateUIOnUIThread(update);
 }
 
 }  // namespace content