Add logic to ResourceProvider to correctly lock GpuMemoryBuffer Resources.

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 377 matching lines @@
 
 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();
   }
 
   swapped_overlay_resources_.clear();
+  ReleaseGpuMemoryBufferResources();
+
   CleanupSharedObjects();
 }
 
 const RendererCapabilitiesImpl& GLRenderer::Capabilities() const {
   return capabilities_;
 }
 
 void GLRenderer::DidChangeVisibility() {
   EnforceMemoryPolicy();
 
@@ skipping 2312 matching lines @@
   output_surface_->SwapBuffers(&compositor_frame);
 
   // We always hold onto resources until an extra frame has swapped, to make
   // sure we don't update the buffer while it's being scanned out.
   swapped_overlay_resources_.push_back(std::move(pending_overlay_resources_));
   pending_overlay_resources_.clear();
   if (!settings_->release_overlay_resources_on_swap_complete &&
       swapped_overlay_resources_.size() > 2) {
     swapped_overlay_resources_.pop_front();
   }
+
+  // Make the assumption that by the time a second SwapBuffers has come in, the
+  // resources in |pending_gmb_resources_| have been received, processed, (and
+  // possibly displayed) by the Window Server.
+  if (!pending_gmb_resources_.empty()) {
+    in_use_gmb_resources_.push_back(std::move(pending_gmb_resources_));
+    pending_gmb_resources_.clear();
+  }
+  ReleaseGpuMemoryBufferResources();
+
   swap_buffer_rect_ = gfx::Rect();
 }
 
 void GLRenderer::SwapBuffersComplete() {
   if (settings_->release_overlay_resources_on_swap_complete &&
       !swapped_overlay_resources_.empty()) {
     swapped_overlay_resources_.pop_front();
   }
 }
 
@@ skipping 856 matching lines @@
 }
 
 bool GLRenderer::IsContextLost() {
   return gl_->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
 }
 
 void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {
   for (const CALayerOverlay& ca_layer_overlay : frame->ca_layer_overlay_list) {
     unsigned texture_id = 0;
     if (ca_layer_overlay.contents_resource_id) {
-      pending_overlay_resources_.push_back(
-          base::WrapUnique(new ResourceProvider::ScopedReadLockGL(
+      pending_gmb_resources_.push_back(
+          base::WrapUnique(new ResourceProvider::ScopedReadLockGpuMemoryBuffer(
               resource_provider_, ca_layer_overlay.contents_resource_id)));
-      texture_id = pending_overlay_resources_.back()->texture_id();
+      texture_id = pending_gmb_resources_.back()->texture_id();
     }
     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(),
@@ skipping 31 matching lines @@
               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::ReleaseGpuMemoryBufferResources() {
+  // Remove resources that are no longer in use by the Window Server.
+  for (auto& resources_vector : in_use_gmb_resources_) {
+    resources_vector.erase(
+        std::remove_if(
+            resources_vector.begin(), resources_vector.end(),
+            [](std::unique_ptr<ResourceProvider::ScopedReadLockGpuMemoryBuffer>&
+                   lock) { return !lock->IsInUseByMacOSWindowServer(); }),
+        resources_vector.end());
+  }
+
+  // Remove vectors that are empty.
+  in_use_gmb_resources_.erase(
+      std::remove_if(in_use_gmb_resources_.begin(), in_use_gmb_resources_.end(),
+                     [](GmbResourceLockList& list) { return list.empty(); }),
+      in_use_gmb_resources_.end());
+}
+
 }  // namespace cc