Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.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/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/error_utils.h"
@@ skipping 65 matching lines @@
 
   EventRouter* router = EventRouter::Get(browser_context_);
   if (!router || !router->HasEventListener(kEventName))
     return;
 
   for (const scoped_refptr<const extensions::Extension>& extension :
        ExtensionRegistry::Get(browser_context_)->enabled_extensions()) {
     const std::string& extension_id = extension->id();
     if (router->ExtensionHasEventListener(extension_id, kEventName) &&
         extension->permissions_data()->HasAPIPermission("webrtcAudioPrivate")) {
-      scoped_ptr<Event> event(
+      std::unique_ptr<Event> event(
           new Event(events::WEBRTC_AUDIO_PRIVATE_ON_SINKS_CHANGED, kEventName,
-                    make_scoped_ptr(new base::ListValue())));
+                    base::WrapUnique(new base::ListValue())));
       router->DispatchEventToExtension(extension_id, std::move(event));
     }
   }
 }
 
 WebrtcAudioPrivateFunction::WebrtcAudioPrivateFunction() {}
 
 WebrtcAudioPrivateFunction::~WebrtcAudioPrivateFunction() {
 }
 
 void WebrtcAudioPrivateFunction::GetOutputDeviceNames() {
   scoped_refptr<base::SingleThreadTaskRunner> audio_manager_runner =
       AudioManager::Get()->GetTaskRunner();
   if (!audio_manager_runner->BelongsToCurrentThread()) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     audio_manager_runner->PostTask(
         FROM_HERE,
         base::Bind(&WebrtcAudioPrivateFunction::GetOutputDeviceNames, this));
     return;
   }
 
-  scoped_ptr<AudioDeviceNames> device_names(new AudioDeviceNames);
+  std::unique_ptr<AudioDeviceNames> device_names(new AudioDeviceNames);
   AudioManager::Get()->GetAudioOutputDeviceNames(device_names.get());
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&WebrtcAudioPrivateFunction::OnOutputDeviceNames, this,
                  base::Passed(&device_names)));
 }
 
 void WebrtcAudioPrivateFunction::OnOutputDeviceNames(
-    scoped_ptr<AudioDeviceNames> device_names) {
+    std::unique_ptr<AudioDeviceNames> device_names) {
   NOTREACHED();
 }
 
 bool WebrtcAudioPrivateFunction::GetControllerList(const RequestInfo& request) {
   content::RenderProcessHost* rph = nullptr;
 
   // If |guest_process_id| is defined, directly use this id to find the
   // corresponding RenderProcessHost.
   if (request.guest_process_id.get()) {
     rph = content::RenderProcessHost::FromID(*request.guest_process_id.get());
@@ skipping 75 matching lines @@
 bool WebrtcAudioPrivateGetSinksFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   InitDeviceIDSalt();
   GetOutputDeviceNames();
 
   return true;
 }
 
 void WebrtcAudioPrivateGetSinksFunction::OnOutputDeviceNames(
-    scoped_ptr<AudioDeviceNames> raw_ids) {
+    std::unique_ptr<AudioDeviceNames> raw_ids) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::vector<wap::SinkInfo> results;
   for (const media::AudioDeviceName& name : *raw_ids) {
     wap::SinkInfo info;
     info.sink_id = CalculateHMACImpl(name.unique_id);
     info.sink_label = name.device_name;
     // TODO(joi): Add other parameters.
     results.push_back(std::move(info));
   }
@@ skipping 15 matching lines @@
 }
 
 void WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread() {
   SendResponse(true);
 }
 
 bool WebrtcAudioPrivateGetActiveSinkFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   InitDeviceIDSalt();
 
-  scoped_ptr<wap::GetActiveSink::Params> params(
+  std::unique_ptr<wap::GetActiveSink::Params> params(
       wap::GetActiveSink::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   return GetControllerList(params->request);
 }
 
 void WebrtcAudioPrivateGetActiveSinkFunction::OnControllerList(
     const RenderProcessHost::AudioOutputControllerList& controllers) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 34 matching lines @@
     WebrtcAudioPrivateSetActiveSinkFunction()
     : num_remaining_sink_ids_(0) {
 }
 
 WebrtcAudioPrivateSetActiveSinkFunction::
 ~WebrtcAudioPrivateSetActiveSinkFunction() {
 }
 
 bool WebrtcAudioPrivateSetActiveSinkFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  scoped_ptr<wap::SetActiveSink::Params> params(
+  std::unique_ptr<wap::SetActiveSink::Params> params(
       wap::SetActiveSink::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   InitDeviceIDSalt();
 
   if (params->request.guest_process_id.get()) {
     request_info_.guest_process_id.reset(
         new int(*params->request.guest_process_id.get()));
   } else if (params->request.tab_id.get()) {
     request_info_.tab_id.reset(new int(*params->request.tab_id.get()));
@@ skipping 29 matching lines @@
     SendResponse(false);
   } else {
     // We need to get the output device names, and calculate the HMAC
     // for each, to find the raw ID for the ID provided to this API
     // function call.
     GetOutputDeviceNames();
   }
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::OnOutputDeviceNames(
-    scoped_ptr<AudioDeviceNames> device_names) {
+    std::unique_ptr<AudioDeviceNames> device_names) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::string raw_sink_id;
   if (sink_id_ == media::AudioManagerBase::kDefaultDeviceId) {
     DVLOG(2) << "Received default ID, replacing with empty ID.";
     raw_sink_id = "";
   } else {
     for (AudioDeviceNames::const_iterator it = device_names->begin();
          it != device_names->end();
          ++it) {
@@ skipping 118 matching lines @@
     results_.reset(wap::GetAssociatedSink::Results::Create("").release());
   } else {
     results_.reset(
         wap::GetAssociatedSink::Results::Create(associated_sink_id).release());
   }
 
   SendResponse(true);
 }
 
 }  // namespace extensions