convert //gpu to std::unique_ptr

gpu/ipc/service/gpu_channel.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/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 176 matching lines @@
   base::AutoLock auto_lock(channel_lock_);
   if (enabled_) {
     if (message.type() == GpuCommandBufferMsg_WaitForTokenInRange::ID ||
         message.type() == GpuCommandBufferMsg_WaitForGetOffsetInRange::ID) {
       channel_->PostHandleOutOfOrderMessage(message);
       return true;
     }
 
     uint32_t order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber(
         sync_point_manager_);
-    scoped_ptr<GpuChannelMessage> msg(
+    std::unique_ptr<GpuChannelMessage> msg(
         new GpuChannelMessage(message, order_num, base::TimeTicks::Now()));
 
     if (channel_messages_.empty()) {
       DCHECK(scheduled_);
       channel_->PostHandleMessage(this);
     }
 
     channel_messages_.push_back(std::move(msg));
 
     if (preempting_flag_)
@@ skipping 743 matching lines @@
                    "not initialized";
     return;
   }
 
   if (share_group && share_group->decoder()->WasContextLost()) {
     DLOG(ERROR) << "GpuChannel::OnCreateCommandBuffer(): shared context was "
                    "already lost";
     return;
   }
 
-  scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
+  std::unique_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this, sync_point_manager_, task_runner_.get(), share_group,
       surface_handle, mailbox_manager_.get(), preempted_flag_.get(),
       subscription_ref_set_.get(), pending_valuebuffer_state_.get(), size,
       disallowed_features_, init_params.attribs, init_params.gpu_preference,
       init_params.stream_id, route_id, watchdog_, init_params.active_url));
 
   scoped_refptr<GpuChannelMessageQueue> queue = LookupStream(stream_id);
   if (!queue)
     queue = CreateStream(stream_id, stream_priority);
 
   if (!AddRoute(route_id, stream_id, stub.get())) {
     DestroyStreamIfNecessary(queue);
     DLOG(ERROR) << "GpuChannel::OnCreateCommandBuffer(): failed to add route";
     return;
   }
 
   stubs_.set(route_id, std::move(stub));
   *succeeded = true;
 }
 
 void GpuChannel::OnDestroyCommandBuffer(int32_t route_id) {
   TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer",
                "route_id", route_id);
 
-  scoped_ptr<GpuCommandBufferStub> stub = stubs_.take_and_erase(route_id);
+  std::unique_ptr<GpuCommandBufferStub> stub = stubs_.take_and_erase(route_id);
   // In case the renderer is currently blocked waiting for a sync reply from the
   // stub, we need to make sure to reschedule the correct stream here.
   if (stub && !stub->IsScheduled()) {
     // This stub won't get a chance to reschedule the stream so do that now.
     OnStreamRescheduled(stub->stream_id(), true);
   }
 
   RemoveRoute(route_id);
 }
 
@@ skipping 73 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace gpu