Add logic to GLRenderer to support RenderPassDrawQuad copying.

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 193 matching lines @@
     if (!found_resource->invalidated_rect().IsEmpty())
       updated_invalidated_rect.Union(found_resource->invalidated_rect());
 
     found_resource->set_content_id(new_content_id);
     found_resource->set_invalidated_rect(updated_invalidated_rect);
   }
 
   return nullptr;
 }
 
+void ResourcePool::ReleaseResourceIfFound(ResourceId resource_id) {
+  auto it = in_use_resources_.find(resource_id);
+  if (it == in_use_resources_.end())
+    return;
+  ReleaseResource(resource_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());
+  ReleaseResource(resource->id());
+}
 
-  auto it = in_use_resources_.find(resource->id());
+void ResourcePool::ReleaseResource(ResourceId resource_id) {
+  // Ensure that the provided resource is valid.
+  // TODO(ericrk): Remove this once we've investigated further.
+  // crbug.com/598286.
+  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 std::unique_ptr<PoolResource>& busy_resource) {
-          return busy_resource->id() == resource->id();
+        [resource_id](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 std::unique_ptr<PoolResource>& pool_resource) {
-          return pool_resource->id() == resource->id();
+        [resource_id](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.
@@ skipping 83 matching lines @@
   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;
 
   task_runner_->PostDelayedTask(FROM_HERE,

[ccameron, 2016/07/20 22:13:53]

|task_runner_| isn't optional, but I would suggest making it optional -- for
your use-case, posting tasks doesn't seem worth doing the plumbing.

[erikchen, 2016/07/20 23:40:39]

Whoops, you're right. The method base::ThreadTaskRunnerHandle::Get().get()
allows us to skip all plumbing. I actually think that ResourcePool should call
that method directly, since it expects to post back onto the same thread that
called task_runner_->PostDelayedTask. I'll do that in a follow up CL.

                                 base::Bind(&ResourcePool::EvictExpiredResources,
                                            weak_ptr_factory_.GetWeakPtr()),
                                 time_from_now);
 }
 
 void ResourcePool::EvictExpiredResources() {
   evict_expired_resources_pending_ = false;
   base::TimeTicks current_time = base::TimeTicks::Now();
 
   EvictResourcesNotUsedSince(current_time - resource_expiration_delay_);
@@ skipping 51 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