Move sync point from TransferResourceList to individual TransferResources

cc/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/resource_provider.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/output_surface.h"
 #include "cc/scoped_ptr_deque.h"
@@ skipping 411 matching lines @@
     uint8_t data2[4] = {5, 5, 5, 5};
     childResourceProvider->setPixels(id2, data2, rect, rect, gfx::Vector2d());
 
     int childId = m_resourceProvider->createChild();
 
     {
         // Transfer some resources to the parent.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(id1);
         resourceIdsToTransfer.push_back(id2);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         childResourceProvider->prepareSendToParent(resourceIdsToTransfer, &list);
-        EXPECT_NE(0u, list.sync_point);
-        EXPECT_EQ(2u, list.resources.size());
+        ASSERT_EQ(2u, list.size());
+        EXPECT_NE(0u, list[0].sync_point);
+        EXPECT_NE(0u, list[1].sync_point);
         EXPECT_TRUE(childResourceProvider->inUseByConsumer(id1));
         EXPECT_TRUE(childResourceProvider->inUseByConsumer(id2));
         m_resourceProvider->receiveFromChild(childId, list);
     }
 
     EXPECT_EQ(2u, m_resourceProvider->numResources());
     ResourceProvider::ResourceIdMap resourceMap = m_resourceProvider->getChildToParentMap(childId);
     ResourceProvider::ResourceId mappedId1 = resourceMap[id1];
     ResourceProvider::ResourceId mappedId2 = resourceMap[id2];
     EXPECT_NE(0u, mappedId1);
     EXPECT_NE(0u, mappedId2);
     EXPECT_FALSE(m_resourceProvider->inUseByConsumer(id1));
     EXPECT_FALSE(m_resourceProvider->inUseByConsumer(id2));
 
     uint8_t result[4] = {0};
     getResourcePixels(mappedId1, size, format, result);
     EXPECT_EQ(0, memcmp(data1, result, pixelSize));
 
     getResourcePixels(mappedId2, size, format, result);
     EXPECT_EQ(0, memcmp(data2, result, pixelSize));
 
     {
         // Check that transfering again the same resource from the child to the
         // parent is a noop.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(id1);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         childResourceProvider->prepareSendToParent(resourceIdsToTransfer, &list);
-        EXPECT_EQ(0u, list.sync_point);
-        EXPECT_EQ(0u, list.resources.size());
+        EXPECT_EQ(0u, list.size());
     }
 
     {
         // Transfer resources back from the parent to the child.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(mappedId1);
         resourceIdsToTransfer.push_back(mappedId2);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         m_resourceProvider->prepareSendToChild(childId, resourceIdsToTransfer, &list);
-        EXPECT_NE(0u, list.sync_point);
-        EXPECT_EQ(2u, list.resources.size());
+        ASSERT_EQ(2u, list.size());
+        EXPECT_NE(0u, list[0].sync_point);
+        EXPECT_NE(0u, list[1].sync_point);
         childResourceProvider->receiveFromParent(list);
     }
     EXPECT_FALSE(childResourceProvider->inUseByConsumer(id1));
     EXPECT_FALSE(childResourceProvider->inUseByConsumer(id2));
 
     ResourceProviderContext* childContext3D = static_cast<ResourceProviderContext*>(childOutputSurface->context3d());
     {
         ResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id1);
         ASSERT_NE(0U, lock.textureId());
         childContext3D->bindTexture(GL_TEXTURE_2D, lock.textureId());
         childContext3D->getPixels(size, format, result);
         EXPECT_EQ(0, memcmp(data1, result, pixelSize));
     }
     {
         ResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id2);
         ASSERT_NE(0U, lock.textureId());
         childContext3D->bindTexture(GL_TEXTURE_2D, lock.textureId());
         childContext3D->getPixels(size, format, result);
         EXPECT_EQ(0, memcmp(data2, result, pixelSize));
     }
 
     {
         // Transfer resources to the parent again.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(id1);
         resourceIdsToTransfer.push_back(id2);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         childResourceProvider->prepareSendToParent(resourceIdsToTransfer, &list);
-        EXPECT_NE(0u, list.sync_point);
-        EXPECT_EQ(2u, list.resources.size());
+        ASSERT_EQ(2u, list.size());
+        EXPECT_NE(0u, list[0].sync_point);
+        EXPECT_NE(0u, list[1].sync_point);
         EXPECT_TRUE(childResourceProvider->inUseByConsumer(id1));
         EXPECT_TRUE(childResourceProvider->inUseByConsumer(id2));
         m_resourceProvider->receiveFromChild(childId, list);
     }
 
     EXPECT_EQ(2u, m_resourceProvider->numResources());
     m_resourceProvider->destroyChild(childId);
     EXPECT_EQ(0u, m_resourceProvider->numResources());
 }
 
@@ skipping 15 matching lines @@
     uint8_t data[4] = {1, 2, 3, 4};
     gfx::Rect rect(gfx::Point(), size);
     childResourceProvider->setPixels(id, data, rect, rect, gfx::Vector2d());
 
     int childId = m_resourceProvider->createChild();
 
     {
         // Transfer some resource to the parent.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(id);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         childResourceProvider->prepareSendToParent(resourceIdsToTransfer, &list);
-        EXPECT_NE(0u, list.sync_point);
-        EXPECT_EQ(1u, list.resources.size());
+        ASSERT_EQ(1u, list.size());
+        EXPECT_NE(0u, list[0].sync_point);
         EXPECT_TRUE(childResourceProvider->inUseByConsumer(id));
         m_resourceProvider->receiveFromChild(childId, list);
     }
 
     // Delete textures in the child, while they are transfered.
     childResourceProvider->deleteResource(id);
     EXPECT_EQ(1u, childResourceProvider->numResources());
 
     {
         // Transfer resources back from the parent to the child.
         ResourceProvider::ResourceIdMap resourceMap = m_resourceProvider->getChildToParentMap(childId);
         ResourceProvider::ResourceId mappedId = resourceMap[id];
         EXPECT_NE(0u, mappedId);
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(mappedId);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         m_resourceProvider->prepareSendToChild(childId, resourceIdsToTransfer, &list);
-        EXPECT_NE(0u, list.sync_point);
-        EXPECT_EQ(1u, list.resources.size());
+        ASSERT_EQ(1u, list.size());
+        EXPECT_NE(0u, list[0].sync_point);
         childResourceProvider->receiveFromParent(list);
     }
     EXPECT_EQ(0u, childResourceProvider->numResources());
 }
 
 void ReleaseTextureMailbox(unsigned* releaseSyncPoint, unsigned syncPoint) {
     *releaseSyncPoint = syncPoint;
 }
 
 TEST_P(ResourceProviderTest, TransferMailboxResources)
@@ skipping 16 matching lines @@
     unsigned releaseSyncPoint = 0;
     TextureMailbox::ReleaseCallback callback = base::Bind(ReleaseTextureMailbox, &releaseSyncPoint);
     ResourceProvider::ResourceId resource = m_resourceProvider->createResourceFromTextureMailbox(TextureMailbox(mailbox, callback, syncPoint));
     EXPECT_EQ(1u, context()->textureCount());
     EXPECT_EQ(0u, releaseSyncPoint);
 
     {
         // Transfer the resource, expect the sync points to be consistent.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(resource);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         m_resourceProvider->prepareSendToParent(resourceIdsToTransfer, &list);
-        EXPECT_LE(syncPoint, list.sync_point);
-        EXPECT_EQ(1u, list.resources.size());
-        EXPECT_EQ(0u, memcmp(mailbox.name, list.resources[0].mailbox.name, sizeof(mailbox.name)));
+        ASSERT_EQ(1u, list.size());
+        EXPECT_LE(syncPoint, list[0].sync_point);
+        EXPECT_EQ(0u, memcmp(mailbox.name, list[0].mailbox.name, sizeof(mailbox.name)));
         EXPECT_EQ(0u, releaseSyncPoint);
 
-        context()->waitSyncPoint(list.sync_point);
+        context()->waitSyncPoint(list[0].sync_point);
         unsigned otherTexture = context()->createTexture();
         context()->bindTexture(GL_TEXTURE_2D, otherTexture);
         context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
         uint8_t testData[4] = {0};
         context()->getPixels(gfx::Size(1, 1), GL_RGBA, testData);
         EXPECT_EQ(0u, memcmp(data, testData, sizeof(data)));
         context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
         context()->deleteTexture(otherTexture);
-        list.sync_point = context()->insertSyncPoint();
-        EXPECT_LT(0u, list.sync_point);
+        list[0].sync_point = context()->insertSyncPoint();
+        EXPECT_LT(0u, list[0].sync_point);
 
         // Receive the resource, then delete it, expect the sync points to be consistent.
         m_resourceProvider->receiveFromParent(list);
         EXPECT_EQ(1u, context()->textureCount());
         EXPECT_EQ(0u, releaseSyncPoint);
 
         m_resourceProvider->deleteResource(resource);
-        EXPECT_LE(list.sync_point, releaseSyncPoint);
+        EXPECT_LE(list[0].sync_point, releaseSyncPoint);
     }
 
 
     // We're going to do the same thing as above, but testing the case where we
     // delete the resource before we receive it back.
     syncPoint = releaseSyncPoint;
     EXPECT_LT(0u, syncPoint);
     releaseSyncPoint = 0;
     resource = m_resourceProvider->createResourceFromTextureMailbox(TextureMailbox(mailbox, callback, syncPoint));
     EXPECT_EQ(1u, context()->textureCount());
     EXPECT_EQ(0u, releaseSyncPoint);
 
     {
         // Transfer the resource, expect the sync points to be consistent.
         ResourceProvider::ResourceIdArray resourceIdsToTransfer;
         resourceIdsToTransfer.push_back(resource);
-        TransferableResourceList list;
+        TransferableResourceArray list;
         m_resourceProvider->prepareSendToParent(resourceIdsToTransfer, &list);
-        EXPECT_LE(syncPoint, list.sync_point);
-        EXPECT_EQ(1u, list.resources.size());
-        EXPECT_EQ(0u, memcmp(mailbox.name, list.resources[0].mailbox.name, sizeof(mailbox.name)));
+        ASSERT_EQ(1u, list.size());
+        EXPECT_LE(syncPoint, list[0].sync_point);
+        EXPECT_EQ(0u, memcmp(mailbox.name, list[0].mailbox.name, sizeof(mailbox.name)));
         EXPECT_EQ(0u, releaseSyncPoint);
 
-        context()->waitSyncPoint(list.sync_point);
+        context()->waitSyncPoint(list[0].sync_point);
         unsigned otherTexture = context()->createTexture();
         context()->bindTexture(GL_TEXTURE_2D, otherTexture);
         context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
         uint8_t testData[4] = {0};
         context()->getPixels(gfx::Size(1, 1), GL_RGBA, testData);
         EXPECT_EQ(0u, memcmp(data, testData, sizeof(data)));
         context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
         context()->deleteTexture(otherTexture);
-        list.sync_point = context()->insertSyncPoint();
-        EXPECT_LT(0u, list.sync_point);
+        list[0].sync_point = context()->insertSyncPoint();
+        EXPECT_LT(0u, list[0].sync_point);
 
         // Delete the resource, which shouldn't do anything.
         m_resourceProvider->deleteResource(resource);
         EXPECT_EQ(1u, context()->textureCount());
         EXPECT_EQ(0u, releaseSyncPoint);
 
         // Then receive the resource which should release the mailbox, expect the sync points to be consistent.
         m_resourceProvider->receiveFromParent(list);
-        EXPECT_LE(list.sync_point, releaseSyncPoint);
+        EXPECT_LE(list[0].sync_point, releaseSyncPoint);
     }
 
     context()->waitSyncPoint(releaseSyncPoint);
     context()->bindTexture(GL_TEXTURE_2D, texture);
     context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     context()->deleteTexture(texture);
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
 public:
@@ skipping 167 matching lines @@
     Mock::VerifyAndClearExpectations(context);
 }
 
 INSTANTIATE_TEST_CASE_P(ResourceProviderTests,
                         ResourceProviderTest,
                         ::testing::Values(ResourceProvider::GLTexture,
                                           ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc