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

cc/resources/resource_pool.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_pool.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 103 matching lines @@
       continue;
 
     // Transfer resource to |in_use_resources_|.
     in_use_resources_[resource->id()] = std::move(*it);
     unused_resources_.erase(it);
     in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
         resource->size(), resource->format());
     return resource;
   }
 
-  scoped_ptr<PoolResource> pool_resource =
+  std::unique_ptr<PoolResource> pool_resource =
       PoolResource::Create(resource_provider_);
 
   if (use_gpu_memory_buffers_) {
     pool_resource->AllocateWithGpuMemoryBuffer(size, format);
   } else {
     pool_resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                             format);
   }
 
   DCHECK(ResourceUtil::VerifySizeInBytes<size_t>(pool_resource->size(),
                                                  pool_resource->format()));
   total_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       pool_resource->size(), pool_resource->format());
   ++total_resource_count_;
 
   Resource* resource = pool_resource.get();
   in_use_resources_[resource->id()] = std::move(pool_resource);
   in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
   return resource;
 }
 
 Resource* ResourcePool::TryAcquireResourceWithContentId(uint64_t content_id) {
   DCHECK(content_id);
 
-  auto it =
-      std::find_if(unused_resources_.begin(), unused_resources_.end(),
-                   [content_id](const scoped_ptr<PoolResource>& pool_resource) {
-                     return pool_resource->content_id() == content_id;
-                   });
+  auto it = std::find_if(
+      unused_resources_.begin(), unused_resources_.end(),
+      [content_id](const std::unique_ptr<PoolResource>& pool_resource) {
+        return pool_resource->content_id() == content_id;
+      });
   if (it == unused_resources_.end())
     return nullptr;
 
   Resource* resource = it->get();
   // TODO(ccameron): The allowance for IsInUseByMacOSWindowServer should not
   // be needed.
   // http://crbug.com/577121
   DCHECK(resource_provider_->CanLockForWrite(resource->id()) ||
          resource_provider_->IsInUseByMacOSWindowServer(resource->id()));
 
@@ skipping 13 matching lines @@
   CHECK(resource->id());
 
   auto it = in_use_resources_.find(resource->id());
   if (it == in_use_resources_.end()) {
     // We should never hit this. Do some digging to try to determine the cause.
     // TODO(ericrk): Remove this once we've investigated further.
     // crbug.com/598286.
 
     // Maybe this is a double free - see if the resource exists in our busy
     // list.
-    auto found_busy =
-        std::find_if(busy_resources_.begin(), busy_resources_.end(),
-                     [resource](const scoped_ptr<PoolResource>& busy_resource) {
-                       return busy_resource->id() == resource->id();
-                     });
+    auto found_busy = std::find_if(
+        busy_resources_.begin(), busy_resources_.end(),
+        [resource](const std::unique_ptr<PoolResource>& busy_resource) {
+          return busy_resource->id() == resource->id();
+        });
     CHECK(found_busy == busy_resources_.end());
 
     // Also check if the resource exists in our unused resources list.
-    auto found_unused =
-        std::find_if(unused_resources_.begin(), unused_resources_.end(),
-                     [resource](const scoped_ptr<PoolResource>& pool_resource) {
-                       return pool_resource->id() == resource->id();
-                     });
+    auto found_unused = std::find_if(
+        unused_resources_.begin(), unused_resources_.end(),
+        [resource](const std::unique_ptr<PoolResource>& pool_resource) {
+          return pool_resource->id() == resource->id();
+        });
     CHECK(found_unused == unused_resources_.end());
 
     // Resource doesn't exist in any of our lists. CHECK.
     CHECK(false);
   }
 
   // Also ensure that the resource wasn't null in our list.
   // TODO(ericrk): Remove this once we've investigated further.
   // crbug.com/598286.
   CHECK(it->second.get());
@@ skipping 38 matching lines @@
 }
 
 bool ResourcePool::ResourceUsageTooHigh() {
   if (total_resource_count_ > max_resource_count_)
     return true;
   if (total_memory_usage_bytes_ > max_memory_usage_bytes_)
     return true;
   return false;
 }
 
-void ResourcePool::DeleteResource(scoped_ptr<PoolResource> resource) {
+void ResourcePool::DeleteResource(std::unique_ptr<PoolResource> resource) {
   size_t resource_bytes = ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
   total_memory_usage_bytes_ -= resource_bytes;
   --total_resource_count_;
 }
 
 void ResourcePool::CheckBusyResources() {
   for (size_t i = 0; i < busy_resources_.size();) {
     ResourceDeque::iterator it(busy_resources_.begin() + i);
     PoolResource* resource = it->get();
 
     if (resource_provider_->CanLockForWrite(resource->id())) {
       DidFinishUsingResource(std::move(*it));
       busy_resources_.erase(it);
     } else if (resource_provider_->IsLost(resource->id())) {
       // Remove lost resources from pool.
       DeleteResource(std::move(*it));
       busy_resources_.erase(it);
     } else {
       ++i;
     }
   }
 }
 
-void ResourcePool::DidFinishUsingResource(scoped_ptr<PoolResource> resource) {
+void ResourcePool::DidFinishUsingResource(
+    std::unique_ptr<PoolResource> resource) {
   unused_resources_.push_front(std::move(resource));
 }
 
 void ResourcePool::ScheduleEvictExpiredResourcesIn(
     base::TimeDelta time_from_now) {
   if (evict_expired_resources_pending_)
     return;
 
   evict_expired_resources_pending_ = true;
 
@@ skipping 62 matching lines @@
   for (const auto& resource : busy_resources_) {
     resource->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   for (const auto& entry : in_use_resources_) {
     entry.second->OnMemoryDump(pmd, resource_provider_, false /* is_free */);
   }
   return true;
 }
 
 }  // namespace cc