Add logic to GLRenderer to support RenderPassDrawQuad copying.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 23 matching lines @@
 #include "cc/output/output_surface.h"
 #include "cc/output/render_surface_filters.h"
 #include "cc/output/static_geometry_binding.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/draw_polygon.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #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"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImage.h"
@@ skipping 310 matching lines @@
     capabilities_.max_msaa_samples = 0;
   else
     capabilities_.max_msaa_samples = context_caps.max_samples;
 
   use_sync_query_ = context_caps.sync_query;
   use_blend_equation_advanced_ = context_caps.blend_equation_advanced;
   use_blend_equation_advanced_coherent_ =
       context_caps.blend_equation_advanced_coherent;
 
   InitializeSharedObjects();
+
+  // TODO(erikchen): Fix this to allow the creation of IOSurfaces.
+  // https://crbug.com/581526.
+  overlay_resource_pool_ = ResourcePool::CreateForGpuMemoryBufferResources(
+      resource_provider_, nullptr);
 }
 
 GLRenderer::~GLRenderer() {
   while (!pending_async_read_pixels_.empty()) {
     PendingAsyncReadPixels* pending_read =
         pending_async_read_pixels_.back().get();
     pending_read->finished_read_pixels_callback.Cancel();
     pending_async_read_pixels_.pop_back();
   }
 
@@ skipping 2405 matching lines @@
       gl_->ScheduleCALayerInUseQueryCHROMIUM(textures.size(), textures.data());
     }
   }
 }
 
 void GLRenderer::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
   DCHECK(settings_->release_overlay_resources_after_gpu_query);
   for (const gpu::TextureInUseResponse& response : responses) {
     if (!response.in_use) {
-      swapped_and_acked_overlay_resources_.erase(response.texture);
+      OverlayResourceNoLongerInUse(response.texture);
     }
   }
 }
 
 void GLRenderer::EnforceMemoryPolicy() {
   if (!visible()) {
     TRACE_EVENT0("cc", "GLRenderer::EnforceMemoryPolicy dropping resources");
     ReleaseRenderPassTextures();
     DiscardBackbuffer();
     output_surface_->context_provider()->DeleteCachedResources();
@@ skipping 814 matching lines @@
   // PrepareSurfaceForPass also clears the surface, which is not desired when
   // restoring.
   SetViewport();
 }
 
 bool GLRenderer::IsContextLost() {
   return gl_->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
 }
 
 void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {
+  size_t copied_render_pass_count = 0;
   for (const CALayerOverlay& ca_layer_overlay : frame->ca_layer_overlay_list) {

[ccameron, 2016/07/21 05:31:16]

Resource* overlay_resource = nullptr;

+    ResourceId contents_resource_id = ca_layer_overlay.contents_resource_id;
+    // Some CALayers require a final round of processing.
+    if (ca_layer_overlay.render_pass_id.IsValid()) {
+      ResourceId resource_id;
+      CopyRenderPassToOverlayResource(ca_layer_overlay.render_pass_id,
+                                      &resource_id);

[ccameron, 2016/07/21 05:31:16]

CopyRenderPassToOverlayResource now takes a Resource**, &overlay_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();
     }

[ccameron, 2016/07/21 05:31:16]

At this point it's safe to
if (overlay_resource)
  overlay_resource_pool_->ReleaseResource(overlay_resource)
because we have the lock, which will prevent the pool from re-using it.

We could, alternatively, save up a vector of Resource*s, and release them all at
the end, if that seems better.

     GLfloat contents_rect[4] = {
         ca_layer_overlay.contents_rect.x(), ca_layer_overlay.contents_rect.y(),
         ca_layer_overlay.contents_rect.width(),
         ca_layer_overlay.contents_rect.height(),
     };
     GLfloat bounds_rect[4] = {
         ca_layer_overlay.bounds_rect.x(), ca_layer_overlay.bounds_rect.y(),
         ca_layer_overlay.bounds_rect.width(),
         ca_layer_overlay.bounds_rect.height(),
     };
     GLboolean is_clipped = ca_layer_overlay.shared_state->is_clipped;
     GLfloat clip_rect[4] = {ca_layer_overlay.shared_state->clip_rect.x(),
                             ca_layer_overlay.shared_state->clip_rect.y(),
                             ca_layer_overlay.shared_state->clip_rect.width(),
                             ca_layer_overlay.shared_state->clip_rect.height()};
     GLint sorting_context_id =
         ca_layer_overlay.shared_state->sorting_context_id;
     GLfloat transform[16];
     ca_layer_overlay.shared_state->transform.asColMajorf(transform);
     unsigned filter = ca_layer_overlay.filter;
     gl_->ScheduleCALayerCHROMIUM(
         texture_id, contents_rect, ca_layer_overlay.shared_state->opacity,
         ca_layer_overlay.background_color, ca_layer_overlay.edge_aa_mask,
         bounds_rect, is_clipped, clip_rect, sorting_context_id, transform,
         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) {
   if (frame->overlay_list.empty())
     return;
 
   OverlayCandidateList& overlays = frame->overlay_list;
   for (const OverlayCandidate& overlay : overlays) {
     unsigned texture_id = 0;
     if (overlay.use_output_surface_for_resource) {
       texture_id = output_surface_->GetOverlayTextureId();
       DCHECK(texture_id || IsContextLost());
     } else {
       pending_overlay_resources_.push_back(
           base::WrapUnique(new ResourceProvider::ScopedReadLockGL(
               resource_provider_, overlay.resource_id)));
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
+void GLRenderer::OverlayResourceNoLongerInUse(GLuint texture) {
+  auto it = swapped_and_acked_overlay_resources_.find(texture);
+  if (it != swapped_and_acked_overlay_resources_.end()) {
+    overlay_resource_pool_->ReleaseResourceIfFound(it->second->resource_id());
+    swapped_and_acked_overlay_resources_.erase(it);

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

(from gl_renderer.h) ... 

We can just check for resource_id in overlay_pool_resources_in_use_, and release
it back to the pool if we find it.

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

I don't think that's a great idea. We'd be maintaining a copy of the member
|in_use_resources_| of resource pool, using separate logic, just so that we
could check whether a given resource is in the data structure.

[ccameron, 2016/07/21 05:31:16]

This would now no longer need to do the release.

+  }
+}
+
+void GLRenderer::CopyRenderPassToOverlayResource(
+    const RenderPassId& render_pass_id,
+    ResourceId* resource_id) {
+  ScopedResource* contents_texture =
+      render_pass_textures_[render_pass_id].get();
+  DCHECK(contents_texture);
+  DCHECK(contents_texture->id());
+  Resource* resource = overlay_resource_pool_->AcquireResource(
+      contents_texture->size(), ResourceFormat::RGBA_8888);
+  *resource_id = resource->id();
+  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,
+                              0, contents_texture->size().width(),
+                              contents_texture->size().height(), GL_TRUE,
+                              GL_FALSE, GL_FALSE);
+}
+
 }  // namespace cc