Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/pepper/pepper_audio_encoder_host.cc

 // Copyright 2015 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 "content/renderer/pepper/pepper_audio_encoder_host.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 54 matching lines @@
 
   // Used on the media thread.
   void Encode(uint8_t* input_data,
               size_t input_size,
               uint8_t* output_data,
               size_t output_size,
               BitstreamBufferReadyCB callback);
   void RequestBitrateChange(uint32_t bitrate);
 
  private:
-  scoped_ptr<uint8_t[]> encoder_memory_;
+  std::unique_ptr<uint8_t[]> encoder_memory_;
   OpusEncoder* opus_encoder_;
 
   // Initialization parameters, only valid if |encoder_memory_| is not
   // nullptr.
   ppapi::proxy::PPB_AudioEncodeParameters parameters_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioEncoderImpl);
 };
 
 PepperAudioEncoderHost::AudioEncoderImpl::AudioEncoderImpl()
@@ skipping 23 matching lines @@
     const ppapi::proxy::PPB_AudioEncodeParameters& parameters) {
   if (parameters.output_profile != PP_AUDIOPROFILE_OPUS)
     return false;
 
   DCHECK(!encoder_memory_);
 
   int32_t encoder_size = opus_encoder_get_size(parameters.channels);
   if (encoder_size < 1)
     return false;
 
-  scoped_ptr<uint8_t[]> encoder_memory(new uint8_t[encoder_size]);
+  std::unique_ptr<uint8_t[]> encoder_memory(new uint8_t[encoder_size]);
   opus_encoder_ = reinterpret_cast<OpusEncoder*>(encoder_memory.get());
 
   if (opus_encoder_init(opus_encoder_, parameters.input_sample_rate,
                         parameters.channels, OPUS_APPLICATION_AUDIO) != OPUS_OK)
     return false;
 
   if (opus_encoder_ctl(opus_encoder_,
                        OPUS_SET_BITRATE(parameters.initial_bitrate <= 0
                                             ? OPUS_AUTO
                                             : parameters.initial_bitrate)) !=
@@ skipping 85 matching lines @@
 
 int32_t PepperAudioEncoderHost::OnHostMsgInitialize(
     ppapi::host::HostMessageContext* context,
     const ppapi::proxy::PPB_AudioEncodeParameters& parameters) {
   if (initialized_)
     return PP_ERROR_FAILED;
 
   if (!IsInitializationValid(parameters))
     return PP_ERROR_NOTSUPPORTED;
 
-  scoped_ptr<AudioEncoderImpl> encoder(new AudioEncoderImpl);
+  std::unique_ptr<AudioEncoderImpl> encoder(new AudioEncoderImpl);
   if (!encoder->Initialize(parameters))
     return PP_ERROR_FAILED;
   if (!AllocateBuffers(parameters, encoder->GetNumberOfSamplesPerFrame()))
     return PP_ERROR_NOMEMORY;
 
   initialized_ = true;
   encoder_last_error_ = PP_OK;
   encoder_.swap(encoder);
 
   ppapi::host::ReplyMessageContext reply_context =
@@ skipping 121 matching lines @@
   bitstream_buffer_size *= 2;
   bitstream_buffer_size += sizeof(ppapi::MediaStreamBuffer::Bitstream);
   base::CheckedNumeric<size_t> total_bitstream_memory_size =
       bitstream_buffer_size;
   total_bitstream_memory_size *= kDefaultNumberOfAudioBuffers;
 
   if (!total_audio_memory_size.IsValid() ||
       !total_bitstream_memory_size.IsValid())
     return false;
 
-  scoped_ptr<base::SharedMemory> audio_memory(
+  std::unique_ptr<base::SharedMemory> audio_memory(
       RenderThreadImpl::current()->HostAllocateSharedMemoryBuffer(
           total_audio_memory_size.ValueOrDie()));
   if (!audio_memory)
     return false;
-  scoped_ptr<ppapi::MediaStreamBufferManager> audio_buffer_manager(
+  std::unique_ptr<ppapi::MediaStreamBufferManager> audio_buffer_manager(
       new ppapi::MediaStreamBufferManager(this));
   if (!audio_buffer_manager->SetBuffers(kDefaultNumberOfAudioBuffers,
                                         total_audio_buffer_size.ValueOrDie(),
                                         std::move(audio_memory), false))
     return false;
 
   for (int32_t i = 0; i < audio_buffer_manager->number_of_buffers(); ++i) {
     ppapi::MediaStreamBuffer::Audio* buffer =
         &(audio_buffer_manager->GetBufferPointer(i)->audio);
     buffer->header.size = total_audio_buffer_size.ValueOrDie();
     buffer->header.type = ppapi::MediaStreamBuffer::TYPE_AUDIO;
     buffer->sample_rate =
         static_cast<PP_AudioBuffer_SampleRate>(parameters.input_sample_rate);
     buffer->number_of_channels = parameters.channels;
     buffer->number_of_samples = samples_per_frame;
     buffer->data_size = audio_buffer_size.ValueOrDie();
   }
 
-  scoped_ptr<base::SharedMemory> bitstream_memory(
+  std::unique_ptr<base::SharedMemory> bitstream_memory(
       RenderThreadImpl::current()->HostAllocateSharedMemoryBuffer(
           total_bitstream_memory_size.ValueOrDie()));
   if (!bitstream_memory)
     return false;
-  scoped_ptr<ppapi::MediaStreamBufferManager> bitstream_buffer_manager(
+  std::unique_ptr<ppapi::MediaStreamBufferManager> bitstream_buffer_manager(
       new ppapi::MediaStreamBufferManager(this));
   if (!bitstream_buffer_manager->SetBuffers(kDefaultNumberOfAudioBuffers,
                                             bitstream_buffer_size.ValueOrDie(),
                                             std::move(bitstream_memory), true))
     return false;
 
   for (int32_t i = 0; i < bitstream_buffer_manager->number_of_buffers(); ++i) {
     ppapi::MediaStreamBuffer::Bitstream* buffer =
         &(bitstream_buffer_manager->GetBufferPointer(i)->bitstream);
     buffer->header.size = bitstream_buffer_size.ValueOrDie();
@@ skipping 80 matching lines @@
   // to avoid freeing memory the encoder might still be working on.
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&StopAudioEncoder, base::Passed(std::move(encoder_)),
                  base::Passed(std::move(audio_buffer_manager_)),
                  base::Passed(std::move(bitstream_buffer_manager_))));
 }
 
 // static
 void PepperAudioEncoderHost::StopAudioEncoder(
-    scoped_ptr<AudioEncoderImpl> encoder,
-    scoped_ptr<ppapi::MediaStreamBufferManager> audio_buffer_manager,
-    scoped_ptr<ppapi::MediaStreamBufferManager> bitstream_buffer_manager) {}
+    std::unique_ptr<AudioEncoderImpl> encoder,
+    std::unique_ptr<ppapi::MediaStreamBufferManager> audio_buffer_manager,
+    std::unique_ptr<ppapi::MediaStreamBufferManager> bitstream_buffer_manager) {
+}
 
 }  // namespace content