Convert //media/audio from scoped_ptr to std::unique_ptr

media/audio/alsa/audio_manager_alsa.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 "media/audio/alsa/audio_manager_alsa.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/environment.h"
@@ skipping 35 matching lines @@
 static const char* kInvalidAudioInputDevices[] = {
   "default",
   "dmix",
   "null",
   "pulse",
   "surround",
 };
 
 // static
 void AudioManagerAlsa::ShowLinuxAudioInputSettings() {
-  scoped_ptr<base::Environment> env(base::Environment::Create());
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   switch (base::nix::GetDesktopEnvironment(env.get())) {
     case base::nix::DESKTOP_ENVIRONMENT_GNOME:
       command_line.SetProgram(base::FilePath("gnome-volume-control"));
       break;
     case base::nix::DESKTOP_ENVIRONMENT_KDE3:
     case base::nix::DESKTOP_ENVIRONMENT_KDE4:
     case base::nix::DESKTOP_ENVIRONMENT_KDE5:
       command_line.SetProgram(base::FilePath("kmix"));
       break;
@@ skipping 88 matching lines @@
     media::AudioDeviceNames* device_names) {
   static const char kIoHintName[] = "IOID";
   static const char kNameHintName[] = "NAME";
   static const char kDescriptionHintName[] = "DESC";
 
   const char* unwanted_device_type = UnwantedDeviceTypeWhenEnumerating(type);
 
   for (void** hint_iter = hints; *hint_iter != NULL; hint_iter++) {
     // Only examine devices of the right type.  Valid values are
     // "Input", "Output", and NULL which means both input and output.
-    scoped_ptr<char, base::FreeDeleter> io(wrapper_->DeviceNameGetHint(
-        *hint_iter, kIoHintName));
+    std::unique_ptr<char, base::FreeDeleter> io(
+        wrapper_->DeviceNameGetHint(*hint_iter, kIoHintName));
     if (io != NULL && strcmp(unwanted_device_type, io.get()) == 0)
       continue;
 
     // Found a device, prepend the default device since we always want
     // it to be on the top of the list for all platforms. And there is
     // no duplicate counting here since it is only done if the list is
     // still empty.  Note, pulse has exclusively opened the default
     // device, so we must open the device via the "default" moniker.
     if (device_names->empty()) {
       device_names->push_front(
           media::AudioDeviceName(AudioManager::GetDefaultDeviceName(),
                                  AudioManagerBase::kDefaultDeviceId));
     }
 
     // Get the unique device name for the device.
-    scoped_ptr<char, base::FreeDeleter> unique_device_name(
+    std::unique_ptr<char, base::FreeDeleter> unique_device_name(
         wrapper_->DeviceNameGetHint(*hint_iter, kNameHintName));
 
     // Find out if the device is available.
     if (IsAlsaDeviceAvailable(type, unique_device_name.get())) {
       // Get the description for the device.
-      scoped_ptr<char, base::FreeDeleter> desc(wrapper_->DeviceNameGetHint(
-          *hint_iter, kDescriptionHintName));
+      std::unique_ptr<char, base::FreeDeleter> desc(
+          wrapper_->DeviceNameGetHint(*hint_iter, kDescriptionHintName));
 
       media::AudioDeviceName name;
       name.unique_id = unique_device_name.get();
       if (desc) {
         // Use the more user friendly description as name.
         // Replace '\n' with '-'.
         char* pret = strchr(desc.get(), '\n');
         if (pret)
           *pret = '-';
         name.device_name = desc.get();
@@ skipping 55 matching lines @@
 
   // Loop through the sound cards.
   // Don't use snd_device_name_hint(-1,..) since there is a access violation
   // inside this ALSA API with libasound.so.2.0.0.
   while (!wrapper_->CardNext(&card) && (card >= 0) && !has_device) {
     int error = wrapper_->DeviceNameHint(card, kPcmInterfaceName, &hints);
     if (!error) {
       for (void** hint_iter = hints; *hint_iter != NULL; hint_iter++) {
         // Only examine devices that are |stream| capable.  Valid values are
         // "Input", "Output", and NULL which means both input and output.
-        scoped_ptr<char, base::FreeDeleter> io(wrapper_->DeviceNameGetHint(
-            *hint_iter, kIoHintName));
+        std::unique_ptr<char, base::FreeDeleter> io(
+            wrapper_->DeviceNameGetHint(*hint_iter, kIoHintName));
         const char* unwanted_type = UnwantedDeviceTypeWhenEnumerating(stream);
         if (io != NULL && strcmp(unwanted_type, io.get()) == 0)
           continue;  // Wrong type, skip the device.
 
         // Found an input device.
         has_device = true;
         break;
       }
 
       // Destroy the hints now that we're done with it.
@@ skipping 82 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAlsaInputDevice)) {
     device_name = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
         switches::kAlsaInputDevice);
   }
 
   return new AlsaPcmInputStream(this, device_name, params, wrapper_.get());
 }
 
 }  // namespace media