convert //gpu to std::unique_ptr

gpu/command_buffer/service/command_buffer_service.cc

 // Copyright (c) 2012 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/command_buffer_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>

[no sievers, 2016/04/05 19:02:40]

#include <memory>

[Mostyn Bramley-Moore, 2016/04/05 21:35:31]

Done.

 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
@@ skipping 77 matching lines @@
   put_offset_ = 0;
   SetGetOffset(0);
   if (!get_buffer_change_callback_.is_null()) {
     get_buffer_change_callback_.Run(ring_buffer_id_);
   }
 
   UpdateState();
 }
 
 void CommandBufferService::SetSharedStateBuffer(
-    scoped_ptr<BufferBacking> shared_state_buffer) {
+    std::unique_ptr<BufferBacking> shared_state_buffer) {
   shared_state_buffer_ = std::move(shared_state_buffer);
   DCHECK(shared_state_buffer_->GetSize() >= sizeof(*shared_state_));
 
   shared_state_ =
       static_cast<CommandBufferSharedState*>(shared_state_buffer_->GetMemory());
 
   UpdateState();
 }
 
 void CommandBufferService::SetGetOffset(int32_t get_offset) {
   DCHECK(get_offset >= 0 && get_offset < num_entries_);
   get_offset_ = get_offset;
 }
 
 scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
                                                                  int32_t* id) {
   *id = -1;
 
-  scoped_ptr<SharedMemory> shared_memory(new SharedMemory());
+  std::unique_ptr<SharedMemory> shared_memory(new SharedMemory());
   if (!shared_memory->CreateAndMapAnonymous(size)) {
     if (error_ == error::kNoError)
       error_ = gpu::error::kOutOfBounds;
     return NULL;
   }
 
   static int32_t next_id = 1;
   *id = next_id++;
 
   if (!RegisterTransferBuffer(
@@ skipping 17 matching lines @@
     put_offset_ = 0;
   }
 }
 
 scoped_refptr<Buffer> CommandBufferService::GetTransferBuffer(int32_t id) {
   return transfer_buffer_manager_->GetTransferBuffer(id);
 }
 
 bool CommandBufferService::RegisterTransferBuffer(
     int32_t id,
-    scoped_ptr<BufferBacking> buffer) {
+    std::unique_ptr<BufferBacking> buffer) {
   return transfer_buffer_manager_->RegisterTransferBuffer(id,
                                                           std::move(buffer));
 }
 
 void CommandBufferService::SetToken(int32_t token) {
   token_ = token;
   UpdateState();
 }
 
 void CommandBufferService::SetParseError(error::Error error) {
@@ skipping 22 matching lines @@
     const GetBufferChangedCallback& callback) {
   get_buffer_change_callback_ = callback;
 }
 
 void CommandBufferService::SetParseErrorCallback(
     const base::Closure& callback) {
   parse_error_callback_ = callback;
 }
 
 }  // namespace gpu