convert //gpu to std::unique_ptr

gpu/vulkan/vulkan_swap_chain.cc

 // Copyright (c) 2016 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/vulkan/vulkan_swap_chain.h"
 
 #include "gpu/vulkan/vulkan_command_buffer.h"
 #include "gpu/vulkan/vulkan_command_pool.h"
 #include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_image_view.h"
@@ skipping 23 matching lines @@
   DestroySwapImages();
   DestroySwapChain();
 }
 
 gfx::SwapResult VulkanSwapChain::SwapBuffers() {
   VkResult result = VK_SUCCESS;
 
   VkDevice device = device_queue_->GetVulkanDevice();
   VkQueue queue = device_queue_->GetVulkanQueue();
 
-  scoped_ptr<ImageData>& current_image_data = images_[current_image_];
+  std::unique_ptr<ImageData>& current_image_data = images_[current_image_];
 
   // Default image subresource range.
   VkImageSubresourceRange image_subresource_range = {};
   image_subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
   image_subresource_range.baseMipLevel = 0;
   image_subresource_range.levelCount = 1;
   image_subresource_range.baseArrayLayer = 0;
   image_subresource_range.layerCount = 1;
 
   // Submit our command buffer for the current buffer.
@@ skipping 128 matching lines @@
   image_memory_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
   image_memory_barrier.subresourceRange = image_subresource_range;
 
   command_pool_ = device_queue_->CreateCommandPool();
   if (!command_pool_)
     return false;
 
   images_.resize(image_count);
   for (uint32_t i = 0; i < image_count; ++i) {
     images_[i].reset(new ImageData);
-    scoped_ptr<ImageData>& image_data = images_[i];
+    std::unique_ptr<ImageData>& image_data = images_[i];
     image_data->image = images[i];
 
     // Setup semaphores.
     result = vkCreateSemaphore(device, &semaphore_create_info, nullptr,
                                &image_data->render_semaphore);
     if (VK_SUCCESS != result) {
       DLOG(ERROR) << "vkCreateSemaphore(render) failed: " << result;
       return false;
     }
 
@@ skipping 47 matching lines @@
 }
 
 void VulkanSwapChain::DestroySwapImages() {
   VkDevice device = device_queue_->GetVulkanDevice();
 
   if (VK_NULL_HANDLE != next_present_semaphore_) {
     vkDestroySemaphore(device, next_present_semaphore_, nullptr);
     next_present_semaphore_ = VK_NULL_HANDLE;
   }
 
-  for (const scoped_ptr<ImageData>& image_data : images_) {
+  for (const std::unique_ptr<ImageData>& image_data : images_) {
     if (image_data->command_buffer) {
       // Make sure command buffer is done processing.
       image_data->command_buffer->Wait(UINT64_MAX);
 
       image_data->command_buffer->Destroy();
       image_data->command_buffer.reset();
     }
 
     // Destroy Image View.
     if (image_data->image_view) {
@@ skipping 20 matching lines @@
     command_pool_->Destroy();
     command_pool_.reset();
   }
 }
 
 VulkanSwapChain::ImageData::ImageData() {}
 
 VulkanSwapChain::ImageData::~ImageData() {}
 
 }  // namespace gpu