Convert //cc from scoped_ptr to std::unique_ptr.

cc/resources/resource_provider.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 47 matching lines @@
         id_allocation_chunk_size_(id_allocation_chunk_size),
         ids_(new GLuint[id_allocation_chunk_size]),
         next_id_index_(id_allocation_chunk_size) {
     DCHECK(id_allocation_chunk_size_);
     DCHECK_LE(id_allocation_chunk_size_,
               static_cast<size_t>(std::numeric_limits<int>::max()));
   }
 
   GLES2Interface* gl_;
   const size_t id_allocation_chunk_size_;
-  scoped_ptr<GLuint[]> ids_;
+  std::unique_ptr<GLuint[]> ids_;
   size_t next_id_index_;
 };
 
 namespace {
 
 bool IsGpuResourceType(ResourceProvider::ResourceType type) {
   return type != ResourceProvider::RESOURCE_TYPE_BITMAP;
 }
 
 GLenum TextureToStorageFormat(ResourceFormat format) {
@@ skipping 297 matching lines @@
   SetSynchronized();
 }
 
 ResourceProvider::Child::Child()
     : marked_for_deletion(false), needs_sync_tokens(true) {}
 
 ResourceProvider::Child::Child(const Child& other) = default;
 
 ResourceProvider::Child::~Child() {}
 
-scoped_ptr<ResourceProvider> ResourceProvider::Create(
+std::unique_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     size_t id_allocation_chunk_size,
     bool use_gpu_memory_buffer_resources,
     const std::vector<unsigned>& use_image_texture_targets) {
-  scoped_ptr<ResourceProvider> resource_provider(new ResourceProvider(
+  std::unique_ptr<ResourceProvider> resource_provider(new ResourceProvider(
       output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
       blocking_main_thread_task_runner, highp_threshold_min,
       id_allocation_chunk_size, use_gpu_memory_buffer_resources,
       use_image_texture_targets));
   resource_provider->Initialize();
   return resource_provider;
 }
 
 ResourceProvider::~ResourceProvider() {
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
@@ skipping 138 matching lines @@
   Resource* resource =
       InsertResource(id, Resource(0, size, Resource::INTERNAL, target,
                                   GL_LINEAR, hint, type, format));
   resource->allocated = false;
   return id;
 }
 
 ResourceId ResourceProvider::CreateBitmap(const gfx::Size& size) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  scoped_ptr<SharedBitmap> bitmap =
+  std::unique_ptr<SharedBitmap> bitmap =
       shared_bitmap_manager_->AllocateSharedBitmap(size);
   uint8_t* pixels = bitmap->pixels();
   DCHECK(pixels);
 
   ResourceId id = next_id_++;
   Resource* resource = InsertResource(
       id,
       Resource(pixels, bitmap.release(), size, Resource::INTERNAL, GL_LINEAR));
   resource->allocated = true;
   return id;
@@ skipping 14 matching lines @@
   DCHECK(gl);
   gl->BindTexture(GL_TEXTURE_RECTANGLE_ARB, resource->gl_id);
   gl->TexImageIOSurface2DCHROMIUM(
       GL_TEXTURE_RECTANGLE_ARB, size.width(), size.height(), io_surface_id, 0);
   resource->allocated = true;
   return id;
 }
 
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
-    scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl,
+    std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl,
     bool read_lock_fences_enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource* resource = nullptr;
   if (mailbox.IsTexture()) {
     resource = InsertResource(
         id,
         Resource(0, mailbox.size_in_pixels(), Resource::EXTERNAL,
@@ skipping 15 matching lines @@
       base::Bind(&SingleReleaseCallbackImpl::Run,
                  base::Owned(release_callback_impl.release()));
   resource->read_lock_fences_enabled = read_lock_fences_enabled;
   resource->is_overlay_candidate = mailbox.is_overlay_candidate();
 
   return id;
 }
 
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
-    scoped_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
+    std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl) {
   return CreateResourceFromTextureMailbox(
       mailbox, std::move(release_callback_impl), false);
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->marked_for_deletion);
@@ skipping 225 matching lines @@
 
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     resource->gl_id = gl->CreateAndConsumeTextureCHROMIUM(
         resource->mailbox().target(), resource->mailbox().name());
     resource->SetLocallyUsed();
   }
 
   if (!resource->pixels && resource->has_shared_bitmap_id &&
       shared_bitmap_manager_) {
-    scoped_ptr<SharedBitmap> bitmap =
+    std::unique_ptr<SharedBitmap> bitmap =
         shared_bitmap_manager_->GetSharedBitmapFromId(
             resource->size, resource->shared_bitmap_id);
     if (bitmap) {
       resource->shared_bitmap = bitmap.release();
       resource->pixels = resource->shared_bitmap->pixels();
     }
   }
 
   resource->lock_for_read_count++;
   if (resource->read_lock_fences_enabled) {
@@ skipping 1079 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc