cc: Move TextureMailbox::ReleaseCallback to SingleReleaseCallback.

cc/resources/resource_provider_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/resources/resource_provider.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "cc/base/scoped_ptr_deque.h"
 #include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/output/output_surface.h"
 #include "cc/resources/returned_resource.h"
+#include "cc/resources/scoped_release_callback.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 797 matching lines @@
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   unsigned sync_point = context()->insertSyncPoint();
 
   // All the logic below assumes that the sync points are all positive.
   EXPECT_LT(0u, sync_point);
 
   unsigned release_sync_point = 0;
   bool lost_resource = false;
-  TextureMailbox::ReleaseCallback callback =
+  ReleaseCallback callback =
       base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
   ResourceProvider::ResourceId resource =
       resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(mailbox, callback, sync_point));
+          TextureMailbox(mailbox, sync_point),
+          ScopedReleaseCallback(callback));
   EXPECT_EQ(1, context()->texture_count());
   EXPECT_EQ(0u, release_sync_point);
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_LE(sync_point, list[0].sync_point);
@@ skipping 25 matching lines @@
     EXPECT_LE(list[0].sync_point, release_sync_point);
     EXPECT_FALSE(lost_resource);
   }
 
   // We're going to do the same thing as above, but testing the case where we
   // delete the resource before we receive it back.
   sync_point = release_sync_point;
   EXPECT_LT(0u, sync_point);
   release_sync_point = 0;
   resource = resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, callback, sync_point));
+      TextureMailbox(mailbox, sync_point),
+      ScopedReleaseCallback(callback));
   EXPECT_EQ(1, context()->texture_count());
   EXPECT_EQ(0u, release_sync_point);
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_LE(sync_point, list[0].sync_point);
@@ skipping 41 matching lines @@
   context()->bindTexture(GL_TEXTURE_2D, texture);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   unsigned sync_point = context()->insertSyncPoint();
 
   EXPECT_LT(0u, sync_point);
 
   unsigned release_sync_point = 0;
   bool lost_resource = false;
-  TextureMailbox::ReleaseCallback callback =
-      base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
+  ScopedReleaseCallback callback(
+      base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource));
   resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, callback, sync_point));
+      TextureMailbox(mailbox, sync_point),
+      callback.Pass());
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
   resource_provider_.reset();
 
   EXPECT_LE(sync_point, release_sync_point);
   EXPECT_FALSE(lost_resource);
 }
 
@@ skipping 15 matching lines @@
 
 TEST_P(ResourceProviderTest, ShutdownSharedMemory) {
   if (GetParam() != ResourceProvider::Bitmap)
     return;
 
   gfx::Size size(64, 64);
   scoped_ptr<base::SharedMemory> shared_memory(
       CreateAndFillSharedMemory(size, 0));
 
   bool release_called = false;
-  TextureMailbox::ReleaseCallback callback =
-      base::Bind(ReleaseSharedMemoryCallback, &release_called);
+  ScopedReleaseCallback callback(
+      base::Bind(ReleaseSharedMemoryCallback, &release_called));
   resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(shared_memory.get(), size, callback));
+      TextureMailbox(shared_memory.get(), size),
+      callback.Pass());
 
   resource_provider_.reset();
 
   EXPECT_TRUE(release_called);
 }
 
 TEST_P(ResourceProviderTest, ShutdownWithExportedResource) {
   // TextureMailbox callbacks only exist for GL textures for now.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   unsigned sync_point = context()->insertSyncPoint();
 
   EXPECT_LT(0u, sync_point);
 
   unsigned release_sync_point = 0;
   bool lost_resource = false;
-  TextureMailbox::ReleaseCallback callback =
-      base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
+  ScopedReleaseCallback callback(
+      base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource));
   ResourceProvider::ResourceId resource =
       resource_provider_->CreateResourceFromTextureMailbox(
-          TextureMailbox(mailbox, callback, sync_point));
+          TextureMailbox(mailbox, sync_point),
+          callback.Pass());
 
   // Transfer the resource, so we can't release it properly on shutdown.
   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
   resource_ids_to_transfer.push_back(resource);
   TransferableResourceArray list;
   resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
@@ skipping 12 matching lines @@
   context()->bindTexture(GL_TEXTURE_2D, texture);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   unsigned sync_point = context()->insertSyncPoint();
 
   EXPECT_LT(0u, sync_point);
 
   unsigned release_sync_point = 0;
   bool lost_resource = false;
-  TextureMailbox::ReleaseCallback callback =
-      base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource);
+  ScopedReleaseCallback callback(
+      base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource));
   resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, callback, sync_point));
+      TextureMailbox(mailbox, sync_point),
+      callback.Pass());
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
   resource_provider_->DidLoseOutputSurface();
   resource_provider_.reset();
 
   EXPECT_LE(sync_point, release_sync_point);
   EXPECT_TRUE(lost_resource);
 }
@@ skipping 199 matching lines @@
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::CreateSoftware(make_scoped_ptr(
           new SoftwareOutputDevice)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
-  TextureMailbox::ReleaseCallback callback = base::Bind(&EmptyReleaseCallback);
-  TextureMailbox mailbox(shared_memory.get(), size, callback);
+  ScopedReleaseCallback callback(base::Bind(&EmptyReleaseCallback));
+  TextureMailbox mailbox(shared_memory.get(), size);
 
   ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(mailbox);
+      resource_provider->CreateResourceFromTextureMailbox(
+          mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   {
     ResourceProvider::ScopedReadLockSoftware lock(resource_provider.get(), id);
     const SkBitmap* sk_bitmap = lock.sk_bitmap();
     EXPECT_EQ(sk_bitmap->width(), size.width());
     EXPECT_EQ(sk_bitmap->height(), size.height());
     EXPECT_EQ(*sk_bitmap->getAddr32(16, 16), kBadBeef);
   }
 }
@@ skipping 20 matching lines @@
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
-  TextureMailbox::ReleaseCallback callback = base::Bind(&EmptyReleaseCallback);
+  ScopedReleaseCallback callback(base::Bind(&EmptyReleaseCallback));
 
-  TextureMailbox mailbox(gpu_mailbox,
-                         callback,
-                         sync_point);
+  TextureMailbox mailbox(gpu_mailbox, sync_point);
 
   ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(mailbox);
+      resource_provider->CreateResourceFromTextureMailbox(
+          mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
     // Using the texture does a consume of the mailbox.
     EXPECT_CALL(*context, bindTexture(target, texture_id));
     EXPECT_CALL(*context, waitSyncPoint(sync_point));
     EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
 
@@ skipping 36 matching lines @@
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
-  TextureMailbox::ReleaseCallback callback = base::Bind(&EmptyReleaseCallback);
+  ScopedReleaseCallback callback(base::Bind(&EmptyReleaseCallback));
 
-  TextureMailbox mailbox(gpu_mailbox,
-                         callback,
-                         target,
-                         sync_point);
+  TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
   ResourceProvider::ResourceId id =
-      resource_provider->CreateResourceFromTextureMailbox(mailbox);
+      resource_provider->CreateResourceFromTextureMailbox(
+          mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
     // Using the texture does a consume of the mailbox.
     EXPECT_CALL(*context, bindTexture(target, texture_id));
     EXPECT_CALL(*context, waitSyncPoint(sync_point));
     EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
 
@@ skipping 462 matching lines @@
                        output_surface.get());
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc