Partial raster for GPU

cc/resources/resource_pool.cc

Index: cc/resources/resource_pool.cc
diff --git a/cc/resources/resource_pool.cc b/cc/resources/resource_pool.cc
index 0ec24005a49e8e40af31fc771f559a69fbd83845..3aef71d1bf91cc604006510457a037f45cb40443 100644
--- a/cc/resources/resource_pool.cc
+++ b/cc/resources/resource_pool.cc
@@ -133,36 +133,77 @@ Resource* ResourcePool::AcquireResource(const gfx::Size& size,
       pool_resource->size(), pool_resource->format());
   ++total_resource_count_;
 
+  // Clear the invalidated rect and content ID, as we are about to raster new
+  // content. These will be re-set when rasterization completes successfully.
+  pool_resource->set_invalidated_rect(gfx::Rect());
+  pool_resource->set_content_id(0);
+
   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(
+Resource* ResourcePool::TryAcquireResourceForPartialRaster(
+    uint64_t new_content_id,
+    const gfx::Rect& new_invalidated_rect,
+    uint64_t previous_content_id,
+    gfx::Rect* total_invalidated_rect) {
+  DCHECK(new_content_id);
+  DCHECK(previous_content_id);
+  *total_invalidated_rect = gfx::Rect();
+
+  // Try to find |previous_content_id| in |unused_resources_|.
+  auto found_unused = 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;
+      [previous_content_id](const ResourceDeque::value_type& pool_resource) {
+        return pool_resource->content_id() == previous_content_id;
       });
-  if (it == unused_resources_.end())
-    return nullptr;
+  if (found_unused != unused_resources_.end()) {
+    PoolResource* found_resource = found_unused->get();
+    DCHECK(resource_provider_->CanLockForWrite(found_resource->id()));
 
-  Resource* resource = it->get();
-  DCHECK(resource_provider_->CanLockForWrite(resource->id()));
+    // Transfer resource to |in_use_resources_|.
+    in_use_resources_[found_resource->id()] = std::move(*found_unused);
+    unused_resources_.erase(found_unused);
+    in_use_memory_usage_bytes_ += ResourceUtil::UncheckedSizeInBytes<size_t>(
+        found_resource->size(), found_resource->format());
 
-  // 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;
+    *total_invalidated_rect = new_invalidated_rect;
+    if (!found_resource->invalidated_rect().IsEmpty())
+      total_invalidated_rect->Union(found_resource->invalidated_rect());
+
+    // Clear the invalidated rect and content ID on the resource being retunred.
+    // These will be updated when raster completes successfully.
+    found_resource->set_invalidated_rect(gfx::Rect());
+    found_resource->set_content_id(0);
+
+    return found_resource;
+  }
+
+  // Couldn't find an unused previous resource. If possible, update the
+  // invalidation on the in-use resource to allow for future partial raster.
+  auto found_in_use = std::find_if(
+      in_use_resources_.begin(), in_use_resources_.end(),
+      [previous_content_id](const InUseResourceMap::value_type& in_use_entry) {
+        return in_use_entry.second->content_id() == previous_content_id;
+      });
+  if (found_in_use != in_use_resources_.end()) {
+    PoolResource* found_resource = found_in_use->second.get();
+    gfx::Rect updated_invalidated_rect = new_invalidated_rect;
+    if (!found_resource->invalidated_rect().IsEmpty())
+      updated_invalidated_rect.Union(found_resource->invalidated_rect());
+
+    found_resource->set_content_id(new_content_id);

[enne (OOO), 2016/07/11 21:16:24]

I guess this could mean that potentially there are two resources in the unused
pool with the same id in some cases, but that should be fine, I think? It just
means you'll find one first in the above case, and then maybe recycle the other
eventually.

However, what happens if the browser takes multiple frames to return resources
and so you have multiple resources in the in use pool with the same id?  Do you
need to update the invalidated rect on all of them and not just the first one
you find?

[ericrk, 2016/07/12 17:31:56]

Per our offline discussion, added a comment to explain things more. Let me know
if this makes sense now.

+    found_resource->set_invalidated_rect(updated_invalidated_rect);
+  }
+
+  return nullptr;
 }
 
-void ResourcePool::ReleaseResource(Resource* resource, uint64_t content_id) {
+void ResourcePool::ReleaseResource(Resource* resource) {
   // Ensure that the provided resource is valid.
   // TODO(ericrk): Remove this once we've investigated further.
   // crbug.com/598286.
@@ -202,7 +243,6 @@ void ResourcePool::ReleaseResource(Resource* resource, uint64_t content_id) {
   CHECK(it->second.get());
 
   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_|.
@@ -216,6 +256,14 @@ void ResourcePool::ReleaseResource(Resource* resource, uint64_t content_id) {
   ScheduleEvictExpiredResourcesIn(resource_expiration_delay_);
 }
 
+void ResourcePool::OnContentReplaced(ResourceId resource_id,
+                                     uint64_t content_id) {
+  auto found = in_use_resources_.find(resource_id);
+  DCHECK(found != in_use_resources_.end());
+  found->second->set_content_id(content_id);
+  found->second->set_invalidated_rect(gfx::Rect());
+}
+
 void ResourcePool::SetResourceUsageLimits(size_t max_memory_usage_bytes,
                                           size_t max_resource_count) {
   max_memory_usage_bytes_ = max_memory_usage_bytes;