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

cc/raster/staging_buffer_pool.cc

 // Copyright 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 "cc/raster/staging_buffer_pool.h"
 
+#include <memory>
+
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/base/container_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 
 namespace cc {
 namespace {
@@ skipping 94 matching lines @@
       gfx::GetGpuMemoryBufferGUIDForTracing(tracing_process_id, buffer_id);
   pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
 
   // By creating an edge with a higher |importance| (w.r.t. browser-side dumps)
   // the tracing UI will account the effective size of the buffer to the child.
   const int kImportance = 2;
   pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance);
 }
 
 // static
-scoped_ptr<StagingBufferPool> StagingBufferPool::Create(
+std::unique_ptr<StagingBufferPool> StagingBufferPool::Create(
     base::SequencedTaskRunner* task_runner,
     ResourceProvider* resource_provider,
     bool use_partial_raster,
     int max_staging_buffer_usage_in_bytes) {
-  return make_scoped_ptr<StagingBufferPool>(
+  return base::WrapUnique(
       new StagingBufferPool(task_runner, resource_provider, use_partial_raster,
                             max_staging_buffer_usage_in_bytes));
 }
 
 StagingBufferPool::StagingBufferPool(base::SequencedTaskRunner* task_runner,
                                      ResourceProvider* resource_provider,
                                      bool use_partial_raster,
                                      int max_staging_buffer_usage_in_bytes)
     : task_runner_(task_runner),
       resource_provider_(resource_provider),
@@ skipping 20 matching lines @@
   base::AutoLock lock(lock_);
   if (buffers_.empty())
     return;
 
   ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max());
   DCHECK_EQ(staging_buffer_usage_in_bytes_, 0);
   DCHECK_EQ(free_staging_buffer_usage_in_bytes_, 0);
 }
 
 void StagingBufferPool::ReleaseStagingBuffer(
-    scoped_ptr<StagingBuffer> staging_buffer) {
+    std::unique_ptr<StagingBuffer> staging_buffer) {
   base::AutoLock lock(lock_);
 
   staging_buffer->last_usage = base::TimeTicks::Now();
   busy_buffers_.push_back(std::move(staging_buffer));
 
   ScheduleReduceMemoryUsage();
 }
 
 bool StagingBufferPool::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
 
   for (const auto* buffer : buffers_) {
     auto in_free_buffers =
         std::find_if(free_buffers_.begin(), free_buffers_.end(),
-                     [buffer](const scoped_ptr<StagingBuffer>& b) {
+                     [buffer](const std::unique_ptr<StagingBuffer>& b) {
                        return b.get() == buffer;
                      });
     buffer->OnMemoryDump(pmd, buffer->format,
                          in_free_buffers != free_buffers_.end());
   }
 
   return true;
 }
 
 void StagingBufferPool::AddStagingBuffer(const StagingBuffer* staging_buffer,
@@ skipping 31 matching lines @@
 void StagingBufferPool::MarkStagingBufferAsBusy(
     const StagingBuffer* staging_buffer) {
   lock_.AssertAcquired();
 
   int buffer_usage_in_bytes = ResourceUtil::UncheckedSizeInBytes<int>(
       staging_buffer->size, staging_buffer->format);
   DCHECK_GE(free_staging_buffer_usage_in_bytes_, buffer_usage_in_bytes);
   free_staging_buffer_usage_in_bytes_ -= buffer_usage_in_bytes;
 }
 
-scoped_ptr<StagingBuffer> StagingBufferPool::AcquireStagingBuffer(
+std::unique_ptr<StagingBuffer> StagingBufferPool::AcquireStagingBuffer(
     const Resource* resource,
     uint64_t previous_content_id) {
   base::AutoLock lock(lock_);
 
-  scoped_ptr<StagingBuffer> staging_buffer;
+  std::unique_ptr<StagingBuffer> staging_buffer;
 
   ContextProvider* context_provider =
       resource_provider_->output_surface()->worker_context_provider();
   DCHECK(context_provider);
 
   ContextProvider::ScopedContextLock scoped_context(context_provider);
 
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
   DCHECK(gl);
 
@@ skipping 28 matching lines @@
         free_buffers_.push_back(PopFront(&busy_buffers_));
       }
     }
   }
 
   // Find a staging buffer that allows us to perform partial raster when
   // using persistent GpuMemoryBuffers.
   if (use_partial_raster_ && previous_content_id) {
     StagingBufferDeque::iterator it = std::find_if(
         free_buffers_.begin(), free_buffers_.end(),
-        [previous_content_id](const scoped_ptr<StagingBuffer>& buffer) {
+        [previous_content_id](const std::unique_ptr<StagingBuffer>& buffer) {
           return buffer->content_id == previous_content_id;
         });
     if (it != free_buffers_.end()) {
       staging_buffer = std::move(*it);
       free_buffers_.erase(it);
       MarkStagingBufferAsBusy(staging_buffer.get());
     }
   }
 
   // Find staging buffer of correct size and format.
   if (!staging_buffer) {
     StagingBufferDeque::iterator it =
         std::find_if(free_buffers_.begin(), free_buffers_.end(),
-                     [resource](const scoped_ptr<StagingBuffer>& buffer) {
+                     [resource](const std::unique_ptr<StagingBuffer>& buffer) {
                        return buffer->size == resource->size() &&
                               buffer->format == resource->format();
                      });
     if (it != free_buffers_.end()) {
       staging_buffer = std::move(*it);
       free_buffers_.erase(it);
       MarkStagingBufferAsBusy(staging_buffer.get());
     }
   }
 
   // Create new staging buffer if necessary.
   if (!staging_buffer) {
-    staging_buffer = make_scoped_ptr(
+    staging_buffer = base::WrapUnique(
         new StagingBuffer(resource->size(), resource->format()));
     AddStagingBuffer(staging_buffer.get(), resource->format());
   }
 
   // Release enough free buffers to stay within the limit.
   while (staging_buffer_usage_in_bytes_ > max_staging_buffer_usage_in_bytes_) {
     if (free_buffers_.empty())
       break;
 
     free_buffers_.front()->DestroyGLResources(gl);
@@ skipping 88 matching lines @@
         return;
 
       busy_buffers_.front()->DestroyGLResources(gl);
       RemoveStagingBuffer(busy_buffers_.front().get());
       busy_buffers_.pop_front();
     }
   }
 }
 
 }  // namespace cc