cc: Add ScopedReadLockGpuMemoryBuffer

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 438 matching lines @@
             base::WrapUnique(new SoftwareOutputDevice));
         child_output_surface_ = FakeOutputSurface::CreateSoftware(
             base::WrapUnique(new SoftwareOutputDevice));
         break;
     }
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     CHECK(child_output_surface_->BindToClient(&child_output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
     gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
+    child_gpu_memory_buffer_manager_ =
+        gpu_memory_buffer_manager_->CreateClientGpuMemoryBufferManager();
 
     resource_provider_ = ResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1,
         use_gpu_memory_buffer_resources_, use_image_texture_targets_);
     child_resource_provider_ = ResourceProvider::Create(
         child_output_surface_.get(), shared_bitmap_manager_.get(),
-        gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(), 0, 1,
-        use_gpu_memory_buffer_resources_, use_image_texture_targets_);
+        child_gpu_memory_buffer_manager_.get(), main_thread_task_runner_.get(),
+        0, 1, use_gpu_memory_buffer_resources_, use_image_texture_targets_);
   }
 
   ResourceProviderTest() : ResourceProviderTest(true) {}
 
   static void CollectResources(ReturnedResourceArray* array,
                                const ReturnedResourceArray& returned,
                                BlockingTaskRunner* main_thread_task_runner) {
     array->insert(array->end(), returned.begin(), returned.end());
   }
 
@@ skipping 59 matching lines @@
   static bool use_gpu_memory_buffer_resources_;
   static std::vector<unsigned> use_image_texture_targets_;
   std::unique_ptr<ContextSharedData> shared_data_;
   ResourceProviderContext* context3d_;
   ResourceProviderContext* child_context_;
   FakeOutputSurfaceClient output_surface_client_;
   FakeOutputSurfaceClient child_output_surface_client_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<OutputSurface> child_output_surface_;
   std::unique_ptr<BlockingTaskRunner> main_thread_task_runner_;
+  std::unique_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
+  std::unique_ptr<TestGpuMemoryBufferManager> child_gpu_memory_buffer_manager_;
   std::unique_ptr<ResourceProvider> child_resource_provider_;
   std::unique_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
-  std::unique_ptr<TestGpuMemoryBufferManager> gpu_memory_buffer_manager_;
 };
 
 bool ResourceProviderTest::use_gpu_memory_buffer_resources_ = false;
 
 std::vector<unsigned> ResourceProviderTest::use_image_texture_targets_ =
     std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
                           GL_TEXTURE_2D);
 
 void CheckCreateResource(ResourceProvider::ResourceType expected_default_type,
                          ResourceProvider* resource_provider,
@@ skipping 97 matching lines @@
   gpu::SyncToken external_sync_token;
   child_context_->genSyncToken(child_context_->insertFenceSync(),
                                external_sync_token.GetData());
   EXPECT_TRUE(external_sync_token.HasData());
   ResourceId id4 = child_resource_provider_->CreateResourceFromTextureMailbox(
       TextureMailbox(external_mailbox, external_sync_token,
                      GL_TEXTURE_EXTERNAL_OES),
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
+
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     resource_ids_to_transfer.push_back(id3);
     resource_ids_to_transfer.push_back(id4);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
@@ skipping 241 matching lines @@
   gpu::SyncToken external_sync_token;
   child_context_->genSyncToken(child_context_->insertFenceSync(),
                                external_sync_token.GetData());
   EXPECT_TRUE(external_sync_token.HasData());
   ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox(
       TextureMailbox(external_mailbox, external_sync_token,
                      GL_TEXTURE_EXTERNAL_OES),
       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   resource_provider_->SetChildNeedsSyncTokens(child_id, false);
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     resource_ids_to_transfer.push_back(id3);
     TransferableResourceArray list;
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
@@ skipping 57 matching lines @@
     return;
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   ResourceId id1 = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id1, data1, size);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
 
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 47 matching lines @@
     return;
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
 
   ResourceId id1 = child_resource_provider_->CreateResource(
       size, 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));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
 
   // Transfer some resources to the parent.
   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
   resource_ids_to_transfer.push_back(id1);
 
   child_resource_provider_->GenerateSyncTokenForResources(
       resource_ids_to_transfer);
 
   TransferableResourceArray list;
   child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 40 matching lines @@
       size, 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, 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));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
 
   // 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);
 
   child_resource_provider_->GenerateSyncTokenForResources(
       resource_ids_to_transfer);
 
   TransferableResourceArray list;
@@ skipping 44 matching lines @@
       size, 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, 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));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
 
   // 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);
 
   child_resource_provider_->GenerateSyncTokenForResources(
       resource_ids_to_transfer);
 
   TransferableResourceArray list;
@@ skipping 48 matching lines @@
 
   std::unique_ptr<SharedBitmap> shared_bitmap(CreateAndFillSharedBitmap(
       shared_bitmap_manager_.get(), gfx::Size(1, 1), 0));
   SharedBitmap* shared_bitmap_ptr = shared_bitmap.get();
   ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox(
       TextureMailbox(shared_bitmap_ptr, gfx::Size(1, 1)),
       SingleReleaseCallbackImpl::Create(base::Bind(
           &SharedBitmapReleaseCallback, base::Passed(&shared_bitmap))));
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
     resource_ids_to_transfer.push_back(id3);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
 
@@ skipping 183 matching lines @@
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id1 = child_resource_provider->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider->CopyToResource(id1, data1, size);
   child_resource_provider->GenerateSyncTokenForResource(id1);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     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(list[0].mailbox_holder.sync_token.HasData());
     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
@@ skipping 25 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);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id1, data1, size);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
 
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
@@ skipping 34 matching lines @@
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   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);
   uint8_t data2[4] = {5, 5, 5, 5};
   child_resource_provider_->CopyToResource(id2, data2, size);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
 
     TransferableResourceArray list;
@@ skipping 82 matching lines @@
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   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);
   uint8_t data2[4] = {5, 5, 5, 5};
   child_resource_provider_->CopyToResource(id2, data2, size);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id1);
     resource_ids_to_transfer.push_back(id2);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
 
     TransferableResourceArray list;
@@ skipping 94 matching lines @@
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data[4] = { 1, 2, 3, 4 };
   child_resource_provider_->CopyToResource(id, data, size);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer some resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
 
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 33 matching lines @@
   ResourceFormat format = RGBA_8888;
   size_t pixel_size = TextureSizeBytes(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceId id = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   uint8_t data[4] = {1, 2, 3, 4};
   child_resource_provider_->CopyToResource(id, data, size);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   const ResourceProvider::ResourceIdMap& map =
       resource_provider_->GetChildToParentMap(child_id);
   {
     // Transfer some resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id);
 
     child_resource_provider_->GenerateSyncTokenForResources(
         resource_ids_to_transfer);
 
@@ skipping 166 matching lines @@
           texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, child_filter));
       EXPECT_CALL(
           *child_context,
           texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, child_filter));
     }
     SetResourceFilter(child_resource_provider.get(), id, child_filter);
     Mock::VerifyAndClearExpectations(child_context);
 
     ReturnedResourceArray returned_to_child;
     int child_id = parent_resource_provider->CreateChild(
-        GetReturnCallback(&returned_to_child));
+        GetReturnCallback(&returned_to_child), -1);
     {
       // Transfer some resource to the parent.
       ResourceProvider::ResourceIdArray resource_ids_to_transfer;
       resource_ids_to_transfer.push_back(id);
       TransferableResourceArray list;
 
       EXPECT_CALL(*child_context,
                   produceTextureDirectCHROMIUM(_, GL_TEXTURE_2D, _));
 
       child_resource_provider->GenerateSyncTokenForResources(
@@ skipping 223 matching lines @@
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   ResourceId resource = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   child_resource_provider_->AllocateForTesting(resource);
   // Expect a GL resource to be lost.
   bool should_lose_resource =
       GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE;
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     EXPECT_EQ(1u, list.size());
 
     resource_provider_->ReceiveFromChild(child_id, list);
@@ skipping 30 matching lines @@
 }
 
 TEST_P(ResourceProviderTest, LostResourceInGrandParent) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   ResourceId resource = child_resource_provider_->CreateResource(
       size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   child_resource_provider_->AllocateForTesting(resource);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     EXPECT_EQ(1u, list.size());
 
     resource_provider_->ReceiveFromChild(child_id, list);
@@ skipping 56 matching lines @@
 
 TEST_P(ResourceProviderTest, LostMailboxInParent) {
   gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   bool release_called = false;
   gpu::SyncToken sync_token;
   ResourceId resource = CreateChildMailbox(&release_sync_token, &lost_resource,
                                            &release_called, &sync_token);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     EXPECT_EQ(1u, list.size());
 
     resource_provider_->ReceiveFromChild(child_id, list);
@@ skipping 31 matching lines @@
 
 TEST_P(ResourceProviderTest, LostMailboxInGrandParent) {
   gpu::SyncToken release_sync_token;
   bool lost_resource = false;
   bool release_called = false;
   gpu::SyncToken sync_token;
   ResourceId resource = CreateChildMailbox(&release_sync_token, &lost_resource,
                                            &release_called, &sync_token);
 
   ReturnedResourceArray returned_to_child;
-  int child_id =
-      resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
   {
     // Transfer the resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     EXPECT_EQ(1u, list.size());
 
     resource_provider_->ReceiveFromChild(child_id, list);
@@ skipping 1201 matching lines @@
     EXPECT_TRUE(lock.GetGpuMemoryBuffer());
   }
   EXPECT_TRUE(resource_provider_->CanLockForWrite(id));
   EXPECT_FALSE(resource_provider_->InUseByConsumer(id));
   gpu_memory_buffer_manager_->SetGpuMemoryBufferIsInUseByMacOSWindowServer(
       gpu_memory_buffer, true);
   EXPECT_FALSE(resource_provider_->CanLockForWrite(id));
   EXPECT_TRUE(resource_provider_->InUseByConsumer(id));
 }
 
+TEST_P(ResourceProviderTest, GpuMemoryBufferReadLockFail) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+
+  gfx::Size size(1, 1);
+  ResourceFormat format = RGBA_8888;
+  size_t pixel_size = TextureSizeBytes(size, format);
+  ASSERT_EQ(4U, pixel_size);
+
+  ResourceId id = resource_provider_->CreateResource(
+      size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  resource_provider_->AllocateForTesting(id);
+  {
+    ResourceProvider::ScopedReadLockGpuMemoryBuffer lock(
+        resource_provider_.get(), id);
+    EXPECT_FALSE(lock.GetGpuMemoryBuffer());
+  }
+}
+
+TEST_P(ResourceProviderTest, GpuMemoryBufferReadLockSucceed) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+
+  gfx::Size size(1, 1);
+  ResourceFormat format = RGBA_8888;
+  size_t pixel_size = TextureSizeBytes(size, format);
+  ASSERT_EQ(4U, pixel_size);
+
+  ResourceId id = resource_provider_->CreateResource(
+      size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  gfx::GpuMemoryBuffer* gpu_memory_buffer = nullptr;
+  {
+    ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
+        resource_provider_.get(), id);
+    gpu_memory_buffer = lock.GetGpuMemoryBuffer();
+    EXPECT_TRUE(lock.GetGpuMemoryBuffer());
+  }
+  {
+    ResourceProvider::ScopedReadLockGpuMemoryBuffer lock(
+        resource_provider_.get(), id);
+    EXPECT_EQ(gpu_memory_buffer, lock.GetGpuMemoryBuffer());
+  }
+}
+
+TEST_P(ResourceProviderTest, ChildGpuMemoryBufferReadLock) {
+  if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
+    return;
+
+  gfx::Size size(1, 1);
+  ResourceFormat format = RGBA_8888;
+  size_t pixel_size = TextureSizeBytes(size, format);
+  ASSERT_EQ(4U, pixel_size);
+
+  // Create the child resource provider.
+  ReturnedResourceArray returned_to_child;
+  int child_id = resource_provider_->CreateChild(
+      GetReturnCallback(&returned_to_child),
+      child_gpu_memory_buffer_manager_->GetClientId());
+
+  // Create a non-GMB-backed resource.
+  ResourceId child_resource = child_resource_provider_->CreateResource(
+      size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  {
+    uint8_t data1[4] = {1, 2, 3, 4};
+    child_resource_provider_->CopyToResource(child_resource, data1, size);
+  }
+
+  // Create a GMB-backed resource.
+  ResourceId child_gmb_resource = child_resource_provider_->CreateResource(
+      size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
+  gfx::GpuMemoryBuffer* child_gmb = nullptr;
+  {
+    ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
+        child_resource_provider_.get(), child_gmb_resource);
+    EXPECT_TRUE(lock.GetGpuMemoryBuffer());
+    child_gmb = lock.GetGpuMemoryBuffer();
+  }
+
+  // Transfer to the parent.
+  TransferableResourceArray list;
+  {
+    ResourceProvider::ResourceIdArray resource_ids_to_transfer;
+    resource_ids_to_transfer.push_back(child_resource);
+    resource_ids_to_transfer.push_back(child_gmb_resource);
+    child_resource_provider_->GenerateSyncTokenForResources(
+        resource_ids_to_transfer);
+    child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
+                                                  &list);
+    resource_provider_->ReceiveFromChild(child_id, list);
+    resource_provider_->WaitSyncTokenIfNeeded(list[0].id);
+    resource_provider_->WaitSyncTokenIfNeeded(list[1].id);
+  }
+
+  // The non-gmb resource should not have a GpuMemoryBuffer when locked.
+  {
+    ResourceProvider::ScopedReadLockGpuMemoryBuffer lock(
+        resource_provider_.get(), list[0].id);
+    EXPECT_FALSE(lock.GetGpuMemoryBuffer());
+  }
+
+  // The gmb resource should have a GpuMemoryBuffer when locked
+  {
+    ResourceProvider::ScopedReadLockGpuMemoryBuffer lock(
+        resource_provider_.get(), list[1].id);
+    gfx::GpuMemoryBuffer* parent_gmb = lock.GetGpuMemoryBuffer();
+    EXPECT_TRUE(parent_gmb);
+    EXPECT_NE(child_gmb, parent_gmb);
+
+    // Verify that the IsInUseByMacOSWindowServer signal is shared between
+    // parent and child.
+    EXPECT_FALSE(parent_gmb->IsInUseByMacOSWindowServer());
+    child_gpu_memory_buffer_manager_
+        ->SetGpuMemoryBufferIsInUseByMacOSWindowServer(child_gmb, true);
+    EXPECT_TRUE(parent_gmb->IsInUseByMacOSWindowServer());
+    child_gpu_memory_buffer_manager_
+        ->SetGpuMemoryBufferIsInUseByMacOSWindowServer(child_gmb, false);
+    EXPECT_FALSE(parent_gmb->IsInUseByMacOSWindowServer());
+  }
+
+  // Transfer back to the child.{
+  {
+    ResourceProvider::ResourceIdSet resource_ids_to_receive;
+    resource_ids_to_receive.insert(child_resource);
+    resource_ids_to_receive.insert(child_gmb_resource);
+    resource_provider_->DeclareUsedResourcesFromChild(child_id,
+                                                      resource_ids_to_receive);
+  }
+  resource_provider_->DestroyChild(child_id);
+
+  EXPECT_EQ(0u, resource_provider_->num_resources());
+}
+
 }  // namespace
 }  // namespace cc