Modified old wait sync point functions to also accept new sync tokens.

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>
 #include <vector>
@@ skipping 169 matching lines @@
              pending_produce_textures_.begin();
          it != pending_produce_textures_.end();
          ++it) {
       shared_data_->ProduceTexture(
           (*it)->mailbox, sync_point, (*it)->texture);
     }
     pending_produce_textures_.clear();
     return sync_point;
   }
 
-  void waitSyncPoint(GLuint sync_point) override {
+  void waitSyncPoint(GLuint sync_point,
+                     const gpu::SyncToken& sync_token) override {
     last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
+    if (last_waited_sync_token_.release_count() > sync_token.release_count()) {
+      last_waited_sync_token_ = sync_token;
+    }
   }
 
   unsigned last_waited_sync_point() const { return last_waited_sync_point_; }
 
+  const gpu::SyncToken last_waited_sync_token() const {

[dcheng, 2015/10/27 19:09:28]

Just curious: did you intentionally not return a const ref?

[David Yen, 2015/10/28 22:03:43]

Good catch, was a typo.

+    return last_waited_sync_token_;
+  }
+
   void texStorage2DEXT(GLenum target,
                        GLint levels,
                        GLuint internalformat,
                        GLint width,
                        GLint height) override {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_EQ(1, levels);
     GLenum format = GL_RGBA;
     switch (internalformat) {
@@ skipping 63 matching lines @@
     memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
     base::AutoLock lock_for_texture_access(namespace_->lock);
     pending->texture = UnboundTexture(texture);
     pending_produce_textures_.push_back(pending.Pass());
   }
 
   GLuint createAndConsumeTextureCHROMIUM(GLenum target,
                                          const GLbyte* mailbox) override {
     GLuint texture_id = createTexture();
     base::AutoLock lock_for_texture_access(namespace_->lock);
-    scoped_refptr<TestTexture> texture =
-        shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_);
+    scoped_refptr<TestTexture> texture = shared_data_->ConsumeTexture(
+        mailbox, last_waited_sync_point_, last_waited_sync_token_);
     namespace_->textures.Replace(texture_id, texture);
     return texture_id;
   }
 
   void GetPixels(const gfx::Size& size,
                  ResourceFormat format,
                  uint8_t* pixels) {
     CheckTextureIsBound(GL_TEXTURE_2D);
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture = BoundTexture(GL_TEXTURE_2D);
@@ skipping 48 matching lines @@
     }
   }
 
   struct PendingProduceTexture {
     GLbyte mailbox[GL_MAILBOX_SIZE_CHROMIUM];
     scoped_refptr<TestTexture> texture;
   };
   typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
   ContextSharedData* shared_data_;
   GLuint last_waited_sync_point_;
+  gpu::SyncToken last_waited_sync_token_;
   PendingProduceTextureList pending_produce_textures_;
 };
 
 void GetResourcePixels(ResourceProvider* resource_provider,
                        ResourceProviderContext* context,
                        ResourceId id,
                        const gfx::Size& size,
                        ResourceFormat format,
                        uint8_t* pixels) {
   resource_provider->WaitSyncPointIfNeeded(id);
@@ skipping 287 matching lines @@
               list[2].mailbox_holder.texture_target);
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES),
               list[3].mailbox_holder.texture_target);
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id4));
     resource_provider_->ReceiveFromChild(child_id, list);
     EXPECT_NE(list[0].mailbox_holder.sync_point,
               context3d_->last_waited_sync_point());
+    EXPECT_NE(list[0].mailbox_holder.sync_token,
+              context3d_->last_waited_sync_token());
     {
       resource_provider_->WaitSyncPointIfNeeded(list[0].id);
       ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
                                               list[0].id);
     }
     EXPECT_EQ(list[0].mailbox_holder.sync_point,
               context3d_->last_waited_sync_point());
+    EXPECT_EQ(list[0].mailbox_holder.sync_token,
+              context3d_->last_waited_sync_token());
     ResourceProvider::ResourceIdSet resource_ids_to_receive;
     resource_ids_to_receive.insert(id1);
     resource_ids_to_receive.insert(id2);
     resource_ids_to_receive.insert(id3);
     resource_ids_to_receive.insert(id4);
     resource_provider_->DeclareUsedResourcesFromChild(child_id,
                                                       resource_ids_to_receive);
   }
 
   EXPECT_EQ(4u, resource_provider_->num_resources());
@@ skipping 1385 matching lines @@
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_LE(sync_point, list[0].mailbox_holder.sync_point);
     EXPECT_EQ(0,
               memcmp(mailbox.name,
                      list[0].mailbox_holder.mailbox.name,
                      sizeof(mailbox.name)));
     EXPECT_EQ(0u, release_sync_point);
 
-    context()->waitSyncPoint(list[0].mailbox_holder.sync_point);
+    context()->waitSyncPoint(list[0].mailbox_holder.sync_point,
+                             list[0].mailbox_holder.sync_token);
     unsigned other_texture =
         context()->createAndConsumeTextureCHROMIUM(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()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D,
                                             mailbox.name);
     context()->deleteTexture(other_texture);
@@ skipping 31 matching lines @@
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_LE(sync_point, list[0].mailbox_holder.sync_point);
     EXPECT_EQ(0,
               memcmp(mailbox.name,
                      list[0].mailbox_holder.mailbox.name,
                      sizeof(mailbox.name)));
     EXPECT_EQ(0u, release_sync_point);
 
-    context()->waitSyncPoint(list[0].mailbox_holder.sync_point);
+    context()->waitSyncPoint(list[0].mailbox_holder.sync_point,
+                             list[0].mailbox_holder.sync_token);
     unsigned other_texture =
         context()->createAndConsumeTextureCHROMIUM(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()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D,
                                             mailbox.name);
     context()->deleteTexture(other_texture);
     list[0].mailbox_holder.sync_point = context()->insertSyncPoint();
     EXPECT_LT(0u, list[0].mailbox_holder.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);
     resource_provider_->ReceiveReturnsFromParent(returned);
     EXPECT_LE(list[0].mailbox_holder.sync_point, release_sync_point);
     EXPECT_FALSE(lost_resource);
     EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
   }
 
-  context()->waitSyncPoint(release_sync_point);
+  context()->waitSyncPoint(release_sync_point, gpu::SyncToken());
   texture =
       context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   context()->deleteTexture(texture);
 }
 
 TEST_P(ResourceProviderTest, LostResourceInParent) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   ResourceId resource = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
@@ skipping 619 matching lines @@
 
     scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
         output_surface.get(), shared_bitmap_manager, gpu_memory_buffer_manager,
         main_thread_task_runner, 0, 1, use_image_texture_targets_));
 
     unsigned texture_id = 1;
     uint32 sync_point = 30;
     unsigned target = GL_TEXTURE_2D;
 
     EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+    EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
     EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
     EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
     gpu::Mailbox gpu_mailbox;
     memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
     uint32 release_sync_point = 0;
     bool lost_resource = false;
     BlockingTaskRunner* mailbox_task_runner = NULL;
     scoped_ptr<SingleReleaseCallbackImpl> callback =
         SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
                                                      &release_sync_point,
                                                      &lost_resource,
                                                      &mailbox_task_runner));
 
     TextureMailbox mailbox(gpu_mailbox, target, sync_point);
     mailbox.set_nearest_neighbor(mailbox_nearest_neighbor);
 
     ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
         mailbox, callback.Pass());
     EXPECT_NE(0u, id);
 
     Mock::VerifyAndClearExpectations(context);
 
     {
       // Mailbox sync point WaitSyncPoint before using the texture.
-      EXPECT_CALL(*context, waitSyncPoint(sync_point));
+      EXPECT_CALL(*context, waitSyncPoint(sync_point, _));
       resource_provider->WaitSyncPointIfNeeded(id);
       Mock::VerifyAndClearExpectations(context);
 
       EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _))
           .WillOnce(Return(texture_id));
       EXPECT_CALL(*context, bindTexture(target, texture_id));
 
       EXPECT_CALL(*context, insertSyncPoint()).Times(0);
       EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
       // The sampler will reset these if |mailbox_nearest_neighbor| does not
       // match |sampler_filter|.
       if (mailbox_nearest_neighbor != (sampler_filter == GL_NEAREST)) {
         EXPECT_CALL(*context, texParameteri(
             GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, sampler_filter));
         EXPECT_CALL(*context, texParameteri(
             GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, sampler_filter));
       }
 
       ResourceProvider::ScopedSamplerGL lock(
           resource_provider.get(), id, sampler_filter);
       Mock::VerifyAndClearExpectations(context);
 
       // When done with it, a sync point should be inserted, but no produce is
       // necessary.
       EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
       EXPECT_CALL(*context, insertSyncPoint());
       EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
-      EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+      EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
       EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
     }
 
     resource_provider->DeleteResource(id);
     EXPECT_EQ(0u, release_sync_point);
     EXPECT_FALSE(lost_resource);
     EXPECT_EQ(main_thread_task_runner, mailbox_task_runner);
   }
 };
 
@@ skipping 65 matching lines @@
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), NULL, 0, 1,
       use_image_texture_targets_));
 
   uint32 sync_point = 30;
   unsigned target = GL_TEXTURE_EXTERNAL_OES;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-  EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+  EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 
   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
     // Mailbox sync point WaitSyncPoint before using the texture.
-    EXPECT_CALL(*context, waitSyncPoint(sync_point));
+    EXPECT_CALL(*context, waitSyncPoint(sync_point, _));
     resource_provider->WaitSyncPointIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
 
     unsigned texture_id = 1;
 
     EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _))
         .WillOnce(Return(texture_id));
 
     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
     EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
     ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
     Mock::VerifyAndClearExpectations(context);
 
     // When done with it, a sync point should be inserted, but no produce is
     // necessary.
     EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
     EXPECT_CALL(*context, insertSyncPoint());
     EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+    EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
     EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
   }
 }
 
 TEST_P(ResourceProviderTest,
        TextureMailbox_WaitSyncPointIfNeeded_WithSyncPoint) {
   // Mailboxing is only supported for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(context_owned.Pass()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), NULL, 0, 1,
       use_image_texture_targets_));
 
   uint32 sync_point = 30;
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-  EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+  EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 
   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
     // First call to WaitSyncPointIfNeeded should call waitSyncPoint.
-    EXPECT_CALL(*context, waitSyncPoint(sync_point));
+    EXPECT_CALL(*context, waitSyncPoint(sync_point, _));
     resource_provider->WaitSyncPointIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
 
     // Subsequent calls to WaitSyncPointIfNeeded shouldn't call waitSyncPoint.
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+    EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
     resource_provider->WaitSyncPointIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
   }
 }
 
 TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncPointIfNeeded_NoSyncPoint) {
   // Mailboxing is only supported for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   scoped_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(context_owned.Pass()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
       output_surface.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), NULL, 0, 1,
       use_image_texture_targets_));
 
   uint32 sync_point = 0;
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
-  EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+  EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
   EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
   EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
 
   gpu::Mailbox gpu_mailbox;
   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 
   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
   ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
       mailbox, callback.Pass());
   EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 
   {
     // WaitSyncPointIfNeeded with sync_point == 0 shouldn't call waitSyncPoint.
-    EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
+    EXPECT_CALL(*context, waitSyncPoint(_, _)).Times(0);
     resource_provider->WaitSyncPointIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
   }
 }
 
 class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD0(NextTextureId, GLuint());
   MOCK_METHOD1(RetireTextureId, void(GLuint id));
   MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
@@ skipping 442 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc