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 376 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();
   CleanupSharedObjects();
 }
 
 const RendererCapabilitiesImpl& GLRenderer::Capabilities() const {
   return capabilities_;
 }
 
 void GLRenderer::DidChangeVisibility() {
   EnforceMemoryPolicy();
 
@@ skipping 2302 matching lines @@
                                            : swap_buffer_rect_.y(),
                   swap_buffer_rect_.width(), swap_buffer_rect_.height());
   } else {
     // Expand the swap rect to the full surface unless it's empty, and empty
     // swap is allowed.
     if (!swap_buffer_rect_.IsEmpty() || !capabilities_.allow_empty_swap) {
       swap_buffer_rect_ = gfx::Rect(surface_size);
     }
     compositor_frame.gl_frame_data->sub_buffer_rect = swap_buffer_rect_;
   }
+
+  swapping_overlay_resources_.push_back(std::move(pending_overlay_resources_));
+  pending_overlay_resources_.clear();
+
   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 &&

[ccameron, 2016/05/17 22:40:25]

This "!settings_->release_overlay_resources_on_swap_complete" logic is used by
Chrome OS ... GLRendererWithOverlaysTest.ResourcesExportedAndReturnedWithDelay
should be testing this.

[erikchen, 2016/05/17 23:22:33]

I get it. You wanted me to reuse the *overlay_resources data structures, but not
necessarily the logic.

The logic *does* turn out to be reusable, but it causes the phrase
"release_overlay_resources_on_swap_complete" to not be obviously accurate.  I've
chosen to take this route.

The alternative is to introduce another setting, or perhaps make this setting an
enum.

-      swapped_overlay_resources_.size() > 2) {
-    swapped_overlay_resources_.pop_front();
-  }
   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();
+  if (swapping_overlay_resources_.empty()) {
+    ReleaseOverlayResources();

[ccameron, 2016/05/17 22:40:25]

This is easier to read without the early-out.

   if (settings_->release_overlay_resources_on_swap_complete &&
+    for (OverlayResourceLock& lock : swapped_overlay_resources_.front()) {
+      swapped_and_acked_overlay_resources_[lock->GetResourceId()] =
+          std::move(lock);
+    }
     swapped_overlay_resources_.pop_front();
   }

[erikchen, 2016/05/17 23:22:33]

Done.

+    return;
   }
+
+  OverlayResourceLockList& list = swapping_overlay_resources_[0];
+  for (OverlayResourceLock& lock : list) {
+    ResourceId resource_id = lock->GetResourceId();
+
+    // Theoretically, there should be a DCHECK here that asserts that the
+    // resource is not already in swapped_and_acked_overlay_resources_. However,
+    // there are compositor consumers that reuse resources without waiting for
+    // them to be returned.

[ccameron, 2016/05/17 22:40:25]

This comment isn't right -- the renderer is not allowed to write to the resource
while the read lock is out, but it is expected to specify the same resource
frame-after-frame.

[erikchen, 2016/05/17 23:22:33]

got it.

+    swapped_and_acked_overlay_resources_[resource_id] = std::move(lock);
+  }
+  list.clear();
+  swapping_overlay_resources_.erase(swapping_overlay_resources_.begin());
+  ReleaseOverlayResources();

[ccameron, 2016/05/17 22:40:25]

I'd just move the ReleaseOverlayResources code here inline.

[erikchen, 2016/05/17 23:22:33]

Done.

 }
 
 void GLRenderer::EnforceMemoryPolicy() {
   if (!visible()) {
     TRACE_EVENT0("cc", "GLRenderer::EnforceMemoryPolicy dropping resources");
     ReleaseRenderPassTextures();
     DiscardBackbuffer();
     output_surface_->context_provider()->DeleteCachedResources();
     gl_->Flush();
   }
@@ skipping 849 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(
+          base::WrapUnique(new ResourceProvider::ScopedReadLockGpuMemoryBuffer(
               resource_provider_, ca_layer_overlay.contents_resource_id)));
-      texture_id = pending_overlay_resources_.back()->texture_id();
+      texture_id = pending_overlay_resources_.back()->GetTextureId();
     }
     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 20 matching lines @@
     return;
 
   OverlayCandidateList& overlays = frame->overlay_list;
   for (const OverlayCandidate& overlay : overlays) {
     unsigned texture_id = 0;
     if (overlay.use_output_surface_for_resource) {
       texture_id = output_surface_->GetOverlayTextureId();
       DCHECK(texture_id || IsContextLost());
     } else {
       pending_overlay_resources_.push_back(
-          base::WrapUnique(new ResourceProvider::ScopedReadLockGL(
+          base::WrapUnique(new ResourceProvider::ScopedReadLockGpuMemoryBuffer(
               resource_provider_, overlay.resource_id)));
-      texture_id = pending_overlay_resources_.back()->texture_id();
+      texture_id = pending_overlay_resources_.back()->GetTextureId();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
+void GLRenderer::ReleaseOverlayResources() {
+  auto it = swapped_and_acked_overlay_resources_.begin();
+  while (it != swapped_and_acked_overlay_resources_.end()) {
+    if (it->second->GetGpuMemoryBuffer() &&
+        it->second->GetGpuMemoryBuffer()->IsInUseByMacOSWindowServer()) {
+      ++it;
+      continue;
+    }
+
+    it = swapped_and_acked_overlay_resources_.erase(it);
+  }
+}
+
 }  // namespace cc