Replace scoped_ptr with std::unique_ptr in //media/base.

media/base/audio_bus.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/base/audio_bus.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/limits.h"
 #include "media/base/vector_math.h"
 
 namespace media {
 
 static const uint8_t kUint8Bias = 128;
 
 static bool IsAligned(void* ptr) {
@@ skipping 123 matching lines @@
     : channel_data_(channels),
       frames_(0),
       can_set_channel_data_(true) {
   CHECK_GT(channels, 0);
   for (size_t i = 0; i < channel_data_.size(); ++i)
     channel_data_[i] = NULL;
 }
 
 AudioBus::~AudioBus() {}
 
-scoped_ptr<AudioBus> AudioBus::Create(int channels, int frames) {
-  return scoped_ptr<AudioBus>(new AudioBus(channels, frames));
+std::unique_ptr<AudioBus> AudioBus::Create(int channels, int frames) {
+  return base::WrapUnique(new AudioBus(channels, frames));
 }
 
-scoped_ptr<AudioBus> AudioBus::Create(const AudioParameters& params) {
-  return scoped_ptr<AudioBus>(new AudioBus(
-      params.channels(), params.frames_per_buffer()));
+std::unique_ptr<AudioBus> AudioBus::Create(const AudioParameters& params) {
+  return base::WrapUnique(
+      new AudioBus(params.channels(), params.frames_per_buffer()));
 }
 
-scoped_ptr<AudioBus> AudioBus::CreateWrapper(int channels) {
-  return scoped_ptr<AudioBus>(new AudioBus(channels));
+std::unique_ptr<AudioBus> AudioBus::CreateWrapper(int channels) {
+  return base::WrapUnique(new AudioBus(channels));
 }
 
-scoped_ptr<AudioBus> AudioBus::WrapVector(
-    int frames, const std::vector<float*>& channel_data) {
-  return scoped_ptr<AudioBus>(new AudioBus(frames, channel_data));
+std::unique_ptr<AudioBus> AudioBus::WrapVector(
+    int frames,
+    const std::vector<float*>& channel_data) {
+  return base::WrapUnique(new AudioBus(frames, channel_data));
 }
 
-scoped_ptr<AudioBus> AudioBus::WrapMemory(int channels, int frames,
-                                          void* data) {
+std::unique_ptr<AudioBus> AudioBus::WrapMemory(int channels,
+                                               int frames,
+                                               void* data) {
   // |data| must be aligned by AudioBus::kChannelAlignment.
   CHECK(IsAligned(data));
-  return scoped_ptr<AudioBus>(new AudioBus(
-      channels, frames, static_cast<float*>(data)));
+  return base::WrapUnique(
+      new AudioBus(channels, frames, static_cast<float*>(data)));
 }
 
-scoped_ptr<AudioBus> AudioBus::WrapMemory(const AudioParameters& params,
-                                          void* data) {
+std::unique_ptr<AudioBus> AudioBus::WrapMemory(const AudioParameters& params,
+                                               void* data) {
   // |data| must be aligned by AudioBus::kChannelAlignment.
   CHECK(IsAligned(data));
-  return scoped_ptr<AudioBus>(new AudioBus(
-      params.channels(), params.frames_per_buffer(),
-      static_cast<float*>(data)));
+  return base::WrapUnique(new AudioBus(params.channels(),
+                                       params.frames_per_buffer(),
+                                       static_cast<float*>(data)));
 }
 
 void AudioBus::SetChannelData(int channel, float* data) {
   CHECK(can_set_channel_data_);
   CHECK(data);
   CHECK_GE(channel, 0);
   CHECK_LT(static_cast<size_t>(channel), channel_data_.size());
   DCHECK(IsAligned(data));
   channel_data_[channel] = data;
 }
@@ skipping 167 matching lines @@
   return scoped_refptr<AudioBusRefCounted>(
       new AudioBusRefCounted(channels, frames));
 }
 
 AudioBusRefCounted::AudioBusRefCounted(int channels, int frames)
     : AudioBus(channels, frames) {}
 
 AudioBusRefCounted::~AudioBusRefCounted() {}
 
 }  // namespace media