cc: Rationalize sync points and lost status for returned resources

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 <map>
 
 #include "base/bind.h"
@@ skipping 63 matching lines @@
     gfx::Size size,
     uint32_t value) {
   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
   CHECK(shared_memory->CreateAndMapAnonymous(4 * size.GetArea()));
   uint32_t* pixels = reinterpret_cast<uint32_t*>(shared_memory->memory());
   CHECK(pixels);
   std::fill_n(pixels, size.GetArea(), value);
   return shared_memory.Pass();
 }
 
+void ForceUseChildTextures(ResourceProvider* resource_provider,
+                           int child_id,
+                           const TransferableResourceArray& resources) {
+  ResourceProvider::ResourceIdMap resource_map =
+      resource_provider->GetChildToParentMap(child_id);
+  for (size_t i = 0; i < resources.size(); ++i) {
+    ResourceProvider::ResourceId mapped_id = resource_map[resources[i].id];
+    ResourceProvider::ScopedReadLockGL lock(resource_provider, mapped_id);
+    EXPECT_NE(0U, lock.texture_id());
+  }
+}
+
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
   MOCK_METHOD3(texParameteri,
                void(WGC3Denum target, WGC3Denum pname, WGC3Dint param));
   MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point));
   MOCK_METHOD0(insertSyncPoint, unsigned(void));
   MOCK_METHOD2(produceTextureCHROMIUM, void(WGC3Denum target,
                                             const WGC3Dbyte* mailbox));
   MOCK_METHOD2(consumeTextureCHROMIUM, void(WGC3Denum target,
@@ skipping 622 matching lines @@
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), list[1].target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), list[2].target);
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
     resource_provider_->ReceiveFromChild(child_id, list);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_transfer);
   }
 
-  EXPECT_EQ(3u, resource_provider_->num_resources());
-  ResourceProvider::ResourceIdMap resource_map =
-      resource_provider_->GetChildToParentMap(child_id);
-  ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
-  ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
-  ResourceProvider::ResourceId mapped_id3 = resource_map[id3];
-  EXPECT_NE(0u, mapped_id1);
-  EXPECT_NE(0u, mapped_id2);
-  EXPECT_NE(0u, mapped_id3);
-  EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
-  EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
-  EXPECT_FALSE(resource_provider_->InUseByConsumer(id3));
+  uint8_t result[4] = { 0 };
+  {
+    EXPECT_EQ(3u, resource_provider_->num_resources());
+    ResourceProvider::ResourceIdMap resource_map =
+        resource_provider_->GetChildToParentMap(child_id);
+    ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
+    ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
+    ResourceProvider::ResourceId mapped_id3 = resource_map[id3];
+    EXPECT_NE(0u, mapped_id1);
+    EXPECT_NE(0u, mapped_id2);
+    EXPECT_NE(0u, mapped_id3);
+    EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
+    EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
+    EXPECT_FALSE(resource_provider_->InUseByConsumer(id3));
 
-  uint8_t result[4] = { 0 };
-  GetResourcePixels(
-      resource_provider_.get(), context(), mapped_id1, size, format, result);
-  EXPECT_EQ(0, memcmp(data1, result, pixel_size));
+    GetResourcePixels(
+        resource_provider_.get(), context(), mapped_id1, size, format, result);
+    EXPECT_EQ(0, memcmp(data1, result, pixel_size));
 
-  GetResourcePixels(
-      resource_provider_.get(), context(), mapped_id2, size, format, result);
-  EXPECT_EQ(0, memcmp(data2, result, pixel_size));
+    GetResourcePixels(
+        resource_provider_.get(), context(), mapped_id2, size, format, result);
+    EXPECT_EQ(0, memcmp(data2, result, pixel_size));
+
+    ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
+                                            mapped_id3);
+    EXPECT_NE(0U, lock.texture_id());
+  }
 
   {
     // Check that transfering again the same resource from the child to the
     // parent works.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     EXPECT_EQ(1u, list.size());
@@ skipping 62 matching lines @@
     EXPECT_NE(0u, list[2].sync_point);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), list[0].target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), list[1].target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), list[2].target);
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
     resource_provider_->ReceiveFromChild(child_id, list);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_transfer);
+    // Lock resources in child to make sure they get "used".
+    ForceUseChildTextures(resource_provider_.get(), child_id, list);
   }
 
   EXPECT_EQ(0u, returned_to_child.size());
 
   EXPECT_EQ(3u, resource_provider_->num_resources());
   resource_provider_->DestroyChild(child_id);
   EXPECT_EQ(0u, resource_provider_->num_resources());
 
   ASSERT_EQ(3u, returned_to_child.size());
   EXPECT_NE(0u, returned_to_child[0].sync_point);
@@ skipping 415 matching lines @@
     EXPECT_EQ(0u, returned_to_child.size());
     EXPECT_EQ(2u, resource_provider_->num_resources());
 
     // Return the resources from the grandparent to the parent. They should be
     // returned to the child then.
     EXPECT_EQ(2u, list.size());
     EXPECT_EQ(mapped_id1, list[0].id);
     EXPECT_EQ(mapped_id2, list[1].id);
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(list, &returned);
+    EXPECT_EQ(2u, returned.size());
+    if (GetParam() == ResourceProvider::GLTexture) {
+      returned[0].sync_point = 3;
+      returned[1].sync_point = 4;
+    }
     resource_provider_->ReceiveReturnsFromParent(returned);
 
     EXPECT_EQ(0u, resource_provider_->num_resources());
     ASSERT_EQ(2u, returned_to_child.size());
     if (GetParam() == ResourceProvider::GLTexture) {
       EXPECT_NE(0u, returned_to_child[0].sync_point);
       EXPECT_NE(0u, returned_to_child[1].sync_point);
     }
     EXPECT_FALSE(returned_to_child[0].lost);
     EXPECT_FALSE(returned_to_child[1].lost);
@@ skipping 83 matching lines @@
     // Return a resource from the grandparent, it should be returned at this
     // point.
     EXPECT_EQ(2u, list.size());
     EXPECT_EQ(mapped_id1, list[0].id);
     EXPECT_EQ(mapped_id2, list[1].id);
     TransferableResourceArray return_list;
     return_list.push_back(list[1]);
     list.pop_back();
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(return_list, &returned);
+    EXPECT_EQ(1u, returned.size());
+    if (GetParam() == ResourceProvider::GLTexture)
+      returned[0].sync_point = 3;
     resource_provider_->ReceiveReturnsFromParent(returned);
 
     EXPECT_EQ(1u, resource_provider_->num_resources());
     ASSERT_EQ(1u, returned_to_child.size());
-    if (GetParam() == ResourceProvider::GLTexture) {
+    if (GetParam() == ResourceProvider::GLTexture)
       EXPECT_NE(0u, returned_to_child[0].sync_point);
-    }
     EXPECT_FALSE(returned_to_child[0].lost);
     returned_to_child.clear();
 
     // Destroy the parent resource provider. The resource that's left should be
     // lost at this point, and returned.
     resource_provider_.reset();
     ASSERT_EQ(1u, returned_to_child.size());
-    if (GetParam() == ResourceProvider::GLTexture) {
-      EXPECT_NE(0u, returned_to_child[0].sync_point);
-    }
     EXPECT_TRUE(returned_to_child[0].lost);
   }
 }
 
 TEST_P(ResourceProviderTest, DeleteTransferredResources) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
@@ skipping 13 matching lines @@
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(1u, list.size());
     if (GetParam() == ResourceProvider::GLTexture)
       EXPECT_NE(0u, list[0].sync_point);
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id));
     resource_provider_->ReceiveFromChild(child_id, list);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_transfer);
+    if (GetParam() == ResourceProvider::GLTexture)
+      ForceUseChildTextures(resource_provider_.get(), child_id, list);
   }
 
   // Delete textures in the child, while they are transfered.
   child_resource_provider_->DeleteResource(id);
   EXPECT_EQ(1u, child_resource_provider_->num_resources());
   {
     EXPECT_EQ(0u, returned_to_child.size());
 
     // Transfer resources back from the parent to the child. Set no resources as
     // being in use.
@@ skipping 107 matching lines @@
       EXPECT_CALL(*child_context,
                   produceTextureCHROMIUM(GL_TEXTURE_2D, _));
       EXPECT_CALL(*child_context, insertSyncPoint());
       child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
                                                    &list);
       Mock::VerifyAndClearExpectations(child_context);
 
       ASSERT_EQ(1u, list.size());
       EXPECT_EQ(static_cast<unsigned>(child_filter), list[0].filter);
 
+      parent_resource_provider->ReceiveFromChild(child_id, list);
+
       EXPECT_CALL(*parent_context,
                   bindTexture(GL_TEXTURE_2D, parent_texture_id));
       EXPECT_CALL(*parent_context, consumeTextureCHROMIUM(GL_TEXTURE_2D, _));
-      parent_resource_provider->ReceiveFromChild(child_id, list);
+      ForceUseChildTextures(parent_resource_provider.get(), child_id, list);
       Mock::VerifyAndClearExpectations(parent_context);
 
       parent_resource_provider->DeclareUsedResourcesFromChild(
           child_id, resource_ids_to_transfer);
       Mock::VerifyAndClearExpectations(parent_context);
     }
     ResourceProvider::ResourceIdMap resource_map =
         parent_resource_provider->GetChildToParentMap(child_id);
     ResourceProvider::ResourceId mapped_id = resource_map[id];
     EXPECT_NE(0u, mapped_id);
@@ skipping 95 matching lines @@
     context()->waitSyncPoint(list[0].sync_point);
     unsigned other_texture = context()->createTexture();
     context()->bindTexture(GL_TEXTURE_2D, other_texture);
     context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     uint8_t test_data[4] = { 0 };
     context()->GetPixels(
         gfx::Size(1, 1), RGBA_8888, test_data);
     EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
     context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     context()->deleteTexture(other_texture);
-    list[0].sync_point = context()->insertSyncPoint();
-    EXPECT_LT(0u, list[0].sync_point);
+    unsigned return_sync_point = context()->insertSyncPoint();
+    EXPECT_LT(0u, return_sync_point);
 
     // Receive the resource, then delete it, expect the sync points to be
     // consistent.
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(list, &returned);
+    EXPECT_EQ(1u, returned.size());
+    returned[0].sync_point = return_sync_point;
+
     resource_provider_->ReceiveReturnsFromParent(returned);
     EXPECT_EQ(1u, context()->NumTextures());
     EXPECT_EQ(0u, release_sync_point);
 
     resource_provider_->DeleteResource(resource);
-    EXPECT_LE(list[0].sync_point, release_sync_point);
+    EXPECT_LE(returned[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, sync_point),
@@ skipping 15 matching lines @@
     context()->waitSyncPoint(list[0].sync_point);
     unsigned other_texture = context()->createTexture();
     context()->bindTexture(GL_TEXTURE_2D, other_texture);
     context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     uint8_t test_data[4] = { 0 };
     context()->GetPixels(
         gfx::Size(1, 1), RGBA_8888, test_data);
     EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
     context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     context()->deleteTexture(other_texture);
-    list[0].sync_point = context()->insertSyncPoint();
-    EXPECT_LT(0u, list[0].sync_point);
+    unsigned return_sync_point = context()->insertSyncPoint();
+    EXPECT_LT(0u, return_sync_point);
 
     // Delete the resource, which shouldn't do anything.
     resource_provider_->DeleteResource(resource);
     EXPECT_EQ(1u, context()->NumTextures());
     EXPECT_EQ(0u, release_sync_point);
 
     // Then receive the resource which should release the mailbox, expect the
     // sync points to be consistent.
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(list, &returned);
+    EXPECT_EQ(1u, returned.size());
+    returned[0].sync_point = return_sync_point;
+
     resource_provider_->ReceiveReturnsFromParent(returned);
     EXPECT_LE(list[0].sync_point, release_sync_point);
     EXPECT_FALSE(lost_resource);
   }
 
   context()->waitSyncPoint(release_sync_point);
   context()->bindTexture(GL_TEXTURE_2D, texture);
   context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   context()->deleteTexture(texture);
 }
@@ skipping 243 matching lines @@
   // Delete the resource in the child. Expect the resource to be lost.
   child_resource_provider_->DeleteResource(resource);
   EXPECT_TRUE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, Shutdown) {
   unsigned release_sync_point = 0;
   bool lost_resource = false;
   bool release_called = false;
   unsigned sync_point = 0;
-  CreateChildMailbox(
+  ResourceProvider::ResourceId resource = CreateChildMailbox(
       &release_sync_point, &lost_resource, &release_called, &sync_point);
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
+  if (GetParam() == ResourceProvider::GLTexture) {
+    ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
+                                            resource);
+  }
+
   child_resource_provider_.reset();
 
   if (GetParam() == ResourceProvider::GLTexture) {
     EXPECT_LE(sync_point, release_sync_point);
   }
   EXPECT_TRUE(release_called);
   EXPECT_FALSE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, ShutdownWithExportedResource) {
@@ skipping 31 matching lines @@
   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;
   scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
       base::Bind(ReleaseTextureMailbox, &release_sync_point, &lost_resource));
-  resource_provider_->CreateResourceFromTextureMailbox(
-      TextureMailbox(mailbox, sync_point),
-      callback.Pass());
+  ResourceProvider::ResourceId resource =
+      resource_provider_->CreateResourceFromTextureMailbox(
+          TextureMailbox(mailbox, sync_point), callback.Pass());
 
   EXPECT_EQ(0u, release_sync_point);
   EXPECT_FALSE(lost_resource);
 
+  if (GetParam() == ResourceProvider::GLTexture) {
+    ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(), resource);
+  }
+
   resource_provider_->DidLoseOutputSurface();
   resource_provider_.reset();
 
-  EXPECT_LE(sync_point, release_sync_point);
+  EXPECT_EQ(0u, release_sync_point);
   EXPECT_TRUE(lost_resource);
 }
 
 TEST_P(ResourceProviderTest, ScopedSampler) {
   // Sampling is only supported for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
@@ skipping 947 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc