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

content/renderer/pepper/pepper_video_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_video_encoder_host.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
@@ skipping 158 matching lines @@
       return !accelerated;
     case PP_HARDWAREACCELERATION_WITHFALLBACK:
       return true;
     // No default case, to catch unhandled PP_HardwareAcceleration values.
   }
   return false;
 }
 
 }  // namespace
 
-PepperVideoEncoderHost::ShmBuffer::ShmBuffer(uint32_t id,
-                                             scoped_ptr<base::SharedMemory> shm)
+PepperVideoEncoderHost::ShmBuffer::ShmBuffer(
+    uint32_t id,
+    std::unique_ptr<base::SharedMemory> shm)
     : id(id), shm(std::move(shm)), in_use(true) {
   DCHECK(this->shm);
 }
 
 PepperVideoEncoderHost::ShmBuffer::~ShmBuffer() {
 }
 
 media::BitstreamBuffer PepperVideoEncoderHost::ShmBuffer::ToBitstreamBuffer() {
   return media::BitstreamBuffer(id, shm->handle(), shm->mapped_size());
 }
@@ skipping 179 matching lines @@
     const gfx::Size& input_coded_size,
     size_t output_buffer_size) {
   DCHECK(RenderThreadImpl::current());
   // We assume RequireBitstreamBuffers is only called once.
   DCHECK(!initialized_);
 
   input_coded_size_ = input_coded_size;
   frame_count_ = frame_count;
 
   for (uint32_t i = 0; i < kDefaultNumberOfBitstreamBuffers; ++i) {
-    scoped_ptr<base::SharedMemory> shm(
+    std::unique_ptr<base::SharedMemory> shm(
         RenderThread::Get()->HostAllocateSharedMemoryBuffer(
             output_buffer_size));
 
     if (!shm || !shm->Map(output_buffer_size)) {
       shm_buffers_.clear();
       break;
     }
 
     shm_buffers_.push_back(new ShmBuffer(i, std::move(shm)));
   }
@@ skipping 177 matching lines @@
       media::VideoFrame::AllocationSize(media_input_format_, input_coded_size_);
   uint32_t frame_size = size.ValueOrDie();
   size += sizeof(ppapi::MediaStreamBuffer::Video);
   uint32_t buffer_size = size.ValueOrDie();
   // Make each buffer 4 byte aligned.
   size += (4 - buffer_size % 4);
   uint32_t buffer_size_aligned = size.ValueOrDie();
   size *= frame_count_;
   uint32_t total_size = size.ValueOrDie();
 
-  scoped_ptr<base::SharedMemory> shm(
+  std::unique_ptr<base::SharedMemory> shm(
       RenderThreadImpl::current()->HostAllocateSharedMemoryBuffer(total_size));
   if (!shm ||
       !buffer_manager_.SetBuffers(frame_count_, buffer_size_aligned,
                                   std::move(shm), true)) {
     SendGetFramesErrorReply(PP_ERROR_NOMEMORY);
     return;
   }
 
   VLOG(4) << " frame_count=" << frame_count_ << " frame_size=" << frame_size
           << " buffer_size=" << buffer_size_aligned;
@@ skipping 77 matching lines @@
 }
 
 uint8_t* PepperVideoEncoderHost::ShmHandleToAddress(int32_t buffer_id) {
   DCHECK(RenderThreadImpl::current());
   DCHECK_GE(buffer_id, 0);
   DCHECK_LT(buffer_id, static_cast<int32_t>(shm_buffers_.size()));
   return static_cast<uint8_t*>(shm_buffers_[buffer_id]->shm->memory());
 }
 
 }  // namespace content