Remove ScopedPtrMap from /cc

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 <algorithm>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 88 matching lines @@
        it != unused_resources_.end(); ++it) {
     ScopedResource* resource = it->get();
     DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
     if (resource->format() != format)
       continue;
     if (resource->size() != size)
       continue;
 
     // Transfer resource to |in_use_resources_|.
-    in_use_resources_.set(resource->id(), it->Pass());
+    in_use_resources_[resource->id()] = it->Pass(); 

[Matt Giuca, 2015/11/19 23:42:26]

nit: It seems that std::move is allowed now. I'm not sure what our policy is on
it, but it seems prudent to use it in any new or updated code. Could you try
changing it->Pass() to std::move(it) and see if it works?

[Matt Giuca, 2015/11/19 23:42:26]

nit: There is a trailing space at the end of this line.

[limasdf, 2015/11/20 15:20:04]

Done.

     unused_resources_.erase(it);
     in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
         resource->size(), resource->format());
     return resource;
   }
 
   scoped_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_.set(resource->id(), std::move(pool_resource));
+  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;
                    });
   if (it == unused_resources_.end())
     return nullptr;
 
   Resource* resource = it->get();
   DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
   // Transfer resource to |in_use_resources_|.
-  in_use_resources_.set(resource->id(), it->Pass());
+  in_use_resources_[resource->id()] = it->Pass();
   unused_resources_.erase(it);
   in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
       resource->size(), resource->format());
   return resource;
 }
 
 void ResourcePool::ReleaseResource(Resource* resource, uint64_t content_id) {
   auto it = in_use_resources_.find(resource->id());
   DCHECK(it != in_use_resources_.end());
 
-  PoolResource* pool_resource = it->second;
+  PoolResource* pool_resource = it->second.get();
   pool_resource->set_content_id(content_id);
   pool_resource->set_last_usage(base::TimeTicks::Now());
 
   // Transfer resource to |busy_resources_|.
-  busy_resources_.push_front(in_use_resources_.take_and_erase(it));
+  //busy_resources_.push_front(in_use_resources_.take_and_erase(it));
+  scoped_ptr<PoolResource> my_resource = it->second.Pass();

[limasdf, 2015/11/19 13:48:51]

take_and_erase() returns scoped_ptr and erase iterator.
I did same thing but doesn't work.

[Matt Giuca, 2015/11/19 23:42:26]

This code can be simplified. The above code gets a raw pointer using
it->second.get(). You then immediately get a scoped_ptr to the same object.

Just replace the line above with:
scoped_ptr<PoolResource> pool_resource = std::move(it->second);

Then you don't need a second variable my_resource.

[Matt Giuca, 2015/11/19 23:42:26]

What do you mean it doesn't work? (I patched your CL in and it compiles fine.) I
think what you've got here is the correct substitute for take_and_erase. Just
delete that commented-out line.

Also use std::move instead of Pass.

take_and_erase is something we added specifically to ScopedPtrMap to get around
a deficiency: we weren't really storing scoped_ptrs in the map so the client
cannot simply std::move the object out of there. take_and_erase is the only way
to move an object out of a ScopedPtrMap once you've put it in.

For a std::map<scoped_ptr> you should just be able to std::move the object out
of the iterator, then erase the iterator.

[limasdf, 2015/11/20 15:20:04]

Sorry. Because of trybot fail, I was thinking there's some problem.
but it was wrong result(flaky?). Trybot is happy now :)

[limasdf, 2015/11/20 15:20:05]

On line#175, |pool_resource| is being used, so keeping raw pointer. and passed
it->second.

[Matt Giuca, 2015/11/23 02:17:49]

Acknowledged.

+  in_use_resources_.erase(it);
+  busy_resources_.push_front(std::move(my_resource));
   in_use_memory_usage_bytes_ -= ResourceUtil::UncheckedSizeInBytes<size_t>(
       pool_resource->size(), pool_resource->format());
 
   // Now that we have evictable resources, schedule an eviction call for this
   // resource if necessary.
   ScheduleEvictExpiredResourcesIn(resource_expiration_delay_);
 }
 
 void ResourcePool::SetResourceUsageLimits(size_t max_memory_usage_bytes,
                                           size_t max_resource_count) {
@@ skipping 128 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