Cache OpenGL textures and other objects in CompositingIOSurfaceMac copy/transform code.

content/browser/renderer_host/compositing_iosurface_mac.h

 // Copyright (c) 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_COMPOSITING_IOSURFACE_MAC_H_
 #define CONTENT_BROWSER_RENDERER_HOST_COMPOSITING_IOSURFACE_MAC_H_
 
 #include <deque>
+#include <vector>
 
 #import <Cocoa/Cocoa.h>
 #import <QuartzCore/CVDisplayLink.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/callback.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
@@ skipping 162 matching lines @@
       // a projection with a flipped y-axis (origin is top left).
       verts_[0].set_texcoord(tx1, ty2);
       verts_[1].set_texcoord(tx1, ty1);
       verts_[2].set_texcoord(tx2, ty1);
       verts_[3].set_texcoord(tx2, ty2);
     }
     SurfaceVertex verts_[4];
   };
 
   // Keeps track of states and buffers for readback of IOSurface.
+  //
+  // TODO(miu): Major code refactoring is badly needed!  To be done in a
+  // soon-upcoming change.  For now, we blatantly violate the style guide with
+  // respect to struct vs. class usage:
   struct CopyContext {
-    CopyContext();
+    explicit CopyContext(const scoped_refptr<CompositingIOSurfaceContext>& ctx);
     ~CopyContext();
-    void CleanUp();
 
+    // Delete any references to owned OpenGL objects.  This must be called
+    // within the OpenGL context just before destruction.
+    void ReleaseCachedGLObjects();
+
+    // The following two methods assume |num_outputs| has been set, and are
+    // being called within the OpenGL context.
+    void PrepareReadbackFramebuffers();
+    void PrepareForAsynchronousReadback();
+
+    const scoped_ptr<CompositingIOSurfaceTransformer> transformer;
     int num_outputs;
-    GLuint output_textures[3];
+    GLuint output_textures[3];  // Not owned.
     // Note: For YUV, the |output_texture_sizes| widths are in terms of 4-byte
     // quads, not pixels.
     gfx::Size output_texture_sizes[3];
     GLuint frame_buffers[3];
     GLuint pixel_buffers[3];
     GLuint fence;  // When non-zero, doing an asynchronous copy.
     int cycles_elapsed;
     base::Callback<bool(const void*, int)> map_buffer_callback;
     base::Callback<void(bool)> done_callback;
   };
@@ skipping 66 matching lines @@
       CopyContext* copy_context,
       const SkBitmap* bitmap_output,
       const scoped_refptr<media::VideoFrame>& video_frame_output);
 
   // Scan the list of started asynchronous copies and test if each one has
   // completed.
   void FinishAllCopies();
   void FinishAllCopiesWithinContext(
       std::vector<base::Closure>* done_callbacks);
 
-  void CleanupAllCopiesWithinContext();
   void FailAllCopies();
+  void DestroyAllCopyContextsWithinContext();
 
   gfx::Rect IntersectWithIOSurface(const gfx::Rect& rect,
                                    float scale_factor) const;
 
   // Cached pointer to IOSurfaceSupport Singleton.
   IOSurfaceSupport* io_surface_support_;
 
   // GL context, and parameters for context sharing. This may change when
   // moving between windows, but will never be NULL.
   scoped_refptr<CompositingIOSurfaceContext> context_;
 
   // IOSurface data.
   uint64 io_surface_handle_;
   base::mac::ScopedCFTypeRef<CFTypeRef> io_surface_;
 
   // The width and height of the io surface.
   gfx::Size pixel_io_surface_size_;  // In pixels.
   gfx::Size io_surface_size_;  // In view units.
 
   // The "live" OpenGL texture referring to this IOSurfaceRef. Note
   // that per the CGLTexImageIOSurface2D API we do not need to
   // explicitly update this texture's contents once created. All we
   // need to do is ensure it is re-bound before attempting to draw
   // with it.
   GLuint texture_;
 
-  std::deque<CopyContext> copy_requests_;
+  // A pool of CopyContexts with OpenGL objects ready for re-use.  Prefer to
+  // pull one from the pool before creating a new CopyContext.
+  std::vector<CopyContext*> copy_context_pool_;
+
+  // CopyContexts being used for in-flight copy operations.
+  std::deque<CopyContext*> copy_requests_;
 
   // Timer for finishing a copy operation.
   base::Timer finish_copy_timer_;
 
-  scoped_ptr<CompositingIOSurfaceTransformer> transformer_;
-
   SurfaceQuad quad_;
 
   // CVDisplayLink for querying Vsync timing info and throttling swaps.
   CVDisplayLinkRef display_link_;
 
   // Timer for stopping display link after a timeout with no swaps.
   base::DelayTimer<CompositingIOSurfaceMac> display_link_stop_timer_;
 
   // Lock for sharing data between UI thread and display-link thread.
   base::Lock lock_;
 
   // Counts for throttling swaps.
   int64 vsync_count_;
   int64 swap_count_;
 
   // Vsync timing data.
   base::TimeTicks vsync_timebase_;
   uint32 vsync_interval_numerator_;
   uint32 vsync_interval_denominator_;
 
   bool initialized_is_intel_;
   bool is_intel_;
   GLint screen_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_COMPOSITING_IOSURFACE_MAC_H_