Add logic to GLRenderer to support RenderPassDrawQuad copying.

cc/output/gl_renderer.cc

Index: cc/output/gl_renderer.cc
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 2dd854e6e53f1941f56607ee8980c98c3931593b..aeb4d787f3318a3eb26d03e6c22eb774a960bda0 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -20,6 +20,7 @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "cc/base/container_util.h"
@@ -41,6 +42,7 @@
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/raster/scoped_gpu_raster.h"
+#include "cc/resources/resource_pool.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
@@ -371,6 +373,9 @@ GLRenderer::GLRenderer(RendererClient* client,
       context_caps.blend_equation_advanced_coherent;
 
   InitializeSharedObjects();
+
+  overlay_resource_pool_ = ResourcePool::CreateForGpuMemoryBufferResources(
+      resource_provider_, base::ThreadTaskRunnerHandle::Get().get());
 }
 
 GLRenderer::~GLRenderer() {
@@ -3632,13 +3637,30 @@ bool GLRenderer::IsContextLost() {
 
 void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {
   scoped_refptr<CALayerOverlaySharedState> shared_state;
+  size_t copied_render_pass_count = 0;
   for (const CALayerOverlay& ca_layer_overlay : frame->ca_layer_overlay_list) {
+    ResourceId contents_resource_id = ca_layer_overlay.contents_resource_id;
+    Resource* resource = nullptr;
+    // Some CALayers require a final round of processing.
+    if (ca_layer_overlay.render_pass_id.IsValid()) {
+      CopyRenderPassToOverlayResource(ca_layer_overlay.render_pass_id,
+                                      &resource);
+      contents_resource_id = resource->id();
+      ++copied_render_pass_count;
+    }
+
     unsigned texture_id = 0;
-    if (ca_layer_overlay.contents_resource_id) {
+    if (contents_resource_id) {
       pending_overlay_resources_.push_back(
           base::WrapUnique(new ResourceProvider::ScopedReadLockGL(
-              resource_provider_, ca_layer_overlay.contents_resource_id)));
+              resource_provider_, contents_resource_id)));
       texture_id = pending_overlay_resources_.back()->texture_id();
+
+      if (resource) {
+        // Once a resource is released, it is marked as "busy". It will be
+        // available for reuse after the ScopedReadLockGL is destroyed.
+        overlay_resource_pool_->ReleaseResource(resource);
+      }
     }
     GLfloat contents_rect[4] = {
         ca_layer_overlay.contents_rect.x(), ca_layer_overlay.contents_rect.y(),
@@ -3671,6 +3693,11 @@ void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {
         texture_id, contents_rect, ca_layer_overlay.background_color,
         ca_layer_overlay.edge_aa_mask, bounds_rect, filter);
   }
+
+  // Take the number of copied render passes in this frame, and use 3 times that
+  // amount as the cache limit.
+  overlay_resource_pool_->SetResourceUsageLimits(
+      std::numeric_limits<std::size_t>::max(), copied_render_pass_count * 3);
 }
 
 void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {
@@ -3696,4 +3723,34 @@ void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {
   }
 }
 
+void GLRenderer::CopyRenderPassToOverlayResource(
+    const RenderPassId& render_pass_id,
+    Resource** resource) {
+  ScopedResource* contents_texture =
+      render_pass_textures_[render_pass_id].get();
+  DCHECK(contents_texture);
+  DCHECK(contents_texture->id());
+  // TODO(erikchen): Fix this to allow the creation of IOSurfaces.
+  // https://crbug.com/581526.
+  *resource = overlay_resource_pool_->AcquireResource(
+      contents_texture->size(), ResourceFormat::RGBA_8888);
+  ResourceProvider::ScopedWriteLockGL destination(resource_provider_,
+                                                  (*resource)->id(), false);
+
+  GLuint source_texture = 0;
+  std::unique_ptr<ResourceProvider::ScopedReadLockGL> source;
+  if (current_framebuffer_lock_ &&
+      current_framebuffer_lock_->texture_id() == contents_texture->id()) {
+    source_texture = current_framebuffer_lock_->texture_id();
+  } else {
+    source.reset(new ResourceProvider::ScopedReadLockGL(
+        resource_provider_, contents_texture->id()));
+    source_texture = source->texture_id();
+  }
+  gl_->CopySubTextureCHROMIUM(source_texture, destination.texture_id(), 0, 0, 0,

[ccameron, 2016/07/21 20:47:18]

nit: I guess we can just do CopyTextureCHROMIUM? Sorry I didn't notice this
earlier.

[erikchen, 2016/07/21 20:55:14]

I think CopyTextureCHROMIUM would work because of its implementation, but the
semantics would be wrong, since it implies a change in destination
format/allocation, ala CopyTexImage.

+                              0, contents_texture->size().width(),
+                              contents_texture->size().height(), GL_TRUE,
+                              GL_FALSE, GL_FALSE);
+}
+
 }  // namespace cc