cc: Make ResourceProvider use bindless Produce/ConsumeTextureCHROMIUM

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 78 matching lines @@
   std::fill_n(pixels, size.GetArea(), value);
   return shared_memory.Pass();
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
   MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param));
   MOCK_METHOD1(waitSyncPoint, void(GLuint sync_point));
   MOCK_METHOD0(insertSyncPoint, GLuint(void));
-  MOCK_METHOD2(produceTextureCHROMIUM,
-               void(GLenum target, const GLbyte* mailbox));
-  MOCK_METHOD2(consumeTextureCHROMIUM,
-               void(GLenum target, const GLbyte* mailbox));
+  MOCK_METHOD3(produceTextureDirectCHROMIUM,
+               void(GLuint texture, GLenum target, const GLbyte* mailbox));
+  MOCK_METHOD2(createAndConsumeTextureCHROMIUM,
+               GLuint(GLenum target, const GLbyte* mailbox));
 
   // Force all textures to be consecutive numbers starting at "1",
   // so we easily can test for them.
   virtual GLuint NextTextureId() override {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id++;
   }
   virtual void RetireTextureId(GLuint) override {}
 };
 
@@ skipping 137 matching lines @@
       ASSERT_EQ(GLDataFormat(BoundTexture(target)->format), format);
     }
     ASSERT_TRUE(pixels);
     SetPixels(xoffset, yoffset, width, height, pixels);
   }
 
   void genMailboxCHROMIUM(GLbyte* mailbox) override {
     return shared_data_->GenMailbox(mailbox);
   }
 
-  void produceTextureCHROMIUM(GLenum target, const GLbyte* mailbox) override {
-    CheckTextureIsBound(target);
-
+  virtual void produceTextureDirectCHROMIUM(GLuint texture,
+                                            GLenum target,
+                                            const GLbyte* mailbox) override {
     // Delay moving the texture into the mailbox until the next
     // InsertSyncPoint, so that it is not visible to other contexts that
     // haven't waited on that sync point.
     scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
     memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
     base::AutoLock lock_for_texture_access(namespace_->lock);
-    pending->texture = BoundTexture(target);
+    pending->texture = UnboundTexture(texture);
     pending_produce_textures_.push_back(pending.Pass());
   }
 
-  void consumeTextureCHROMIUM(GLenum target, const GLbyte* mailbox) override {
-    CheckTextureIsBound(target);
+  virtual GLuint createAndConsumeTextureCHROMIUM(GLenum target,
+                                                 const GLbyte* mailbox) {
+    GLuint texture_id =
+        TestWebGraphicsContext3D::createAndConsumeTextureCHROMIUM(target,
+                                                                  mailbox);
     base::AutoLock lock_for_texture_access(namespace_->lock);
-    scoped_refptr<TestTexture> texture =
-        shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_);
-    namespace_->textures.Replace(BoundTextureId(target), texture);
+    namespace_->textures.Replace(texture_id, UnboundTexture(texture_id));

[danakj, 2014/12/01 16:20:04]

We still need to do what ConsumeTexture was doing.

[sohanjg, 2014/12/30 14:45:54]

Done.

+    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);
     ASSERT_EQ(texture->size, size);
     ASSERT_EQ(texture->format, format);
@@ skipping 39 matching lines @@
     uint8_t* dest = texture->data.get() + yoffset * out_pitch +
                     TextureSizeBytes(gfx::Size(xoffset, 1), texture->format);
     const uint8_t* src = static_cast<const uint8_t*>(pixels);
     for (int i = 0; i < height; ++i) {
       memcpy(dest, src, in_pitch);
       dest += out_pitch;
       src += in_pitch;
     }
   }
 
+  void SetPixelsEXT(int xoffset,

[danakj, 2014/12/01 16:20:05]

Nothing uses this

[sohanjg, 2014/12/30 14:45:55]

Done.

+                    int yoffset,
+                    int width,
+                    int height,
+                    const void* pixels,
+                    GLuint id) {
+    base::AutoLock lock_for_texture_access(namespace_->lock);
+    scoped_refptr<TestTexture> texture = UnboundTexture(id);
+    ASSERT_TRUE(texture->data.get());
+    ASSERT_TRUE(xoffset >= 0 && xoffset + width <= texture->size.width());
+    ASSERT_TRUE(yoffset >= 0 && yoffset + height <= texture->size.height());
+    ASSERT_TRUE(pixels);
+    size_t in_pitch = TextureSizeBytes(gfx::Size(width, 1), texture->format);
+    size_t out_pitch =
+        TextureSizeBytes(gfx::Size(texture->size.width(), 1), texture->format);
+    uint8_t* dest = texture->data.get() + yoffset * out_pitch +
+                    TextureSizeBytes(gfx::Size(xoffset, 1), texture->format);
+    const uint8_t* src = static_cast<const uint8_t*>(pixels);
+    for (int i = 0; i < height; ++i) {
+      memcpy(dest, src, in_pitch);
+      dest += out_pitch;
+      src += in_pitch;
+    }
+  }
+
   struct PendingProduceTexture {
     GLbyte mailbox[GL_MAILBOX_SIZE_CHROMIUM];
     scoped_refptr<TestTexture> texture;
   };
   typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
   ContextSharedData* shared_data_;
   GLuint last_waited_sync_point_;
   PendingProduceTextureList pending_produce_textures_;
 };
 
@@ skipping 105 matching lines @@
 
   ResourceProviderContext* context() { return context3d_; }
 
   ResourceProvider::ResourceId CreateChildMailbox(uint32* release_sync_point,
                                                   bool* lost_resource,
                                                   bool* release_called,
                                                   uint32* sync_point) {
     if (GetParam() == ResourceProvider::GLTexture) {
       unsigned texture = child_context_->createTexture();
       gpu::Mailbox gpu_mailbox;
-      child_context_->bindTexture(GL_TEXTURE_2D, texture);
       child_context_->genMailboxCHROMIUM(gpu_mailbox.name);
-      child_context_->produceTextureCHROMIUM(GL_TEXTURE_2D, gpu_mailbox.name);
+      child_context_->produceTextureDirectCHROMIUM(
+          texture, GL_TEXTURE_2D, gpu_mailbox.name);
       *sync_point = child_context_->insertSyncPoint();
       EXPECT_LT(0u, *sync_point);
 
       scoped_ptr<base::SharedMemory> shared_memory;
       scoped_ptr<SingleReleaseCallbackImpl> callback =
           SingleReleaseCallbackImpl::Create(
               base::Bind(ReleaseSharedMemoryCallback,
                          base::Passed(&shared_memory),
                          release_called,
                          release_sync_point,
@@ skipping 158 matching lines @@
 
   ResourceProvider::ResourceId id3 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
   {
     ResourceProvider::ScopedWriteLockGpuMemoryBuffer lock(
         child_resource_provider_.get(), id3);
     EXPECT_TRUE(!!lock.GetGpuMemoryBuffer());
   }
 
   GLuint external_texture_id = child_context_->createExternalTexture();
-  child_context_->bindTexture(GL_TEXTURE_EXTERNAL_OES, external_texture_id);
 
   gpu::Mailbox external_mailbox;
   child_context_->genMailboxCHROMIUM(external_mailbox.name);
-  child_context_->produceTextureCHROMIUM(GL_TEXTURE_EXTERNAL_OES,
-                                         external_mailbox.name);
+  child_context_->produceTextureDirectCHROMIUM(
+      external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name);
   const GLuint external_sync_point = child_context_->insertSyncPoint();
   ResourceProvider::ResourceId id4 =
       child_resource_provider_->CreateResourceFromTextureMailbox(
           TextureMailbox(
               external_mailbox, GL_TEXTURE_EXTERNAL_OES, external_sync_point),
           SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 
   ReturnedResourceArray returned_to_child;
   int child_id =
       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
@@ skipping 52 matching lines @@
   EXPECT_NE(0u, mapped_id1);
   EXPECT_NE(0u, mapped_id2);
   EXPECT_NE(0u, mapped_id3);
   EXPECT_NE(0u, mapped_id4);
   EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
   EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
   EXPECT_FALSE(resource_provider_->InUseByConsumer(id3));
   EXPECT_FALSE(resource_provider_->InUseByConsumer(id4));
 
   uint8_t result[4] = { 0 };
-  GetResourcePixels(

[danakj, 2014/12/01 16:20:05]

We should not remove test expectations

[sohanjg, 2014/12/30 14:45:55]

Done.

-      resource_provider_.get(), context(), mapped_id1, size, format, result);
-  EXPECT_EQ(0, memcmp(data1, result, pixel_size));
-
-  GetResourcePixels(
-      resource_provider_.get(), context(), mapped_id2, size, format, result);
-  EXPECT_EQ(0, memcmp(data2, result, pixel_size));
 
   {
     // Check that transfering again the same resource from the child to the
     // parent works.
     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_->PrepareSendToParent(resource_ids_to_transfer,
@@ skipping 143 matching lines @@
     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
                                                   &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
 
     resource_provider_->ReceiveFromChild(child_id, list);
 
     resource_provider_->WaitSyncPointIfNeeded(list[0].id);
     ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
                                             list[0].id);
-
     resource_provider_->DeclareUsedResourcesFromChild(
         child_id, ResourceProvider::ResourceIdArray());
     EXPECT_EQ(0u, returned_to_child.size());
   }
 
   EXPECT_EQ(1u, returned_to_child.size());
   child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
 
   {
     child_resource_provider_->WaitSyncPointIfNeeded(id1);
@@ skipping 818 matching lines @@
 
     ReturnedResourceArray returned_to_child;
     int child_id = parent_resource_provider->CreateChild(
         GetReturnCallback(&returned_to_child));
     {
       // 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, bindTexture(GL_TEXTURE_2D, child_texture_id));
       EXPECT_CALL(*child_context,
-                  produceTextureCHROMIUM(GL_TEXTURE_2D, _));
+                  produceTextureDirectCHROMIUM(_, GL_TEXTURE_2D, _));
       EXPECT_CALL(*child_context, insertSyncPoint());
       child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
                                                    &list);
       Mock::VerifyAndClearExpectations(child_context);
 
       ASSERT_EQ(1u, list.size());
       EXPECT_EQ(static_cast<unsigned>(child_filter), list[0].filter);
 
       EXPECT_CALL(*parent_context,
-                  bindTexture(GL_TEXTURE_2D, parent_texture_id));
-      EXPECT_CALL(*parent_context, consumeTextureCHROMIUM(GL_TEXTURE_2D, _));
+                  createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _)).Times(0);
       parent_resource_provider->ReceiveFromChild(child_id, list);
       {
         parent_resource_provider->WaitSyncPointIfNeeded(list[0].id);
         ResourceProvider::ScopedReadLockGL lock(parent_resource_provider.get(),
                                                 list[0].id);
       }
       Mock::VerifyAndClearExpectations(parent_context);
 
       parent_resource_provider->DeclareUsedResourcesFromChild(
           child_id, resource_ids_to_transfer);
@@ skipping 63 matching lines @@
   // Other mailbox transfers tested elsewhere.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   uint8_t data[4] = { 1, 2, 3, 4 };
   context()->texImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
-  context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+  context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
   uint32 sync_point = context()->insertSyncPoint();
 
   // All the logic below assumes that the sync points are all positive.
   EXPECT_LT(0u, sync_point);
 
   uint32 release_sync_point = 0;
   bool lost_resource = false;
   BlockingTaskRunner* main_thread_task_runner = NULL;
   ReleaseCallbackImpl callback = base::Bind(ReleaseCallback,
                                             &release_sync_point,
@@ skipping 13 matching lines @@
     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);
-    unsigned other_texture = context()->createTexture();
-    context()->bindTexture(GL_TEXTURE_2D, other_texture);
-    context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
-    uint8_t test_data[4] = { 0 };
-    context()->GetPixels(

[danakj, 2014/12/01 16:20:04]

We should not remove test expectations.

[sohanjg, 2014/12/30 14:45:54]

Done.

-        gfx::Size(1, 1), RGBA_8888, test_data);
-    EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
-    context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+    unsigned other_texture =
+        context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+
+    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);
 
     // Receive the resource, then delete it, expect the sync points to be
     // consistent.
     ReturnedResourceArray returned;
     TransferableResource::ReturnResources(list, &returned);
     resource_provider_->ReceiveReturnsFromParent(returned);
     EXPECT_EQ(1u, context()->NumTextures());
@@ skipping 23 matching lines @@
     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);
-    unsigned other_texture = context()->createTexture();
-    context()->bindTexture(GL_TEXTURE_2D, other_texture);
-    context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
-    uint8_t test_data[4] = { 0 };
-    context()->GetPixels(

[danakj, 2014/12/01 16:20:05]

ditto...

[sohanjg, 2014/12/30 14:45:55]

Done.

-        gfx::Size(1, 1), RGBA_8888, test_data);
-    EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
-    context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+    unsigned other_texture =
+        context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+
+    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()->bindTexture(GL_TEXTURE_2D, texture);
-  context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+  texture =
+      context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   context()->deleteTexture(texture);
 }
 
 TEST_P(ResourceProviderTest, LostResourceInParent) {
   gfx::Size size(1, 1);
   ResourceFormat format = RGBA_8888;
   ResourceProvider::ResourceId resource =
       child_resource_provider_->CreateResource(
           size,
           GL_CLAMP_TO_EDGE,
@@ skipping 289 matching lines @@
 }
 
 TEST_P(ResourceProviderTest, LostContext) {
   // TextureMailbox callbacks only exist for GL textures for now.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
-  context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
+  context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
   uint32 sync_point = context()->insertSyncPoint();
 
   EXPECT_LT(0u, sync_point);
 
   uint32 release_sync_point = 0;
   bool lost_resource = false;
   BlockingTaskRunner* main_thread_task_runner = NULL;
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(ReleaseCallback,
                                                    &release_sync_point,
@@ skipping 356 matching lines @@
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(),
                                shared_bitmap_manager_.get(),
                                gpu_memory_buffer_manager_.get(),
                                main_thread_task_runner_.get(),
                                0,
                                false,
                                1));
 
-  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, insertSyncPoint()).Times(0);
-  EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
-  EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).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* main_thread_task_runner = NULL;
   scoped_ptr<SingleReleaseCallbackImpl> callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
                                                    &release_sync_point,
                                                    &lost_resource,
                                                    &main_thread_task_runner));
 
   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
 
   ResourceProvider::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));
     resource_provider->WaitSyncPointIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
 
     // Using the texture does a consume of the mailbox.
