cc: Propagate read lock fences constraints to parent compositors.

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 <set>
 
@@ skipping 1027 matching lines @@
                                             id1);
     child_resource_provider_->DeleteResource(id1);
     EXPECT_EQ(1u, child_resource_provider_->num_resources());
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
   }
 
   EXPECT_EQ(0u, child_resource_provider_->num_resources());
   resource_provider_->DestroyChild(child_id);
 }
 
+class TestFence : public ResourceProvider::Fence {
+ public:
+  TestFence() {}
+
+  void Set() override {}
+  bool HasPassed() override { return passed; }
+  void Wait() override {}
+
+  bool passed = false;
+
+ private:
+  ~TestFence() override {}
+};
+
+TEST_P(ResourceProviderTest, ReadLockFenceStopsReturnToChildOrDelete) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+  gfx::Size size(1, 1);
+  ResourceFormat format = RGBA_8888;
+
+  ResourceId id1 = child_resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  uint8_t data1[4] = {1, 2, 3, 4};
+  child_resource_provider_->CopyToResource(id1, data1, size);
+  child_resource_provider_->EnableReadLockFencesForTesting(id1);
+  ReturnedResourceArray returned_to_child;
+  int child_id =
+      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+
+  // Transfer some resources to the parent.
+  ResourceProvider::ResourceIdArray resource_ids_to_transfer;
+  resource_ids_to_transfer.push_back(id1);
+  TransferableResourceArray list;
+  child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
+                                                &list);
+  ASSERT_EQ(1u, list.size());
+  EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));

[piman, 2015/06/16 16:46:20]

nit: you could add an EXPECT_TRUE(list[0].read_lock_fences_enabled)

[Daniele Castagna, 2015/06/17 15:20:41]

Done.

+
+  resource_provider_->ReceiveFromChild(child_id, list);
+
+  scoped_refptr<TestFence> fence(new TestFence);
+  resource_provider_->SetReadLockFence(fence.get());
+  {
+    unsigned parent_id = list.front().id;
+    resource_provider_->WaitSyncPointIfNeeded(parent_id);
+    ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
+                                            parent_id);
+  }
+  resource_provider_->DeclareUsedResourcesFromChild(
+      child_id, ResourceProvider::ResourceIdSet());
+  EXPECT_EQ(0u, returned_to_child.size());
+
+  resource_provider_->DeclareUsedResourcesFromChild(
+      child_id, ResourceProvider::ResourceIdSet());
+  EXPECT_EQ(0u, returned_to_child.size());
+  fence->passed = true;
+
+  resource_provider_->DeclareUsedResourcesFromChild(
+      child_id, ResourceProvider::ResourceIdSet());
+  EXPECT_EQ(1u, returned_to_child.size());
+
+  child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
+  child_resource_provider_->DeleteResource(id1);
+  EXPECT_EQ(0u, child_resource_provider_->num_resources());
+}
+
+TEST_P(ResourceProviderTest, ReadLockFenceDestroyChild) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+  gfx::Size size(1, 1);
+  ResourceFormat format = RGBA_8888;
+
+  ResourceId id1 = child_resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  uint8_t data[4] = {1, 2, 3, 4};
+  child_resource_provider_->CopyToResource(id1, data, size);
+  child_resource_provider_->EnableReadLockFencesForTesting(id1);
+
+  ResourceId id2 = child_resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  child_resource_provider_->CopyToResource(id2, data, size);
+
+  ReturnedResourceArray returned_to_child;
+  int child_id =
+      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+
+  // Transfer resources to the parent.
+  ResourceProvider::ResourceIdArray resource_ids_to_transfer;
+  resource_ids_to_transfer.push_back(id1);
+  resource_ids_to_transfer.push_back(id2);
+  TransferableResourceArray list;
+  child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
+                                                &list);
+  ASSERT_EQ(2u, list.size());
+  EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
+  EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
+
+  resource_provider_->ReceiveFromChild(child_id, list);
+
+  scoped_refptr<TestFence> fence(new TestFence);
+  resource_provider_->SetReadLockFence(fence.get());
+  {
+    for (size_t i = 0; i < list.size(); i++) {
+      unsigned parent_id = list[i].id;
+      resource_provider_->WaitSyncPointIfNeeded(parent_id);
+      ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
+                                              parent_id);
+    }
+  }
+  EXPECT_EQ(0u, returned_to_child.size());
+
+  EXPECT_EQ(2u, resource_provider_->num_resources());
+
+  resource_provider_->DestroyChild(child_id);
+
+  EXPECT_EQ(0u, resource_provider_->num_resources());
+  EXPECT_EQ(2u, returned_to_child.size());
+
+  bool swapped = id1 != returned_to_child.front().id;
+  EXPECT_TRUE(returned_to_child[swapped ? 1 : 0].lost);

[piman, 2015/06/16 16:46:20]

nit: Maybe something along the lines of:
EXPECT_EQ(returned_to_child[0].lost, returned_to_child[0].id == id1);
EXPECT_EQ(returned_to_child[1].lost, returned_to_child[1].id == id1);

To convey than id1 is the one that should be lost and the other one should not?

[Daniele Castagna, 2015/06/17 15:20:41]

Done.

+  EXPECT_FALSE(returned_to_child[swapped ? 0 : 1].lost);
+
+  child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
+  child_resource_provider_->DeleteResource(id1);
+  child_resource_provider_->DeleteResource(id2);
+  EXPECT_EQ(0u, child_resource_provider_->num_resources());
+}
+
+TEST_P(ResourceProviderTest, ReadLockFenceContextLost) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+  gfx::Size size(1, 1);
+  ResourceFormat format = RGBA_8888;
+
+  ResourceId id1 = child_resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  uint8_t data[4] = {1, 2, 3, 4};
+  child_resource_provider_->CopyToResource(id1, data, size);
+  child_resource_provider_->EnableReadLockFencesForTesting(id1);
+
+  ResourceId id2 = child_resource_provider_->CreateResource(
+      size, GL_CLAMP_TO_EDGE, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  child_resource_provider_->CopyToResource(id2, data, size);
+
+  ReturnedResourceArray returned_to_child;
+  int child_id =
+      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+
+  // Transfer resources to the parent.
+  ResourceProvider::ResourceIdArray resource_ids_to_transfer;
+  resource_ids_to_transfer.push_back(id1);
+  resource_ids_to_transfer.push_back(id2);
+  TransferableResourceArray list;
+  child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
+                                                &list);
+  ASSERT_EQ(2u, list.size());
+  EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
+  EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
+
+  resource_provider_->ReceiveFromChild(child_id, list);
+
+  scoped_refptr<TestFence> fence(new TestFence);
+  resource_provider_->SetReadLockFence(fence.get());
+  {
+    for (size_t i = 0; i < list.size(); i++) {
+      unsigned parent_id = list[i].id;
+      resource_provider_->WaitSyncPointIfNeeded(parent_id);
+      ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
+                                              parent_id);
+    }
+  }
+  EXPECT_EQ(0u, returned_to_child.size());
+
+  EXPECT_EQ(2u, resource_provider_->num_resources());
+  resource_provider_->DidLoseOutputSurface();
+  resource_provider_ = nullptr;
+
+  EXPECT_EQ(2u, returned_to_child.size());
+
+  EXPECT_TRUE(returned_to_child[0].lost);
+  EXPECT_TRUE(returned_to_child[1].lost);
+}
+
 TEST_P(ResourceProviderTest, TransferSoftwareResources) {
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_BITMAP)
     return;
 
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id1 = child_resource_provider_->CreateResource(
@@ skipping 2570 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc