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

cc/raster/one_copy_tile_task_worker_pool.cc

 // Copyright 2014 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/one_copy_tile_task_worker_pool.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #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"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/container_util.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/raster/raster_buffer.h"
 #include "cc/resources/platform_color.h"
@@ skipping 147 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<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
+std::unique_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     int max_copy_texture_chromium_size,
     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));
 }
 
 OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     int max_copy_texture_chromium_size,
@@ skipping 92 matching lines @@
   }
 
   return resource_provider_->best_texture_format();
 }
 
 bool OneCopyTileTaskWorkerPool::GetResourceRequiresSwizzle(
     bool must_support_alpha) const {
   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.
 }
 
 void OneCopyTileTaskWorkerPool::PlaybackAndCopyOnWorkerThread(
     const Resource* resource,
     ResourceProvider::ScopedWriteLockGL* resource_lock,
     const RasterSource* raster_source,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
     float scale,
     const RasterSource::PlaybackSettings& playback_settings,
     uint64_t previous_content_id,
     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);
 
   {
     base::AutoUnlock unlock(lock_);
 
     // Allocate GpuMemoryBuffer if necessary. If using partial raster, we
     // must allocate a buffer with BufferUsage CPU_READ_WRITE_PERSISTENT.
     if (!staging_buffer->gpu_memory_buffer) {
       staging_buffer->gpu_memory_buffer =
@@ skipping 152 matching lines @@
 }
 
 bool OneCopyTileTaskWorkerPool::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 OneCopyTileTaskWorkerPool::AddStagingBuffer(
@@ skipping 32 matching lines @@
 void OneCopyTileTaskWorkerPool::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<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();
   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 89 matching lines @@
         return;
 
       busy_buffers_.front()->DestroyGLResources(gl);
       RemoveStagingBuffer(busy_buffers_.front().get());
       busy_buffers_.pop_front();
     }
   }
 }
 
 }  // namespace cc