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

cc/raster/one_copy_tile_task_worker_pool.cc

Index: cc/raster/one_copy_tile_task_worker_pool.cc
diff --git a/cc/raster/one_copy_tile_task_worker_pool.cc b/cc/raster/one_copy_tile_task_worker_pool.cc
index 878911981a7bb5625c65e97748cc1bc831458a18..50f6fec85f147392636d66ae21b7b83bbf64b3e7 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.cc
+++ b/cc/raster/one_copy_tile_task_worker_pool.cc
@@ -11,6 +11,7 @@
 #include <utility>
 
 #include "base/macros.h"
+#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"
@@ -178,7 +179,7 @@ void OneCopyTileTaskWorkerPool::StagingBuffer::OnMemoryDump(
 }
 
 // static
-scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
+std::unique_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
@@ -187,7 +188,7 @@ scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     bool use_partial_raster,
     int max_staging_buffer_usage_in_bytes,
     ResourceFormat preferred_tile_format) {
-  return make_scoped_ptr<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool(
+  return base::WrapUnique<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool(
       task_runner, task_graph_runner, resource_provider,
       max_copy_texture_chromium_size, use_partial_raster,
       max_staging_buffer_usage_in_bytes, preferred_tile_format));
@@ -300,19 +301,19 @@ bool OneCopyTileTaskWorkerPool::GetResourceRequiresSwizzle(
   return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha));
 }
 
-scoped_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
+std::unique_ptr<RasterBuffer> OneCopyTileTaskWorkerPool::AcquireBufferForRaster(
     const Resource* resource,
     uint64_t resource_content_id,
     uint64_t previous_content_id) {
   // TODO(danakj): If resource_content_id != 0, we only need to copy/upload
   // the dirty rect.
-  return make_scoped_ptr<RasterBuffer>(
+  return base::WrapUnique<RasterBuffer>(
       new RasterBufferImpl(this, resource_provider_, resource->format(),
                            resource, previous_content_id));
 }
 
 void OneCopyTileTaskWorkerPool::ReleaseBufferForRaster(
-    scoped_ptr<RasterBuffer> buffer) {
+    std::unique_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
@@ -328,7 +329,7 @@ void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
     uint64_t new_content_id) {
   base::AutoLock lock(lock_);
 
-  scoped_ptr<StagingBuffer> staging_buffer =
+  std::unique_ptr<StagingBuffer> staging_buffer =
       AcquireStagingBuffer(resource, previous_content_id);
   DCHECK(staging_buffer);
 
@@ -501,7 +502,7 @@ bool OneCopyTileTaskWorkerPool::OnMemoryDump(
   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,
@@ -554,12 +555,12 @@ void OneCopyTileTaskWorkerPool::MarkStagingBufferAsBusy(
   free_staging_buffer_usage_in_bytes_ -= buffer_usage_in_bytes;
 }
 
-scoped_ptr<OneCopyTileTaskWorkerPool::StagingBuffer>
+std::unique_ptr<OneCopyTileTaskWorkerPool::StagingBuffer>
 OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource,
                                                 uint64_t previous_content_id) {
   lock_.AssertAcquired();
 
-  scoped_ptr<StagingBuffer> staging_buffer;
+  std::unique_ptr<StagingBuffer> staging_buffer;
 
   ContextProvider* context_provider =
       resource_provider_->output_surface()->worker_context_provider();
@@ -608,7 +609,7 @@ OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource,
   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()) {
@@ -622,7 +623,7 @@ OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource,
   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();
                      });
@@ -635,7 +636,7 @@ OneCopyTileTaskWorkerPool::AcquireStagingBuffer(const Resource* resource,
 
   // 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());
   }