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

media/cast/sender/audio_encoder.cc

 // Copyright 2014 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/cast/sender/audio_encoder.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 68 matching lines @@
   OperationalStatus InitializationResult() const {
     return operational_status_;
   }
 
   int samples_per_frame() const {
     return samples_per_frame_;
   }
 
   base::TimeDelta frame_duration() const { return frame_duration_; }
 
-  void EncodeAudio(scoped_ptr<AudioBus> audio_bus,
+  void EncodeAudio(std::unique_ptr<AudioBus> audio_bus,
                    const base::TimeTicks& recorded_time) {
     DCHECK_EQ(operational_status_, STATUS_INITIALIZED);
     DCHECK(!recorded_time.is_null());
 
     // Determine whether |recorded_time| is consistent with the amount of audio
     // data having been processed in the past.  Resolve the underrun problem by
     // dropping data from the internal buffer and skipping ahead the next
     // frame's RTP timestamp by the estimated number of frames missed.  On the
     // other hand, don't attempt to resolve overruns: A receiver should
     // gracefully deal with an excess of audio data.
@@ skipping 32 matching lines @@
           samples_per_frame_ - buffer_fill_end_, audio_bus->frames() - src_pos);
       DCHECK_EQ(audio_bus->channels(), num_channels_);
       TransferSamplesIntoBuffer(
           audio_bus.get(), src_pos, buffer_fill_end_, num_samples_to_xfer);
       src_pos += num_samples_to_xfer;
       buffer_fill_end_ += num_samples_to_xfer;
 
       if (buffer_fill_end_ < samples_per_frame_)
         break;
 
-      scoped_ptr<SenderEncodedFrame> audio_frame(
-          new SenderEncodedFrame());
+      std::unique_ptr<SenderEncodedFrame> audio_frame(new SenderEncodedFrame());
       audio_frame->dependency = EncodedFrame::KEY;
       audio_frame->frame_id = frame_id_;
       audio_frame->referenced_frame_id = frame_id_;
       audio_frame->rtp_timestamp = frame_rtp_timestamp_;
       audio_frame->reference_time = frame_capture_time_;
 
       TRACE_EVENT_ASYNC_BEGIN2(
           "cast.stream",
           "Audio Encode", audio_frame.get(),
           "frame_id", frame_id_,
@@ skipping 160 matching lines @@
   static bool IsValidFrameDuration(base::TimeDelta duration) {
     // See https://tools.ietf.org/html/rfc6716#section-2.1.4
     return duration == base::TimeDelta::FromMicroseconds(2500) ||
            duration == base::TimeDelta::FromMilliseconds(5) ||
            duration == base::TimeDelta::FromMilliseconds(10) ||
            duration == base::TimeDelta::FromMilliseconds(20) ||
            duration == base::TimeDelta::FromMilliseconds(40) ||
            duration == base::TimeDelta::FromMilliseconds(60);
   }
 
-  const scoped_ptr<uint8_t[]> encoder_memory_;
+  const std::unique_ptr<uint8_t[]> encoder_memory_;
   OpusEncoder* const opus_encoder_;
-  const scoped_ptr<float[]> buffer_;
+  const std::unique_ptr<float[]> buffer_;
 
   // This is the recommended value, according to documentation in
   // third_party/opus/src/include/opus.h, so that the Opus encoder does not
   // degrade the audio due to memory constraints.
   //
   // Note: Whereas other RTP implementations do not, the cast library is
   // perfectly capable of transporting larger than MTU-sized audio frames.
   static const int kOpusMaxPayloadSize = 4000;
 
   DISALLOW_COPY_AND_ASSIGN(OpusImpl);
@@ skipping 151 matching lines @@
         return false;
       }
     }
 
     // This is the only location where the implementation modifies
     // |max_access_unit_size_|.
     const_cast<uint32_t&>(max_access_unit_size_) = max_access_unit_size;
 
     // Allocate a buffer to store one access unit. This is the only location
     // where the implementation modifies |access_unit_buffer_|.
