cc: Allocate resources on worker context.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 18 matching lines @@
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
+using testing::InSequence;
 using testing::Mock;
 using testing::NiceMock;
+using testing::Pointee;
 using testing::Return;
 using testing::StrictMock;
+using testing::TypedEq;
 using testing::_;
 
 namespace cc {
 namespace {
 
 static const bool kUseGpuMemoryBufferResources = false;
 static const bool kEnableColorCorrectRendering = false;
 static const bool kDelegatedSyncPointsRequired = true;
 
 MATCHER_P(MatchesSyncToken, sync_token, "") {
@@ skipping 575 matching lines @@
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format, color_space1);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id1, data1, size);
 
   ResourceId id2 = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
       gfx::ColorSpace());
   uint8_t data2[4] = { 5, 5, 5, 5 };
   child_resource_provider_->CopyToResource(id2, data2, size);
 
-  ResourceId id3 = child_resource_provider_->CreateResource(
+  ResourceId id3 = child_resource_provider_->CreateGpuMemoryBufferResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
-      gfx::ColorSpace());
+      gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gfx::ColorSpace());
   {
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
         child_resource_provider_.get(), id3);
     EXPECT_TRUE(lock.GetGpuMemoryBuffer());
   }
 
   GLuint external_texture_id = child_context_->createExternalTexture();
 
   gpu::Mailbox external_mailbox;
   child_context_->genMailboxCHROMIUM(external_mailbox.name);
@@ skipping 352 matching lines @@
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id1 = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
       gfx::ColorSpace());
   uint8_t data1[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id1, data1, size);
 
-  ResourceId id2 = child_resource_provider_->CreateResource(
+  ResourceId id2 = child_resource_provider_->CreateGpuMemoryBufferResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
-      gfx::ColorSpace());
+      gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gfx::ColorSpace());
   {
     // Ensure locking the memory buffer doesn't create an unnecessary sync
     // point.
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
         child_resource_provider_.get(), id2);
     EXPECT_TRUE(lock.GetGpuMemoryBuffer());
   }
 
   GLuint external_texture_id = child_context_->createExternalTexture();
 
@@ skipping 2351 matching lines @@
   Mock::VerifyAndClearExpectations(context);
 
   {
     // WaitSyncTokenIfNeeded with empty sync_token shouldn't call waitSyncToken.
     EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
     resource_provider->WaitSyncTokenIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
   }
 }
 
-class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
+class AllocationTrackingContext3D : public TextureStateTrackingContext {
  public:
   MOCK_METHOD0(NextTextureId, GLuint());
   MOCK_METHOD1(RetireTextureId, void(GLuint id));
-  MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
   MOCK_METHOD5(texStorage2DEXT,
                void(GLenum target,
                     GLint levels,
                     GLuint internalformat,
                     GLint width,
                     GLint height));
   MOCK_METHOD9(texImage2D,
                void(GLenum target,
                     GLint level,
                     GLenum internalformat,
@@ skipping 45 matching lines @@
   MOCK_METHOD1(waitAsyncTexImage2DCHROMIUM, void(GLenum));
   MOCK_METHOD4(createImageCHROMIUM,
                GLuint(ClientBuffer, GLsizei, GLsizei, GLenum));
   MOCK_METHOD1(destroyImageCHROMIUM, void(GLuint));
   MOCK_METHOD2(bindTexImage2DCHROMIUM, void(GLenum, GLint));
   MOCK_METHOD2(releaseTexImage2DCHROMIUM, void(GLenum, GLint));
 
   // We're mocking bindTexture, so we override
   // TestWebGraphicsContext3D::texParameteri to avoid assertions related to the
   // currently bound texture.
-  virtual void texParameteri(GLenum target, GLenum pname, GLint param) {}
+  void texParameteri(GLenum target, GLenum pname, GLint param) override {}
 };
 
 TEST_P(ResourceProviderTest, TextureAllocation) {
   // Only for GL textures.
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
   std::unique_ptr<AllocationTrackingContext3D> context_owned(
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
@@ skipping 156 matching lines @@
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
   std::unique_ptr<AllocationTrackingContext3D> context_owned(
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   const int kWidth = 2;
   const int kHeight = 2;
-  gfx::Size size(kWidth, kHeight);
-  ResourceFormat format = RGBA_8888;
-  ResourceId id = 0;
+  const ResourceFormat format = RGBA_8888;
   const unsigned kTextureId = 123u;
   const unsigned kImageId = 234u;
 
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
           CreateResourceSettings()));
 
-  id = resource_provider->CreateResource(
-      size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format,
-      gfx::ColorSpace());
+  ResourceId id = resource_provider->CreateGpuMemoryBufferResource(
+      gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gfx::ColorSpace());
 
-  EXPECT_CALL(*context, NextTextureId())
-      .WillOnce(Return(kTextureId))
-      .RetiresOnSaturation();
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId))
-      .Times(3)
-      .RetiresOnSaturation();
+  InSequence sequence;
+
+  // Image is created in the lock's dtor.
+  EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(kTextureId));
+  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId));
   EXPECT_CALL(*context, createImageCHROMIUM(_, kWidth, kHeight, GL_RGBA))
-      .WillOnce(Return(kImageId))
-      .RetiresOnSaturation();
+      .WillOnce(Return(kImageId));
   {
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
         resource_provider.get(), id);
     EXPECT_TRUE(lock.GetGpuMemoryBuffer());
   }
 
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
-      .Times(1)
-      .RetiresOnSaturation();
   {
-    ResourceProvider::ScopedSamplerGL lock_gl(
-        resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(2);
+    EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId));
+    ResourceProvider::ScopedSamplerGL lock_gl(resource_provider.get(), id,
+                                              GL_TEXTURE_2D, GL_LINEAR);
     EXPECT_EQ(kTextureId, lock_gl.texture_id());
   }
 
   {
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
         resource_provider.get(), id);
     EXPECT_TRUE(lock.GetGpuMemoryBuffer());
   }
 
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*context, releaseTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
-      .Times(1)
-      .RetiresOnSaturation();
-  EXPECT_CALL(*context, RetireTextureId(kTextureId))
-      .Times(1)
-      .RetiresOnSaturation();
+  // Upload to GPU again since image is dirty after the write lock.
   {
-    ResourceProvider::ScopedSamplerGL lock_gl(
-        resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(2);
+    EXPECT_CALL(*context, releaseTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId));
+    EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId));
+    ResourceProvider::ScopedSamplerGL lock_gl(resource_provider.get(), id,
+                                              GL_TEXTURE_2D, GL_LINEAR);
     EXPECT_EQ(kTextureId, lock_gl.texture_id());
   }
 
-  EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId))
-      .Times(1)
-      .RetiresOnSaturation();
+  EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId));
+  EXPECT_CALL(*context, RetireTextureId(kTextureId));
 }
 
 TEST_P(ResourceProviderTest, CompressedTextureETC1Allocate) {
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
   std::unique_ptr<AllocationTrackingContext3D> context_owned(
       new AllocationTrackingContext3D);
   AllocationTrackingContext3D* context = context_owned.get();
   context_owned->set_support_compressed_texture_etc1(true);
   auto context_provider = TestContextProvider::Create(std::move(context_owned));
   context_provider->BindToCurrentThread();
 
   gfx::Size size(4, 4);
   std::unique_ptr<ResourceProvider> resource_provider(
       base::MakeUnique<ResourceProvider>(
           context_provider.get(), shared_bitmap_manager_.get(),
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
           CreateResourceSettings()));
   int texture_id = 123;
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1, gfx::ColorSpace());
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
+  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
   resource_provider->AllocateForTesting(id);
 
   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 }
 
 TEST_P(ResourceProviderTest, CompressedTextureETC1Upload) {
   if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
     return;
 
@@ skipping 11 matching lines @@
           gpu_memory_buffer_manager_.get(), nullptr,
           kDelegatedSyncPointsRequired, kEnableColorCorrectRendering,
           CreateResourceSettings()));
   int texture_id = 123;
   uint8_t pixels[8];
 
   ResourceId id = resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, ETC1, gfx::ColorSpace());
   EXPECT_NE(0u, id);
   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
-  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
+  EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
   EXPECT_CALL(*context,
               compressedTexImage2D(
                   _, 0, _, size.width(), size.height(), _, _, _)).Times(1);
   resource_provider->CopyToResource(id, pixels, size);
 
   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
   resource_provider->DeleteResource(id);
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ skipping 86 matching lines @@
     token.Set(gpu::CommandBufferNamespace::INVALID, 0, gpu::CommandBufferId(),
               release_counts[i]);
     lock.set_sync_token(token);
   }
 
   gpu::SyncToken last_token =
       resource_provider_->GetSyncTokenForResources(array);
   EXPECT_EQ(last_token.release_count(), 10u);
 }
 
+TEST_P(ResourceProviderTest, ScopedWriteLockGL) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+  std::unique_ptr<AllocationTrackingContext3D> context_owned(
+      new StrictMock<AllocationTrackingContext3D>);
+  AllocationTrackingContext3D* context = context_owned.get();
+  auto context_provider = TestContextProvider::Create(std::move(context_owned));
+  context_provider->BindToCurrentThread();
+
+  const int kWidth = 2;
+  const int kHeight = 2;
+  const ResourceFormat format = RGBA_8888;
+  const unsigned kTextureId = 123u;
+
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          context_provider.get(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kEnableColorCorrectRendering,
+          DefaultBufferToTextureTargetMapForTesting()));
+
+  ResourceId id = resource_provider->CreateResource(
+      gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      format, gfx::ColorSpace());
+
+  InSequence sequence;
+
+  // First use will allocate lazily on creation of lock.
+  {
+    EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(kTextureId));
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(2);
+    EXPECT_CALL(*context, texImage2D(GL_TEXTURE_2D, 0, GLInternalFormat(format),
+                                     kWidth, kHeight, 0, GLDataFormat(format),
+                                     GLDataType(format), nullptr));
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id,
+                                             false);
+  }
+
+  // Subsequent uses will not allocate.
+  {
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id,
+                                             false);
+  }
+
+  EXPECT_CALL(*context, RetireTextureId(kTextureId));
+  resource_provider->DeleteResource(id);
+}
+
+TEST_P(ResourceProviderTest, ScopedWriteLockGL_GpuMemoryBuffer) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+  std::unique_ptr<AllocationTrackingContext3D> context_owned(
+      new StrictMock<AllocationTrackingContext3D>);
+  AllocationTrackingContext3D* context = context_owned.get();
+  auto context_provider = TestContextProvider::Create(std::move(context_owned));
+  context_provider->BindToCurrentThread();
+
+  const int kWidth = 2;
+  const int kHeight = 2;
+  const ResourceFormat format = RGBA_8888;
+  const unsigned kTextureId = 123u;
+  const unsigned kImageId = 234u;
+
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          context_provider.get(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kEnableColorCorrectRendering,
+          DefaultBufferToTextureTargetMapForTesting()));
+
+  ResourceId id = resource_provider->CreateGpuMemoryBufferResource(
+      gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gfx::ColorSpace());
+
+  InSequence sequence;
+
+  // First use will allocate lazily on creation of lock.
+  {
+    EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(kTextureId));
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId));
+    EXPECT_CALL(*context, createImageCHROMIUM(_, kWidth, kHeight,
+                                              GLInternalFormat(format)))
+        .WillOnce(Return(kImageId));
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId));
+    EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId));
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id,
+                                             false);
+  }
+
+  // Subsequent uses will not allocate.
+  {
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id,
+                                             false);
+  }
+
+  EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId));
+  EXPECT_CALL(*context, RetireTextureId(kTextureId));
+  resource_provider->DeleteResource(id);
+}
+
+TEST_P(ResourceProviderTest, ScopedWriteLockGL_AsyncWorkerContext) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+  std::unique_ptr<AllocationTrackingContext3D> context_owned(
+      new StrictMock<AllocationTrackingContext3D>);
+  AllocationTrackingContext3D* context = context_owned.get();
+  auto context_provider = TestContextProvider::Create(std::move(context_owned));
+  context_provider->BindToCurrentThread();
+
+  const int kWidth = 2;
+  const int kHeight = 2;
+  const ResourceFormat format = RGBA_8888;
+  const unsigned kTextureId = 123u;
+  const unsigned kWorkerTextureId = 234u;
+
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          context_provider.get(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kEnableColorCorrectRendering,
+          DefaultBufferToTextureTargetMapForTesting()));
+
+  ResourceId id = resource_provider->CreateResource(
+      gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      format, gfx::ColorSpace());
+
+  gpu::SyncToken sync_token;
+  context->genSyncToken(context->insertFenceSync(), sync_token.GetData());
+
+  InSequence sequence;
+
+  // First use will create mailbox when lock is created and allocate lazily in
+  // ConsumeTexture.
+  {
+    EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(kTextureId));
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId));
+    EXPECT_CALL(*context,
+                produceTextureDirectCHROMIUM(kTextureId, GL_TEXTURE_2D, _));
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id, true);
+
+    EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _))
+        .WillOnce(Return(kWorkerTextureId));
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kWorkerTextureId));
+    EXPECT_CALL(*context, texImage2D(GL_TEXTURE_2D, 0, GLInternalFormat(format),
+                                     kWidth, kHeight, 0, GLDataFormat(format),
+                                     GLDataType(format), nullptr));
+    EXPECT_EQ(kWorkerTextureId,
+              lock.ConsumeTexture(context_provider->ContextGL()));
+
+    EXPECT_CALL(*context, RetireTextureId(kWorkerTextureId));
+    context_provider->ContextGL()->DeleteTextures(1, &kWorkerTextureId);
+  }
+
+  // Subsequent uses will not create mailbox or allocate.
+  {
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id, true);
+
+    EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _))
+        .WillOnce(Return(kWorkerTextureId));
+    EXPECT_EQ(kWorkerTextureId,
+              lock.ConsumeTexture(context_provider->ContextGL()));
+
+    lock.set_sync_token(sync_token);
+
+    EXPECT_CALL(*context, RetireTextureId(kWorkerTextureId));
+    context_provider->ContextGL()->DeleteTextures(1, &kWorkerTextureId);
+  }
+
+  // Wait for worker context sync token before deleting texture.
+  EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
+  EXPECT_CALL(*context, RetireTextureId(kTextureId));
+  resource_provider->DeleteResource(id);
+}
+
+TEST_P(ResourceProviderTest,
+       ScopedWriteLockGL_GpuMemoryBuffer_AsyncWorkerContext) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+  std::unique_ptr<AllocationTrackingContext3D> context_owned(
+      new StrictMock<AllocationTrackingContext3D>);
+  AllocationTrackingContext3D* context = context_owned.get();
+  auto context_provider = TestContextProvider::Create(std::move(context_owned));
+  context_provider->BindToCurrentThread();
+
+  const int kWidth = 2;
+  const int kHeight = 2;
+  const ResourceFormat format = RGBA_8888;
+  const unsigned kTextureId = 123u;
+  const unsigned kWorkerTextureId = 234u;
+  const unsigned kImageId = 345u;
+
+  std::unique_ptr<ResourceProvider> resource_provider(
+      base::MakeUnique<ResourceProvider>(
+          context_provider.get(), shared_bitmap_manager_.get(),
+          gpu_memory_buffer_manager_.get(), nullptr, 1,
+          kDelegatedSyncPointsRequired, kUseGpuMemoryBufferResources,
+          kEnableColorCorrectRendering,
+          DefaultBufferToTextureTargetMapForTesting()));
+
+  ResourceId id = resource_provider->CreateGpuMemoryBufferResource(
+      gfx::Size(kWidth, kHeight), ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+      format, gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, gfx::ColorSpace());
+
+  gpu::SyncToken sync_token;
+  context->genSyncToken(context->insertFenceSync(), sync_token.GetData());
+
+  InSequence sequence;
+
+  // First use will create mailbox when lock is created and allocate lazily in
+  // ConsumeTexture.
+  {
+    EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(kTextureId));
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId));
+    EXPECT_CALL(*context,
+                produceTextureDirectCHROMIUM(kTextureId, GL_TEXTURE_2D, _));
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id, true);
+
+    EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _))
+        .WillOnce(Return(kWorkerTextureId));
+    EXPECT_CALL(*context, createImageCHROMIUM(_, kWidth, kHeight,
+                                              GLInternalFormat(format)))
+        .WillOnce(Return(kImageId));
+    EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kWorkerTextureId));
+    EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId));
+    EXPECT_EQ(kWorkerTextureId,
+              lock.ConsumeTexture(context_provider->ContextGL()));
+
+    EXPECT_CALL(*context, RetireTextureId(kWorkerTextureId));
+    context_provider->ContextGL()->DeleteTextures(1, &kWorkerTextureId);
+  }
+
+  // Subsequent uses will not create mailbox or allocate.
+  {
+    ResourceProvider::ScopedWriteLockGL lock(resource_provider.get(), id, true);
+
+    EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _))
+        .WillOnce(Return(kWorkerTextureId));
+    EXPECT_EQ(kWorkerTextureId,
+              lock.ConsumeTexture(context_provider->ContextGL()));
+
+    lock.set_sync_token(sync_token);
+
+    EXPECT_CALL(*context, RetireTextureId(kWorkerTextureId));
+    context_provider->ContextGL()->DeleteTextures(1, &kWorkerTextureId);
+  }
+
+  // Wait for worker context sync token before deleting texture.
+  EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
+  EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId));
+  EXPECT_CALL(*context, RetireTextureId(kTextureId));
+  resource_provider->DeleteResource(id);
+}
+
 }  // namespace
 }  // namespace cc