Add logic to GLRenderer to support RenderPassDrawQuad copying.

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 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 <stdint.h>
 
 #include <set>
 
@@ skipping 2049 matching lines @@
 
   // Verify that overlay_quad actually gets turned into an overlay, and even
   // though it's not drawn, that its sync point is waited on.
   EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token))).Times(1);
   EXPECT_CALL(overlay_scheduler,
               Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _, viewport_rect,
                        BoundingRect(uv_top_left, uv_bottom_right))).Times(1);
 
   DrawFrame(&renderer, viewport_rect);
 }
+}  // namespace
 
-}  // namespace
+// Explicitly named to be a friend in GLRenderer.
+class GLRendererRenderPassDrawQuadCopierTest : public testing::Test {
+  void SetUp() override {
+    settings_.release_overlay_resources_after_gpu_query = true;
+    output_surface_ =
+        FakeOutputSurface::Create3d(std::unique_ptr<TestWebGraphicsContext3D>(
+            new ForbidSynchronousCallContext));
+    CHECK(output_surface_->BindToClient(&output_surface_client_));
+
+    shared_bitmap_manager_.reset(new TestSharedBitmapManager());
+    resource_provider_ = FakeResourceProvider::Create(
+        output_surface_.get(), shared_bitmap_manager_.get());
+
+    renderer_.reset(new FakeRendererGL(&renderer_client_, &settings_,
+                                       output_surface_.get(),
+                                       resource_provider_.get()));
+  }
+
+ protected:
+  FakeOutputSurfaceClient output_surface_client_;
+  std::unique_ptr<OutputSurface> output_surface_;
+  std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
+  std::unique_ptr<ResourceProvider> resource_provider_;
+  RendererSettings settings_;
+  FakeRendererClient renderer_client_;
+  std::unique_ptr<FakeRendererGL> renderer_;
+};
+
+TEST_F(GLRendererRenderPassDrawQuadCopierTest, Reuse) {
+  // Make 4 resources of different sizes.
+  for (int i = 1; i < 5; ++i) {
+    std::unique_ptr<ScopedResource> resource =
+        ScopedResource::Create(resource_provider_.get());
+    resource->Allocate(gfx::Size(i, i), ResourceProvider::TEXTURE_HINT_DEFAULT,
+                       RGBA_8888);
+    renderer_->free_iosurfaces_.emplace_back(std::move(resource));
+  }
+  ResourceId id = renderer_->CreateOrReuseIOSurface(gfx::Size(3, 3));
+  EXPECT_EQ(3u, id);
+  EXPECT_EQ(3u, renderer_->free_iosurfaces_.size());
+  id = renderer_->CreateOrReuseIOSurface(gfx::Size(3, 3));
+  EXPECT_EQ(5u, id);
+  EXPECT_EQ(3u, renderer_->free_iosurfaces_.size());
+}
+
+TEST_F(GLRendererRenderPassDrawQuadCopierTest, ReleaseResources) {
+  // Set cache size to 6.
+  renderer_->UpdateCopyCountForFrame(3);
+  std::map<unsigned, GLRenderer::OverlayResourceLock>& swapped_resources =
+      renderer_->swapped_and_acked_overlay_resources_;
+
+  // ResourceIds 1 through 6 are "in use" by the gpu process.
+  for (int i = 0; i < 6; ++i) {
+    std::unique_ptr<ScopedResource> resource =
+        ScopedResource::Create(resource_provider_.get());
+    resource->Allocate(gfx::Size(1, 1), ResourceProvider::TEXTURE_HINT_DEFAULT,
+                       RGBA_8888);
+
+    // Force the resource to be allocated.
+    {
+      std::unique_ptr<ResourceProvider::ScopedWriteLockGL> lock(
+          new ResourceProvider::ScopedWriteLockGL(resource_provider_.get(),
+                                                  resource->id(), false));
+    }
+
+    std::unique_ptr<ResourceProvider::ScopedReadLockGL> lock(
+        new ResourceProvider::ScopedReadLockGL(resource_provider_.get(),
+                                               resource->id()));
+    swapped_resources[resource->id()] = std::move(lock);
+    renderer_->in_use_iosurfaces_.emplace_back(std::move(resource));
+  }
+  EXPECT_EQ(6u, swapped_resources.size());
+
+  // ResourceIds 7 through 11 are free.
+  for (int i = 0; i < 5; ++i) {
+    std::unique_ptr<ScopedResource> resource =
+        ScopedResource::Create(resource_provider_.get());
+    resource->Allocate(gfx::Size(1, 1), ResourceProvider::TEXTURE_HINT_DEFAULT,
+                       RGBA_8888);
+    renderer_->free_iosurfaces_.emplace_back(std::move(resource));
+  }
+
+  // Free ResourceId 3.
+  auto it = std::find_if(
+      swapped_resources.begin(), swapped_resources.end(),
+      [](std::pair<const unsigned, GLRenderer::OverlayResourceLock>& pair) {
+        return pair.second->resource_id() == 3;
+      });
+  EXPECT_NE(it, swapped_resources.end());
+  renderer_->OverlayResourceNoLongerInUse(it->first);
+  EXPECT_EQ(5u, renderer_->in_use_iosurfaces_.size());
+  EXPECT_EQ(6u, renderer_->free_iosurfaces_.size());
+  EXPECT_EQ(3u, renderer_->free_iosurfaces_[5]->id());
+
+  // Free two more resources.
+  renderer_->OverlayResourceNoLongerInUse(swapped_resources.begin()->first);
+  renderer_->OverlayResourceNoLongerInUse(swapped_resources.begin()->first);
+  EXPECT_EQ(3u, renderer_->in_use_iosurfaces_.size());
+  EXPECT_EQ(6u, renderer_->free_iosurfaces_.size());
+  EXPECT_EQ(9u, renderer_->free_iosurfaces_[0]->id());
+  EXPECT_EQ(10u, renderer_->free_iosurfaces_[1]->id());
+  EXPECT_EQ(11u, renderer_->free_iosurfaces_[2]->id());
+  EXPECT_EQ(3u, renderer_->free_iosurfaces_[3]->id());
+}
+
+TEST_F(GLRendererRenderPassDrawQuadCopierTest, MaxCacheSize) {
+  for (int i = 0; i < 6; ++i) {
+    std::unique_ptr<ScopedResource> resource =
+        ScopedResource::Create(resource_provider_.get());
+    resource->Allocate(gfx::Size(1, 1), ResourceProvider::TEXTURE_HINT_DEFAULT,
+                       RGBA_8888);
+    renderer_->in_use_iosurfaces_.emplace_back(std::move(resource));
+  }
+  for (int i = 0; i < 5; ++i) {
+    std::unique_ptr<ScopedResource> resource =
+        ScopedResource::Create(resource_provider_.get());
+    resource->Allocate(gfx::Size(1, 1), ResourceProvider::TEXTURE_HINT_DEFAULT,
+                       RGBA_8888);
+    renderer_->free_iosurfaces_.emplace_back(std::move(resource));
+  }
+
+  // Set cache size to 4.
+  renderer_->UpdateCopyCountForFrame(2);
+  EXPECT_EQ(4u, renderer_->iosurface_limit_);
+  EXPECT_EQ(6u, renderer_->in_use_iosurfaces_.size());
+  EXPECT_EQ(4u, renderer_->free_iosurfaces_.size());
+
+  // Set cache size to 2.
+  renderer_->UpdateCopyCountForFrame(1);
+  EXPECT_EQ(2u, renderer_->iosurface_limit_);
+  EXPECT_EQ(6u, renderer_->in_use_iosurfaces_.size());
+  EXPECT_EQ(2u, renderer_->free_iosurfaces_.size());
+
+  // Set cache size to 8.
+  renderer_->UpdateCopyCountForFrame(1);
+  EXPECT_EQ(2u, renderer_->iosurface_limit_);
+  EXPECT_EQ(6u, renderer_->in_use_iosurfaces_.size());
+  EXPECT_EQ(2u, renderer_->free_iosurfaces_.size());
+}
+
 }  // namespace cc