Add logic to GLRenderer to support RenderPassDrawQuad copying.

cc/output/gl_renderer.h

 // 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.
 
 #ifndef CC_OUTPUT_GL_RENDERER_H_
 #define CC_OUTPUT_GL_RENDERER_H_
 
 #include <deque>
 #include <vector>
 
@@ skipping 17 matching lines @@
 namespace gles2 {
 class GLES2Interface;
 }
 }
 
 namespace cc {
 
 class GLRendererShaderTest;
 class OutputSurface;
 class PictureDrawQuad;
+class ResourcePool;
 class ScopedResource;
 class StreamVideoDrawQuad;
 class TextureDrawQuad;
 class TextureMailboxDeleter;
 class StaticGeometryBinding;
 class DynamicGeometryBinding;
 class ScopedEnsureFramebufferAllocation;
 
 // Class that handles drawing of composited render layers using GL.
 class CC_EXPORT GLRenderer : public DirectRenderer {
@@ skipping 208 matching lines @@
   void RestoreGLState();
   void RestoreFramebuffer(DrawingFrame* frame);
 
   void DiscardBackbuffer() override;
   void EnsureBackbuffer() override;
   void EnforceMemoryPolicy();
 
   void ScheduleCALayers(DrawingFrame* frame);
   void ScheduleOverlays(DrawingFrame* frame);
 
+  // Indicates that an overlay resource with the given |texture| id is no longer
+  // in use.
+  void OverlayResourceNoLongerInUse(GLuint texture);
+
+  // Copies the contents of the render pass to an overlay resource, returned in
+  // |resource_id|. The resource is allocated from |overlay_resource_pool_|, and
+  // stays allocated until OverlayResourceNoLongerInUse() is called.
+  void CopyRenderPassToOverlayResource(const RenderPassId& render_pass_id,
+                                       ResourceId* resource_id);
+
   using OverlayResourceLock =
       std::unique_ptr<ResourceProvider::ScopedReadLockGL>;
   using OverlayResourceLockList = std::vector<OverlayResourceLock>;
 
   // Resources that have been sent to the GPU process, but not yet swapped.
   OverlayResourceLockList pending_overlay_resources_;
 
   // Resources that should be shortly swapped by the GPU process.
   std::deque<OverlayResourceLockList> swapping_overlay_resources_;
 
@@ skipping 238 matching lines @@
   ResourceFormat current_framebuffer_format_;
 
   class SyncQuery;
   std::deque<std::unique_ptr<SyncQuery>> pending_sync_queries_;
   std::deque<std::unique_ptr<SyncQuery>> available_sync_queries_;
   std::unique_ptr<SyncQuery> current_sync_query_;
   bool use_sync_query_;
   bool use_blend_equation_advanced_;
   bool use_blend_equation_advanced_coherent_;
 
+  // Some overlays require that content is copied from a render pass into an
+  // overlay resource. This means the GLRenderer needs its own ResourcePool.
+  std::unique_ptr<ResourcePool> overlay_resource_pool_;

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

I'd add a
  std::map<ResourceId, Resource*> overlay_pool_resources_in_use_
and then ... (cut to gl_render.cc)

+
   BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_