Convert //ppapi to use std::unique_ptr

ppapi/proxy/video_encoder_resource.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 "ppapi/proxy/video_encoder_resource.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/numerics/safe_conversions.h"
 #include "ppapi/c/pp_array_output.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/video_frame_resource.h"
 #include "ppapi/shared_impl/array_writer.h"
 #include "ppapi/shared_impl/media_stream_buffer.h"
 #include "ppapi/shared_impl/media_stream_buffer_manager.h"
 #include "ppapi/thunk/enter.h"
 
@@ skipping 32 matching lines @@
                                    : PP_HARDWAREACCELERATION_NONE;
 
     profiles_0_1.push_back(profile_0_1);
   }
 
   return profiles_0_1;
 }
 
 }  // namespace
 
-VideoEncoderResource::ShmBuffer::ShmBuffer(uint32_t id,
-                                           scoped_ptr<base::SharedMemory> shm)
+VideoEncoderResource::ShmBuffer::ShmBuffer(
+    uint32_t id,
+    std::unique_ptr<base::SharedMemory> shm)
     : id(id), shm(std::move(shm)) {}
 
 VideoEncoderResource::ShmBuffer::~ShmBuffer() {
 }
 
 VideoEncoderResource::BitstreamBuffer::BitstreamBuffer(uint32_t id,
                                                        uint32_t size,
                                                        bool key_frame)
     : id(id), size(size), key_frame(key_frame) {
 }
@@ skipping 269 matching lines @@
   if (error) {
     NotifyError(error);
     return;
   }
 
   base::SharedMemoryHandle buffer_handle;
   params.TakeSharedMemoryHandleAtIndex(0, &buffer_handle);
 
   if (!buffer_manager_.SetBuffers(
           frame_count, frame_length,
-          make_scoped_ptr(new base::SharedMemory(buffer_handle, false)),
+          base::WrapUnique(new base::SharedMemory(buffer_handle, false)),
           true)) {
     NotifyError(PP_ERROR_FAILED);
     return;
   }
 
   if (TrackedCallback::IsPending(get_video_frame_callback_))
     TryWriteVideoFrame();
 }
 
 void VideoEncoderResource::OnPluginMsgEncodeReply(
@@ skipping 26 matching lines @@
     const ResourceMessageReplyParams& params,
     uint32_t buffer_length) {
   std::vector<base::SharedMemoryHandle> shm_handles;
   params.TakeAllSharedMemoryHandles(&shm_handles);
   if (shm_handles.size() == 0) {
     NotifyError(PP_ERROR_FAILED);
     return;
   }
 
   for (uint32_t i = 0; i < shm_handles.size(); ++i) {
-    scoped_ptr<base::SharedMemory> shm(
+    std::unique_ptr<base::SharedMemory> shm(
         new base::SharedMemory(shm_handles[i], true));
     CHECK(shm->Map(buffer_length));
 
     ShmBuffer* buffer = new ShmBuffer(i, std::move(shm));
     shm_buffers_.push_back(buffer);
     bitstream_buffer_map_.insert(
         std::make_pair(buffer->shm->memory(), buffer->id));
   }
 }
 
@@ skipping 65 matching lines @@
   for (VideoFrameMap::iterator it = video_frames_.begin();
        it != video_frames_.end(); ++it) {
     it->second->Invalidate();
     it->second = nullptr;
   }
   video_frames_.clear();
 }
 
 }  // namespace proxy
 }  // namespace ppapi