Add logic to ResourceProvider to correctly lock GpuMemoryBuffer Resources.

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 240 matching lines @@
   void RestoreGLState();
   void RestoreFramebuffer(DrawingFrame* frame);
 
   void DiscardBackbuffer() override;
   void EnsureBackbuffer() override;
   void EnforceMemoryPolicy();
 
   void ScheduleCALayers(DrawingFrame* frame);
   void ScheduleOverlays(DrawingFrame* frame);
 
+  // Releases the read lock from GpuMemoryBuffer resources that are no longer in
+  // use by the Window Server.
+  void ReleaseGpuMemoryBufferResources();
+
   using OverlayResourceLockList =
       std::vector<std::unique_ptr<ResourceProvider::ScopedReadLockGL>>;
   OverlayResourceLockList pending_overlay_resources_;
   std::deque<OverlayResourceLockList> swapped_overlay_resources_;
 
+  using GmbResourceLockList = std::vector<
+      std::unique_ptr<ResourceProvider::ScopedReadLockGpuMemoryBuffer>>;
+
+  // GpuMemoryBuffers that have been sent to the GPU process for display.
+  GmbResourceLockList pending_gmb_resources_;
+
+  // GpuMemoryBuffers that are known to have been received by the Window Server.
+  std::deque<GmbResourceLockList> in_use_gmb_resources_;

[ccameron, 2016/05/17 03:36:38]

Couple of things:

1. This logic should be shared with the OverlayResourceLockList. The platforms
that use ScheduleOverlayPlane should actually be using a
ScopedReadLockGpuMemoryBuffer as well, since they're not actually using the
resource in OpenGL (they're doing some equivalent GMB thing on their platforms
-- they just don't have an 'in use' parameter).

2. This could potentially grow without bound -- if you're watching a video then,
ideally, most of the resources are getting re-used for thousands of frames on
end.

We should have a
  map<ResourceId, unique_ptr<ScopedReadLockGpuMemoryBuffer>>
instead.

I think the groups would be
- pending_overlay_resources (vector)
- swapped_overlay_resources (deque of vectors)
- swapped_and_acked_overlay_resources (map)
When we get a swap-ack, we merge the oldest of swapped into swapped_and_acked
(instead of removing it).

[erikchen, 2016/05/17 22:13:20]

Done.
Right. I added a comment in the implementation indicating that we should have a
DCHECK, but currently don't, since some compositor consumers incorrectly reuse
resources while they may still be in use by the Window Server. I've also updated
the logic to be more resilient to this.
Done.

+
   RendererCapabilitiesImpl capabilities_;
 
   unsigned offscreen_framebuffer_id_;
 
   std::unique_ptr<StaticGeometryBinding> shared_geometry_;
   std::unique_ptr<DynamicGeometryBinding> clipped_geometry_;
   gfx::QuadF shared_geometry_quad_;
 
   // This block of bindings defines all of the programs used by the compositor
   // itself.  Add any new programs here to GLRendererShaderTest.
@@ skipping 246 matching lines @@
 
   SkBitmap on_demand_tile_raster_bitmap_;
   ResourceId on_demand_tile_raster_resource_id_;
   BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_