Pass responsibility for IOSurface-texture reuse to the gpu process.

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 2683 matching lines @@
       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();
 
   // 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.
-  if (!settings_->release_overlay_resources_on_swap_complete &&
+  if (!settings_->release_overlay_resources_after_gpu_query &&
       swapping_overlay_resources_.size() > 2) {
     swapping_overlay_resources_.pop_front();
   }
 
   output_surface_->SwapBuffers(&compositor_frame);
 
   swap_buffer_rect_ = gfx::Rect();
 }
 
 void GLRenderer::SwapBuffersComplete() {
-  // On OS X, the logic in this block moves resources into
-  // |swapped_and_acked_overlay_resources_|, and then erases resources from
-  // |swapped_and_acked_overlay_resources_| that are no longer in use by the
-  // Window Server. On other platforms, since resources are never in use by the
-  // Window Server, this is equivalent to just erasing all resources from the
-  // first element of |swapping_overlay_resources_|.
-  if (settings_->release_overlay_resources_on_swap_complete) {
-    // Move resources known to be acked into
-    // |swapped_and_acked_overlay_resources_|.
+  // Once a resouce has been swap-ACKed, send a query to the GPU process to ask
+  // if the resource is no longer being consumed by the system compositor. The
+  // response will come with the next swap-ACK.
+  if (settings_->release_overlay_resources_after_gpu_query) {
     if (!swapping_overlay_resources_.empty()) {
       for (OverlayResourceLock& lock : swapping_overlay_resources_.front()) {
-        swapped_and_acked_overlay_resources_[lock->GetResourceId()] =
-            std::move(lock);
+        unsigned texture = lock->GetTextureId();
+        if (swapped_and_acked_overlay_resources_.find(texture) ==
+            swapped_and_acked_overlay_resources_.end()) {
+          swapped_and_acked_overlay_resources_[texture] = std::move(lock);
+        }
       }
       swapping_overlay_resources_.pop_front();
     }
 
-    // Release resources that are no longer in use by the Window Server.
-    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;
+    if (!swapped_and_acked_overlay_resources_.empty()) {
+      std::vector<unsigned> textures;
+      textures.reserve(swapped_and_acked_overlay_resources_.size());
+      for (auto& pair : swapped_and_acked_overlay_resources_) {
+        textures.push_back(pair.first);
       }
-
-      it = swapped_and_acked_overlay_resources_.erase(it);
+      gl_->ScheduleCALayerInUseQueryCHROMIUM(textures.size(), textures.data());
     }
   }
 }
+
+void GLRenderer::DidReceiveTextureInUseResponses(
+    const gpu::TextureInUseResponses& responses) {
+  DCHECK(settings_->release_overlay_resources_after_gpu_query);
+  for (const gpu::TextureInUseResponse& response : responses) {
+    if (!response.in_use) {
+      auto it = swapped_and_acked_overlay_resources_.find(response.texture);

[dcheng, 2016/06/15 08:47:21]

Out of curiosity, why isn't this just a call to erase()?

[erikchen, 2016/06/20 16:16:31]

Mistake, fixed.

+      if (it != swapped_and_acked_overlay_resources_.end())
+        swapped_and_acked_overlay_resources_.erase(it);
+    }
+  }
+}
 
 void GLRenderer::EnforceMemoryPolicy() {
   if (!visible()) {
     TRACE_EVENT0("cc", "GLRenderer::EnforceMemoryPolicy dropping resources");
     ReleaseRenderPassTextures();
     DiscardBackbuffer();
     output_surface_->context_provider()->DeleteCachedResources();
     gl_->Flush();
   }
   PrepareGeometry(NO_BINDING);
@@ skipping 889 matching lines @@
       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);
   }
 }
 
 }  // namespace cc