-    EXPECT_CALL(*context, bindTexture(target, texture_id));
-    EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
+    EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _)).Times(0);
 
     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
-    EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).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, produceTextureCHROMIUM(_, _)).Times(0);
+    EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
-    EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).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_.get(), main_thread_task_runner);
 }
 
 TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {
   // Mailboxing is only supported for GL textures.
@@ skipping 11 matching lines @@
 
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(),
                                shared_bitmap_manager_.get(),
                                gpu_memory_buffer_manager_.get(),
                                NULL,
                                0,
                                false,
                                1));
 
-  unsigned texture_id = 1;
   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, insertSyncPoint()).Times(0);
-  EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
-  EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).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);
 
   ResourceProvider::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));
     resource_provider->WaitSyncPointIfNeeded(id);
     Mock::VerifyAndClearExpectations(context);
 
     // Using the texture does a consume of the mailbox.
-    EXPECT_CALL(*context, bindTexture(target, texture_id));
-    EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
+    EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _)).Times(0);
 
     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
-    EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).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, produceTextureCHROMIUM(_, _)).Times(0);
+    EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
 
     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
-    EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
+    EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
   }
 }
 
 TEST_P(ResourceProviderTest,
        TextureMailbox_WaitSyncPointIfNeeded_WithSyncPoint) {
   // Mailboxing is only supported for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
 
   scoped_ptr<TextureStateTrackingContext> context_owned(
@@ skipping 13 matching lines @@
                                0,
                                false,
                                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, insertSyncPoint()).Times(0);
-  EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
-  EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).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);
 
   ResourceProvider::ResourceId id =
       resource_provider->CreateResourceFromTextureMailbox(mailbox,
@@ skipping 37 matching lines @@
                                0,
                                false,
                                1));
 
   uint32 sync_point = 0;
   unsigned target = GL_TEXTURE_2D;
 
   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
-  EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
-  EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).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);
 
   ResourceProvider::ResourceId id =
       resource_provider->CreateResourceFromTextureMailbox(mailbox,
@@ skipping 773 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc