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>
 
 #include "base/cancelable_callback.h"
 #include "base/macros.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/gl_renderer_draw_cache.h"
 #include "cc/output/program_binding.h"
 #include "cc/output/renderer.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
+#include "cc/resources/scoped_resource.h"
 #include "ui/gfx/geometry/quad_f.h"
 
 class SkBitmap;
 
 namespace gpu {
 namespace gles2 {
 class GLES2Interface;
 }
 }
 
@@ skipping 108 matching lines @@
       const gfx::Transform& device_transform,
       const RenderPassDrawQuad* quad,
       const gfx::QuadF* device_layer_quad,
       const gfx::QuadF* clip_region,
       gfx::QuadF* local_quad,
       float edge[24]);
 
  private:
   friend class GLRendererShaderPixelTest;
   friend class GLRendererShaderTest;
+  FRIEND_TEST_ALL_PREFIXES(GLRendererRenderPassDrawQuadCopierTest, Reuse);
+  FRIEND_TEST_ALL_PREFIXES(GLRendererRenderPassDrawQuadCopierTest,
+                           ReleaseResources);
+  FRIEND_TEST_ALL_PREFIXES(GLRendererRenderPassDrawQuadCopierTest,
+                           MaxCacheSize);
 
   static void ToGLMatrix(float* gl_matrix, const gfx::Transform& transform);
 
   void DiscardPixels();
   void ClearFramebuffer(DrawingFrame* frame);
   void SetViewport();
 
   void DrawDebugBorderQuad(const DrawingFrame* frame,
                            const DebugBorderDrawQuad* quad);
   static bool IsDefaultBlendMode(SkXfermode::Mode blend_mode) {
@@ skipping 95 matching lines @@
   void RestoreGLState();
   void RestoreFramebuffer(DrawingFrame* frame);
 
   void DiscardBackbuffer() override;
   void EnsureBackbuffer() override;
   void EnforceMemoryPolicy();
 
   void ScheduleCALayers(DrawingFrame* frame);
   void ScheduleOverlays(DrawingFrame* frame);
 
+  void OverlayResourceNoLongerInUse(GLuint texture);
+  ResourceId CreateOrReuseIOSurface(const gfx::Size& size);
+  void DeleteIOSurfacesOverCacheLimit();
+
+  // RenderPassDrawQuadCopier
+  bool CopyRenderPassDrawQuadToIOSurface(const RenderPassDrawQuad* quad,
+                                         ResourceId* resource_id) override;
+  void ReleaseIOSurfaces(const std::vector<ResourceId>& resources) override;
+  void UpdateCopyCountForFrame(size_t count) override;
+
   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_;
 
+  // Keep an LRU buffer of GMB resources to encourage reuse.

[ccameron, 2016/07/20 05:32:19]

Can we use/augment the existing
cc::ResourcePool::CreateForGpuMemoryBufferResources instead?

[Also, I'd be a fan of doing IOSurface reuse in the GPU process, or something
like that, but that's a discussion for another day].

[erikchen, 2016/07/20 21:48:01]

Done.

+  std::vector<std::unique_ptr<ScopedResource>> in_use_iosurfaces_;
+  std::vector<std::unique_ptr<ScopedResource>> free_iosurfaces_;
+  size_t iosurface_limit_ = 0;
+
   BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_