-    const_cast<scoped_ptr<uint8_t[]>&>(access_unit_buffer_)
+    const_cast<std::unique_ptr<uint8_t[]>&>(access_unit_buffer_)
         .reset(new uint8_t[max_access_unit_size]);
 
     // Initialize the converter ABL. Note that the buffer size has to be set
     // before every encode operation, since the field is modified to indicate
     // the size of the output data (on input it indicates the buffer capacity).
     converter_abl_.mNumberBuffers = 1;
     converter_abl_.mBuffers[0].mNumberChannels = num_channels_;
     converter_abl_.mBuffers[0].mData = access_unit_buffer_.get();
 
     // The "magic cookie" is an encoder state vector required for decoding and
     // packetization. It is queried now from |converter_| then set on |file_|
     // after initialization.
     UInt32 cookie_size;
     if (AudioConverterGetPropertyInfo(converter_,
                                       kAudioConverterCompressionMagicCookie,
                                       &cookie_size,
                                       nullptr) != noErr) {
       return false;
     }
-    scoped_ptr<uint8_t[]> cookie_data(new uint8_t[cookie_size]);
+    std::unique_ptr<uint8_t[]> cookie_data(new uint8_t[cookie_size]);
     if (AudioConverterGetProperty(converter_,
                                   kAudioConverterCompressionMagicCookie,
                                   &cookie_size,
                                   cookie_data.get()) != noErr) {
       return false;
     }
 
     if (AudioFileInitializeWithCallbacks(this,
                                          &FileReadCallback,
                                          &FileWriteCallback,
@@ skipping 156 matching lines @@
     return 0;
   }
 
   // The AudioFile setsize callback function.
   static OSStatus FileSetSizeCallback(void* in_encoder, SInt64 in_size) {
     return noErr;
   }
 
   // Buffer that holds one AAC access unit worth of samples. The input callback
   // function provides samples from this buffer via |input_bus_| to the encoder.
-  const scoped_ptr<AudioBus> input_buffer_;
+  const std::unique_ptr<AudioBus> input_buffer_;
 
   // Wrapper AudioBus used by the input callback function. Normally it wraps
   // |input_buffer_|. However, as an optimization when the client submits a
   // buffer containing exactly one access unit worth of samples, the bus is
   // redirected to the client buffer temporarily. We know that the base
   // implementation will call us right after to encode the buffer and thus we
   // can eliminate the copy into |input_buffer_|.
-  const scoped_ptr<AudioBus> input_bus_;
+  const std::unique_ptr<AudioBus> input_bus_;
 
   // A buffer that holds one AAC access unit. Initialized in |Initialize| once
   // the maximum access unit size is known.
-  const scoped_ptr<uint8_t[]> access_unit_buffer_;
+  const std::unique_ptr<uint8_t[]> access_unit_buffer_;
 
   // The maximum size of an access unit that the encoder can emit.
   const uint32_t max_access_unit_size_;
 
   // A temporary pointer to the current output buffer. Only non-null when
   // writing an access unit. Accessed by the AudioFile write callback function.
   std::string* output_buffer_;
 
   // The |AudioConverter| is responsible for AAC encoding. This is a Core Audio
   // object, not to be confused with |media::AudioConverter|.
@@ skipping 57 matching lines @@
     out->resize(num_channels_ * samples_per_frame_ * sizeof(int16_t));
     const int16_t* src = buffer_.get();
     const int16_t* const src_end = src + num_channels_ * samples_per_frame_;
     uint16_t* dest = reinterpret_cast<uint16_t*>(&out->at(0));
     for (; src < src_end; ++src, ++dest)
       *dest = base::HostToNet16(*src);
     return true;
   }
 
  private:
-  const scoped_ptr<int16_t[]> buffer_;
+  const std::unique_ptr<int16_t[]> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Pcm16Impl);
 };
 
 AudioEncoder::AudioEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
     int num_channels,
     int sampling_rate,
     int bitrate,
     Codec codec,
@@ skipping 54 matching lines @@
 
 base::TimeDelta AudioEncoder::GetFrameDuration() const {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
   if (InitializationResult() != STATUS_INITIALIZED) {
     NOTREACHED();
     return base::TimeDelta();
   }
   return impl_->frame_duration();
 }
 
-void AudioEncoder::InsertAudio(scoped_ptr<AudioBus> audio_bus,
+void AudioEncoder::InsertAudio(std::unique_ptr<AudioBus> audio_bus,
                                const base::TimeTicks& recorded_time) {
   DCHECK(insert_thread_checker_.CalledOnValidThread());
   DCHECK(audio_bus.get());
   if (InitializationResult() != STATUS_INITIALIZED) {
     NOTREACHED();
     return;
   }
   cast_environment_->PostTask(CastEnvironment::AUDIO,
                               FROM_HERE,
                               base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
                                          impl_,
                                          base::Passed(&audio_bus),
                                          recorded_time));
 }
 
 }  // namespace cast
 }  // namespace media