Return overlay resources to renderers in larger batches.

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 2642 matching lines @@
 
     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);
       }
       gl_->ScheduleCALayerInUseQueryCHROMIUM(textures.size(), textures.data());
     }
   } else if (swapping_overlay_resources_.size() > 1) {
+    resource_provider_->SetBatchReturnResources(true);

[Daniele Castagna, 2017/03/24 01:44:43]

Should we have something like ScopedBacthReturnResources instead?
Otherwise it seems like it could be easy to forget to set it back to false and
that would cause issues.

+
     // If a query is not needed to release the overlay buffers, we can assume
     // that once a swap buffer has completed we can remove the oldest buffers
     // from the queue.
     swapping_overlay_resources_.pop_front();
+    resource_provider_->SetBatchReturnResources(false);
   }
 }
 
 void GLRenderer::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
   DCHECK(settings_->release_overlay_resources_after_gpu_query);
+  resource_provider_->SetBatchReturnResources(true);
   for (const gpu::TextureInUseResponse& response : responses) {
     if (!response.in_use) {
       swapped_and_acked_overlay_resources_.erase(response.texture);
     }
   }
+  resource_provider_->SetBatchReturnResources(false);
   color_lut_cache_.Swap();
 }
 
 void GLRenderer::GetFramebufferPixelsAsync(
     const gfx::Rect& rect,
     std::unique_ptr<CopyOutputRequest> request) {
   DCHECK(!request->IsEmpty());
   if (request->IsEmpty())
     return;
   if (rect.IsEmpty())
@@ skipping 519 matching lines @@
   if (overlay_resource_pool_) {
     overlay_resource_pool_->CheckBusyResources();
   }
 
   scoped_refptr<DCLayerOverlaySharedState> shared_state;
   size_t copied_render_pass_count = 0;
   for (const DCLayerOverlay& dc_layer_overlay :
        current_frame()->dc_layer_overlay_list) {
     DCHECK(!dc_layer_overlay.rpdq);
 
-    ResourceId contents_resource_id = dc_layer_overlay.contents_resource_id;
     unsigned texture_id = 0;
-    if (contents_resource_id) {
-      pending_overlay_resources_.push_back(
-          base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
-              resource_provider_, contents_resource_id));
-      texture_id = pending_overlay_resources_.back()->texture_id();
+    for (const auto& contents_resource_id : dc_layer_overlay.resources) {
+      if (contents_resource_id) {
+        pending_overlay_resources_.push_back(
+            base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
+                resource_provider_, contents_resource_id));
+        if (!texture_id)
+          texture_id = pending_overlay_resources_.back()->texture_id();
+      }
     }
     GLfloat contents_rect[4] = {
         dc_layer_overlay.contents_rect.x(), dc_layer_overlay.contents_rect.y(),
         dc_layer_overlay.contents_rect.width(),
         dc_layer_overlay.contents_rect.height(),
     };
     GLfloat bounds_rect[4] = {
         dc_layer_overlay.bounds_rect.x(), dc_layer_overlay.bounds_rect.y(),
         dc_layer_overlay.bounds_rect.width(),
         dc_layer_overlay.bounds_rect.height(),
@@ skipping 348 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc