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

media/base/audio_bus.h

 // 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.
 
 #ifndef MEDIA_BASE_AUDIO_BUS_H_
 #define MEDIA_BASE_AUDIO_BUS_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "media/base/media_export.h"
 
 namespace media {
 class AudioParameters;
 
 // Scoped container for "busing" audio channel data around.  Each channel is
 // stored in planar format and guaranteed to be aligned by kChannelAlignment.
 // AudioBus objects can be created normally or via wrapping.  Normally, AudioBus
 // will dice up a contiguous memory block for channel data.  When wrapped,
 // AudioBus instead routes requests for channel data to the wrapped object.
 class MEDIA_EXPORT AudioBus {
  public:
   // Guaranteed alignment of each channel's data; use 16-byte alignment for easy
   // SSE optimizations.
   enum { kChannelAlignment = 16 };
 
   // Creates a new AudioBus and allocates |channels| of length |frames|.  Uses
   // channels() and frames_per_buffer() from AudioParameters if given.
-  static scoped_ptr<AudioBus> Create(int channels, int frames);
-  static scoped_ptr<AudioBus> Create(const AudioParameters& params);
+  static std::unique_ptr<AudioBus> Create(int channels, int frames);
+  static std::unique_ptr<AudioBus> Create(const AudioParameters& params);
 
   // Creates a new AudioBus with the given number of channels, but zero length.
   // It's expected to be used with SetChannelData() and set_frames() to
   // wrap externally allocated memory.
-  static scoped_ptr<AudioBus> CreateWrapper(int channels);
+  static std::unique_ptr<AudioBus> CreateWrapper(int channels);
 
   // Creates a new AudioBus from an existing channel vector.  Does not transfer
   // ownership of |channel_data| to AudioBus; i.e., |channel_data| must outlive
   // the returned AudioBus.  Each channel must be aligned by kChannelAlignment.
-  static scoped_ptr<AudioBus> WrapVector(
-      int frames, const std::vector<float*>& channel_data);
+  static std::unique_ptr<AudioBus> WrapVector(
+      int frames,
+      const std::vector<float*>& channel_data);
 
   // Creates a new AudioBus by wrapping an existing block of memory.  Block must
   // be at least CalculateMemorySize() bytes in size.  |data| must outlive the
   // returned AudioBus.  |data| must be aligned by kChannelAlignment.
-  static scoped_ptr<AudioBus> WrapMemory(int channels, int frames, void* data);
-  static scoped_ptr<AudioBus> WrapMemory(const AudioParameters& params,
-                                         void* data);
+  static std::unique_ptr<AudioBus> WrapMemory(int channels,
+                                              int frames,
+                                              void* data);
+  static std::unique_ptr<AudioBus> WrapMemory(const AudioParameters& params,
+                                              void* data);
   static int CalculateMemorySize(const AudioParameters& params);
 
   // Calculates the required size for an AudioBus given the number of channels
   // and frames.
   static int CalculateMemorySize(int channels, int frames);
 
   // Helper methods for converting an AudioBus from and to interleaved integer
   // data.  Expects interleaving to be [ch0, ch1, ..., chN, ch0, ch1, ...] with
   // |bytes_per_sample| per value.  Values are scaled and bias corrected during
   // conversion.  ToInterleaved() will also clip values to format range.
@@ skipping 59 matching lines @@
   AudioBus(int channels, int frames, float* data);
   AudioBus(int frames, const std::vector<float*>& channel_data);
   explicit AudioBus(int channels);
 
  private:
   // Helper method for building |channel_data_| from a block of memory.  |data|
   // must be at least BlockSize() bytes in size.
   void BuildChannelData(int channels, int aligned_frame, float* data);
 
   // Contiguous block of channel memory.
-  scoped_ptr<float, base::AlignedFreeDeleter> data_;
+  std::unique_ptr<float, base::AlignedFreeDeleter> data_;
 
   std::vector<float*> channel_data_;
   int frames_;
 
   // Protect SetChannelData() and set_frames() for use by CreateWrapper().
   bool can_set_channel_data_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioBus);
 };
 
@@ skipping 11 matching lines @@
 
   AudioBusRefCounted(int channels, int frames);
   ~AudioBusRefCounted() override;
 
   DISALLOW_COPY_AND_ASSIGN(AudioBusRefCounted);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_AUDIO_BUS_H_