cc: Partial tile update for one-copy raster.

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 "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 
 namespace cc {
 
 ResourcePool::ResourcePool(ResourceProvider* resource_provider, GLenum target)
     : resource_provider_(resource_provider),
       target_(target),
       max_memory_usage_bytes_(0),
       max_unused_memory_usage_bytes_(0),
       max_resource_count_(0),
       memory_usage_bytes_(0),
       unused_memory_usage_bytes_(0),
       resource_count_(0) {}
 
 ResourcePool::~ResourcePool() {
   while (!busy_resources_.empty()) {
-    DidFinishUsingResource(busy_resources_.front());
+    auto const& front = busy_resources_.front();
+    DidFinishUsingResource(front.resource, front.id);
     busy_resources_.pop_front();
   }
 
   SetResourceUsageLimits(0, 0, 0);
   DCHECK_EQ(0u, unused_resources_.size());
   DCHECK_EQ(0u, memory_usage_bytes_);
   DCHECK_EQ(0u, unused_memory_usage_bytes_);
   DCHECK_EQ(0u, resource_count_);
 }
 
 scoped_ptr<ScopedResource> ResourcePool::AcquireResource(
     const gfx::Size& size, ResourceFormat format) {
   for (ResourceList::iterator it = unused_resources_.begin();
        it != unused_resources_.end();
        ++it) {
-    ScopedResource* resource = *it;
+    ScopedResource* resource = it->resource;
     DCHECK(resource_provider_->CanLockForWrite(resource->id()));
 
     if (resource->format() != format)
       continue;
     if (resource->size() != size)
       continue;
 
     unused_resources_.erase(it);
     unused_memory_usage_bytes_ -= resource->bytes();
     return make_scoped_ptr(resource);
   }
 
   scoped_ptr<ScopedResource> resource =
       ScopedResource::Create(resource_provider_);
   resource->AllocateManaged(size, target_, format);
 
   memory_usage_bytes_ += resource->bytes();
   ++resource_count_;
   return resource.Pass();
 }
 
-void ResourcePool::ReleaseResource(scoped_ptr<ScopedResource> resource) {
-  busy_resources_.push_back(resource.release());
+scoped_ptr<ScopedResource> ResourcePool::TryAcquireOldResource(
+    const gfx::Size& size,
+    ResourceFormat format,
+    uint64_t id) {
+  if (!id)

[reveman, 2015/05/22 17:15:13]

hm, doesn't it make more sense for the caller to check this?

[danakj, 2015/05/26 19:02:52]

Sure, can do if you. It means if (id && TryBlah()) instead of if (TryBlah()) at
each call site, which I thought seemed noisier.

[danakj, 2015/05/26 23:37:34]

Done.

+    return nullptr;
+
+  auto it = std::find_if(unused_resources_.begin(), unused_resources_.end(),
+                         [id](const PoolResource& pr) { return pr.id == id; });
+  if (it == unused_resources_.end())
+    return nullptr;
+
+  ScopedResource* resource = it->resource;
+  DCHECK(resource_provider_->CanLockForWrite(resource->id()));
+  if (resource->format() != format || resource->size() != size)

[reveman, 2015/05/22 17:15:13]

how can a resource with the same ID have a different size or format?

[danakj, 2015/05/26 19:02:52]

I don't know. :) I guess that it can't. I'll DCHECK instead.

[danakj, 2015/05/26 23:37:34]

Done.

+    return nullptr;
+
+  unused_resources_.erase(it);
+  unused_memory_usage_bytes_ -= resource->bytes();
+  return make_scoped_ptr(resource);
+}
+
+void ResourcePool::ReleaseResource(scoped_ptr<ScopedResource> resource,
+                                   uint64_t id) {
+  busy_resources_.push_back(PoolResource(resource.release(), id));
 }
 
 void ResourcePool::SetResourceUsageLimits(size_t max_memory_usage_bytes,
                                           size_t max_unused_memory_usage_bytes,
                                           size_t max_resource_count) {
   max_memory_usage_bytes_ = max_memory_usage_bytes;
   max_unused_memory_usage_bytes_ = max_unused_memory_usage_bytes;
   max_resource_count_ = max_resource_count;
 
   ReduceResourceUsage();
 }
 
 void ResourcePool::ReduceResourceUsage() {
   while (!unused_resources_.empty()) {
     if (!ResourceUsageTooHigh())
       break;
 
     // LRU eviction pattern. Most recently used might be blocked by
     // a read lock fence but it's still better to evict the least
     // recently used as it prevents a resource that is hard to reuse
     // because of unique size from being kept around. Resources that
     // can't be locked for write might also not be truly free-able.
     // We can free the resource here but it doesn't mean that the
     // memory is necessarily returned to the OS.
-    ScopedResource* resource = unused_resources_.front();
+    ScopedResource* resource = unused_resources_.front().resource;
     unused_resources_.pop_front();
     memory_usage_bytes_ -= resource->bytes();
     unused_memory_usage_bytes_ -= resource->bytes();
     --resource_count_;
     delete resource;
   }
 }
 
 bool ResourcePool::ResourceUsageTooHigh() {
   if (resource_count_ > max_resource_count_)
     return true;
   if (memory_usage_bytes_ > max_memory_usage_bytes_)
     return true;
   if (unused_memory_usage_bytes_ > max_unused_memory_usage_bytes_)
     return true;
   return false;
 }
 
 void ResourcePool::CheckBusyResources(bool wait_if_needed) {
   ResourceList::iterator it = busy_resources_.begin();
 
   while (it != busy_resources_.end()) {
-    ScopedResource* resource = *it;
+    ScopedResource* resource = it->resource;
 
     if (wait_if_needed)
       resource_provider_->WaitReadLockIfNeeded(resource->id());
 
     if (resource_provider_->CanLockForWrite(resource->id())) {
-      DidFinishUsingResource(resource);
+      DidFinishUsingResource(resource, it->id);
       it = busy_resources_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
-void ResourcePool::DidFinishUsingResource(ScopedResource* resource) {
+void ResourcePool::DidFinishUsingResource(ScopedResource* resource,
+                                          uint64_t id) {
   unused_memory_usage_bytes_ += resource->bytes();
-  unused_resources_.push_back(resource);
+  unused_resources_.push_back(PoolResource(resource, id));
 }
 
 }  // namespace cc