convert //gpu to std::unique_ptr

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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 "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 72 matching lines @@
 
  private:
   SyncPointOrderData* order_data_;
   uint32_t order_num_;
 };
 
 struct GpuInProcessThreadHolder {
   GpuInProcessThreadHolder()
       : sync_point_manager(new SyncPointManager(false)),
         gpu_thread(new GpuInProcessThread(sync_point_manager.get())) {}
-  scoped_ptr<SyncPointManager> sync_point_manager;
+  std::unique_ptr<SyncPointManager> sync_point_manager;
   scoped_refptr<InProcessCommandBuffer::Service> gpu_thread;
 };
 
 base::LazyInstance<GpuInProcessThreadHolder> g_default_service =
     LAZY_INSTANCE_INITIALIZER;
 
 class ScopedEvent {
  public:
   explicit ScopedEvent(base::WaitableEvent* event) : event_(event) {}
   ~ScopedEvent() { event_->Signal(); }
@@ skipping 214 matching lines @@
     const InitializeOnGpuThreadParams& params) {
   CheckSequencedThread();
   gpu_thread_weak_ptr_ = gpu_thread_weak_ptr_factory_.GetWeakPtr();
 
   DCHECK(params.size.width() >= 0 && params.size.height() >= 0);
 
   TransferBufferManager* manager = new TransferBufferManager(nullptr);
   transfer_buffer_manager_ = manager;
   manager->Initialize();
 
-  scoped_ptr<CommandBufferService> command_buffer(
+  std::unique_ptr<CommandBufferService> command_buffer(
       new CommandBufferService(transfer_buffer_manager_.get()));
   command_buffer->SetPutOffsetChangeCallback(base::Bind(
       &InProcessCommandBuffer::PumpCommandsOnGpuThread, gpu_thread_weak_ptr_));
   command_buffer->SetParseErrorCallback(base::Bind(
       &InProcessCommandBuffer::OnContextLostOnGpuThread, gpu_thread_weak_ptr_));
 
   if (!command_buffer->Initialize()) {
     LOG(ERROR) << "Could not initialize command buffer.";
     DestroyOnGpuThread();
     return false;
@@ skipping 496 matching lines @@
 }
 
 int32_t InProcessCommandBuffer::CreateGpuMemoryBufferImage(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage) {
   CheckSequencedThread();
 
   DCHECK(gpu_memory_buffer_manager_);
-  scoped_ptr<gfx::GpuMemoryBuffer> buffer(
+  std::unique_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
           gpu::DefaultBufferFormatForImageFormat(internalformat),
           gfx::BufferUsage::SCANOUT, 0 /* surface_id */));
   if (!buffer)
     return -1;
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
@@ skipping 164 matching lines @@
     const base::Closure& callback) {
   // The task_runner.get() check is to support using InProcessCommandBuffer on
   // a thread without a message loop.
   if (task_runner.get() && !task_runner->BelongsToCurrentThread()) {
     task_runner->PostTask(FROM_HERE, callback);
   } else {
     callback.Run();
   }
 }
 
-void RunOnTargetThread(scoped_ptr<base::Closure> callback) {
+void RunOnTargetThread(std::unique_ptr<base::Closure> callback) {
   DCHECK(callback.get());
   callback->Run();
 }
 
 }  // anonymous namespace
 
 base::Closure InProcessCommandBuffer::WrapCallback(
     const base::Closure& callback) {
   // Make sure the callback gets deleted on the target thread by passing
   // ownership.
-  scoped_ptr<base::Closure> scoped_callback(new base::Closure(callback));
+  std::unique_ptr<base::Closure> scoped_callback(new base::Closure(callback));
   base::Closure callback_on_client_thread =
       base::Bind(&RunOnTargetThread, base::Passed(&scoped_callback));
   base::Closure wrapped_callback =
       base::Bind(&PostCallback, base::ThreadTaskRunnerHandle::IsSet()
                                     ? base::ThreadTaskRunnerHandle::Get()
                                     : nullptr,
                  callback_on_client_thread);
   return wrapped_callback;
 }
 
@@ skipping 62 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu