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

media/audio/mac/audio_manager_mac.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 "media/audio/mac/audio_manager_mac.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 115 matching lines @@
                                                    0,
                                                    NULL,
                                                    &size);
   if (result || !size)
     return;
 
   int device_count = size / sizeof(AudioDeviceID);
 
   // Get the array of device ids for all the devices, which includes both
   // input devices and output devices.
-  scoped_ptr<AudioDeviceID, base::FreeDeleter>
-      devices(static_cast<AudioDeviceID*>(malloc(size)));
+  std::unique_ptr<AudioDeviceID, base::FreeDeleter> devices(

[danakj, 2016/04/22 22:47:37]

include memory

[dcheng, 2016/04/22 23:13:20]

Already in related header.

+      static_cast<AudioDeviceID*>(malloc(size)));
   AudioDeviceID* device_ids = devices.get();
   result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                       &property_address,
                                       0,
                                       NULL,
                                       &size,
                                       device_ids);
   if (result)
     return;
 
@@ skipping 257 matching lines @@
   AudioObjectPropertyAddress pa;
   pa.mSelector = kAudioDevicePropertyStreamConfiguration;
   pa.mScope = scope;
   pa.mElement = kAudioObjectPropertyElementMaster;
 
   UInt32 size;
   OSStatus result = AudioObjectGetPropertyDataSize(device, &pa, 0, 0, &size);
   if (result != noErr || !size)
     return false;
 
-  scoped_ptr<uint8_t[]> list_storage(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> list_storage(new uint8_t[size]);
   AudioBufferList& buffer_list =
       *reinterpret_cast<AudioBufferList*>(list_storage.get());
 
   result = AudioObjectGetPropertyData(device, &pa, 0, 0, &size, &buffer_list);
   if (result != noErr)
     return false;
 
   // Determine number of channels based on the AudioBufferList.
   // |mNumberBuffers] is the  number of interleaved channels in the buffer.
   // If the number is 1, the buffer is noninterleaved.
@@ skipping 101 matching lines @@
   AudioObjectPropertyAddress pa = {
     kAudioDevicePropertyRelatedDevices,
     kAudioDevicePropertyScopeOutput,
     kAudioObjectPropertyElementMaster
   };
   OSStatus result = AudioObjectGetPropertyDataSize(device, &pa, 0, 0, &size);
   if (result || !size)
     return std::string();
 
   int device_count = size / sizeof(AudioDeviceID);
-  scoped_ptr<AudioDeviceID, base::FreeDeleter>
-      devices(static_cast<AudioDeviceID*>(malloc(size)));
+  std::unique_ptr<AudioDeviceID, base::FreeDeleter> devices(
+      static_cast<AudioDeviceID*>(malloc(size)));
   result = AudioObjectGetPropertyData(
       device, &pa, 0, NULL, &size, devices.get());
   if (result)
     return std::string();
 
   std::vector<std::string> associated_devices;
   for (int i = 0; i < device_count; ++i) {
     // Get the number of  output channels of the device.
     pa.mSelector = kAudioDevicePropertyStreams;
     size = 0;
@@ skipping 388 matching lines @@
 ScopedAudioManagerPtr CreateAudioManager(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner,
     AudioLogFactory* audio_log_factory) {
   return ScopedAudioManagerPtr(
       new AudioManagerMac(std::move(task_runner), std::move(worker_task_runner),
                           audio_log_factory));
 }
 
 }  // namespace media