Partial raster for GPU

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 115 matching lines @@
     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_;
 
+  // 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);
+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();
 
-  auto it = std::find_if(
+  // 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.
   CHECK(resource);
   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.
@@ skipping 19 matching lines @@
     // 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());
 
   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(std::move(it->second));
   in_use_resources_.erase(it);
   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::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;
   max_resource_count_ = max_resource_count;
 
   ReduceResourceUsage();
 }
 
 void ResourcePool::ReduceResourceUsage() {
   while (!unused_resources_.empty()) {
@@ skipping 121 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