cc: Use correct message loop proxy in BlockingTaskRunner

cc/layers/texture_layer_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/layers/texture_layer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 84 matching lines @@
 class MockMailboxCallback {
  public:
   MOCK_METHOD3(Release,
                void(const gpu::Mailbox& mailbox,
                     uint32 sync_point,
                     bool lost_resource));
   MOCK_METHOD3(Release2,
                void(base::SharedMemory* shared_memory,
                     uint32 sync_point,
                     bool lost_resource));
+  MOCK_METHOD4(ReleaseImpl,
+               void(const gpu::Mailbox& mailbox,
+                    uint32 sync_point,
+                    bool lost_resource,
+                    BlockingTaskRunner* main_thread_task_runner));
+  MOCK_METHOD4(ReleaseImpl2,
+               void(base::SharedMemory* shared_memory,
+                    uint32 sync_point,
+                    bool lost_resource,
+                    BlockingTaskRunner* main_thread_task_runner));
 };
 
 struct CommonMailboxObjects {
   CommonMailboxObjects()
       : mailbox_name1_(MailboxFromChar('1')),
         mailbox_name2_(MailboxFromChar('2')),
         sync_point1_(1),
         sync_point2_(2),
         shared_memory_(new base::SharedMemory) {
     release_mailbox1_ = base::Bind(&MockMailboxCallback::Release,
                                    base::Unretained(&mock_callback_),
                                    mailbox_name1_);
     release_mailbox2_ = base::Bind(&MockMailboxCallback::Release,
                                    base::Unretained(&mock_callback_),
                                    mailbox_name2_);
+    release_mailbox1_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl,
+                                        base::Unretained(&mock_callback_),
+                                        mailbox_name1_);
+    release_mailbox2_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl,
+                                        base::Unretained(&mock_callback_),
+                                        mailbox_name2_);
     const uint32 arbitrary_target1 = GL_TEXTURE_2D;
     const uint32 arbitrary_target2 = GL_TEXTURE_EXTERNAL_OES;
     mailbox1_ = TextureMailbox(mailbox_name1_, arbitrary_target1, sync_point1_);
     mailbox2_ = TextureMailbox(mailbox_name2_, arbitrary_target2, sync_point2_);
     gfx::Size size(128, 128);
     EXPECT_TRUE(shared_memory_->CreateAndMapAnonymous(4 * size.GetArea()));
     release_mailbox3_ = base::Bind(&MockMailboxCallback::Release2,
                                    base::Unretained(&mock_callback_),
                                    shared_memory_.get());
+    release_mailbox3_impl_ = base::Bind(&MockMailboxCallback::ReleaseImpl2,
+                                        base::Unretained(&mock_callback_),
+                                        shared_memory_.get());
     mailbox3_ = TextureMailbox(shared_memory_.get(), size);
   }
 
   gpu::Mailbox mailbox_name1_;
   gpu::Mailbox mailbox_name2_;
   MockMailboxCallback mock_callback_;
   ReleaseCallback release_mailbox1_;
   ReleaseCallback release_mailbox2_;
   ReleaseCallback release_mailbox3_;
+  ReleaseCallbackImpl release_mailbox1_impl_;
+  ReleaseCallbackImpl release_mailbox2_impl_;
+  ReleaseCallbackImpl release_mailbox3_impl_;
   TextureMailbox mailbox1_;
   TextureMailbox mailbox2_;
   TextureMailbox mailbox3_;
   uint32 sync_point1_;
   uint32 sync_point2_;
   scoped_ptr<base::SharedMemory> shared_memory_;
 };
 
 class TextureLayerTest : public testing::Test {
  public:
@@ skipping 222 matching lines @@
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   test_layer->SetTextureMailboxWithoutReleaseCallback(mailbox2);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 class TextureLayerMailboxHolderTest : public TextureLayerTest {
  public:
   TextureLayerMailboxHolderTest()
       : main_thread_("MAIN") {
     main_thread_.Start();
+    main_thread_.message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&TextureLayerMailboxHolderTest::InitializeOnMain,
+                   base::Unretained(this)));
+    Wait(main_thread_);
   }
 
   void Wait(const base::Thread& thread) {
     bool manual_reset = false;
     bool initially_signaled = false;
     base::WaitableEvent event(manual_reset, initially_signaled);
     thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&event)));
     event.Wait();
   }
 
   void CreateMainRef() {
     main_ref_ = TestMailboxHolder::Create(
         test_data_.mailbox1_,
         SingleReleaseCallback::Create(test_data_.release_mailbox1_)).Pass();
   }
 
   void ReleaseMainRef() {
     main_ref_.reset();
   }
 
-  void CreateImplRef(scoped_ptr<SingleReleaseCallback>* impl_ref) {
+  void CreateImplRef(scoped_ptr<SingleReleaseCallbackImpl>* impl_ref) {
     *impl_ref = main_ref_->holder()->GetCallbackForImplThread();
   }
 
   void CapturePostTasksAndWait(base::WaitableEvent* begin_capture,
                                base::WaitableEvent* wait_for_capture,
                                base::WaitableEvent* stop_capture) {
     begin_capture->Wait();
-    BlockingTaskRunner::CapturePostTasks capture;
+    BlockingTaskRunner::CapturePostTasks capture(
+        main_thread_task_runner_.get());
     wait_for_capture->Signal();
     stop_capture->Wait();
   }
 
  protected:
+  void InitializeOnMain() {
+    main_thread_task_runner_ =
+        BlockingTaskRunner::Create(main_thread_.message_loop_proxy());
+  }
+
   scoped_ptr<TestMailboxHolder::MainThreadReference>
       main_ref_;
   base::Thread main_thread_;
+  scoped_ptr<BlockingTaskRunner> main_thread_task_runner_;
   CommonMailboxObjects test_data_;
 };
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_BothReleaseThenMain) {
   scoped_refptr<TextureLayer> test_layer = TextureLayer::CreateForMailbox(NULL);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                  base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor1;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor1;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor1));
 
   // Then the texture layer is removed and attached to compositor2, and passes a
   // reference to its impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor2;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor2;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor2));
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The compositors both destroy their impl trees before the main thread layer
   // is destroyed.
-  compositor1->Run(100, false);
-  compositor2->Run(200, false);
+  compositor1->Run(100, false, main_thread_task_runner_.get());
+  compositor2->Run(200, false, main_thread_task_runner_.get());
 
   Wait(main_thread_);
 
   EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The main thread ref is the last one, so the mailbox is released back to the
   // embedder, with the last sync point provided by the impl trees.
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_, 200, false)).Times(1);
@@ skipping 12 matching lines @@
 
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                  base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor1;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor1;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor1));
 
   // Then the texture layer is removed and attached to compositor2, and passes a
   // reference to its impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor2;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor2;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor2));
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // One compositor destroys their impl tree.
-  compositor1->Run(100, false);
+  compositor1->Run(100, false, main_thread_task_runner_.get());
 
   // Then the main thread reference is destroyed.
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::ReleaseMainRef,
                  base::Unretained(this)));
 
   Wait(main_thread_);
 
   EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The second impl reference is destroyed last, causing the mailbox to be
   // released back to the embedder with the last sync point from the impl tree.
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_, 200, true)).Times(1);
 
-  compositor2->Run(200, true);
+  compositor2->Run(200, true, main_thread_task_runner_.get());
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleasedFirst) {
   scoped_refptr<TextureLayer> test_layer = TextureLayer::CreateForMailbox(NULL);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                  base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor1;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor1;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor1));
 
   // Then the texture layer is removed and attached to compositor2, and passes a
   // reference to its impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor2;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor2;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor2));
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The main thread reference is destroyed first.
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::ReleaseMainRef,
                  base::Unretained(this)));
 
   // One compositor destroys their impl tree.
-  compositor2->Run(200, false);
+  compositor2->Run(200, false, main_thread_task_runner_.get());
 
   Wait(main_thread_);
 
   EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The second impl reference is destroyed last, causing the mailbox to be
   // released back to the embedder with the last sync point from the impl tree.
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_, 100, true)).Times(1);
 
-  compositor1->Run(100, true);
+  compositor1->Run(100, true, main_thread_task_runner_.get());
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_SecondImplRefShortcut) {
   scoped_refptr<TextureLayer> test_layer = TextureLayer::CreateForMailbox(NULL);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                  base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor1;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor1;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor1));
 
   // Then the texture layer is removed and attached to compositor2, and passes a
   // reference to its impl tree.
-  scoped_ptr<SingleReleaseCallback> compositor2;
+  scoped_ptr<SingleReleaseCallbackImpl> compositor2;
   main_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CreateImplRef,
                  base::Unretained(this),
                  &compositor2));
 
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // The main thread reference is destroyed first.
@@ skipping 17 matching lines @@
       FROM_HERE,
       base::Bind(&TextureLayerMailboxHolderTest::CapturePostTasksAndWait,
                  base::Unretained(this),
                  &begin_capture,
                  &wait_for_capture,
                  &stop_capture));
 
   // Before the main thread capturing starts, one compositor destroys their
   // impl reference. Since capturing did not start, this gets post-tasked to
   // the main thread.
-  compositor1->Run(100, false);
+  compositor1->Run(100, false, main_thread_task_runner_.get());
 
   // Start capturing on the main thread.
   begin_capture.Signal();
   wait_for_capture.Wait();
 
   // Meanwhile, the second compositor released its impl reference, but this task
   // gets shortcutted directly to the main thread. This means the reference is
   // released before compositor1, whose reference will be released later when
   // the post-task is serviced. But since it was destroyed _on the impl thread_
   // last, its sync point values should be used.
-  compositor2->Run(200, true);
+  compositor2->Run(200, true, main_thread_task_runner_.get());
 
   stop_capture.Signal();
   Wait(main_thread_);
 
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
  public:
   TextureLayerImplWithMailboxThreadedCallback()
@@ skipping 239 matching lines @@
     return will_draw;
   }
 
   CommonMailboxObjects test_data_;
   FakeLayerTreeHostClient fake_client_;
 };
 
 // Test conditions for results of TextureLayerImpl::WillDraw under
 // different configurations of different mailbox, texture_id, and draw_mode.
 TEST_F(TextureLayerImplWithMailboxTest, TestWillDraw) {
-  EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_,
-                      test_data_.sync_point1_,
-                      false))
+  EXPECT_CALL(
+      test_data_.mock_callback_,
+      ReleaseImpl(test_data_.mailbox_name1_, test_data_.sync_point1_, false, _))
       .Times(AnyNumber());
   EXPECT_CALL(test_data_.mock_callback_,
-              Release2(test_data_.shared_memory_.get(), 0, false))
+              ReleaseImpl2(test_data_.shared_memory_.get(), 0, false, _))
       .Times(AnyNumber());
   // Hardware mode.
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(
         test_data_.mailbox1_,
-        SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+        SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(TextureMailbox(),
-                                  scoped_ptr<SingleReleaseCallback>());
+                                  scoped_ptr<SingleReleaseCallbackImpl>());
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   {
     // Software resource.
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(
         test_data_.mailbox3_,
-        SingleReleaseCallback::Create(test_data_.release_mailbox3_));
+        SingleReleaseCallbackImpl::Create(test_data_.release_mailbox3_impl_));
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   // Software mode.
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(
         test_data_.mailbox1_,
-        SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+        SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(TextureMailbox(),
-                                  scoped_ptr<SingleReleaseCallback>());
+                                  scoped_ptr<SingleReleaseCallbackImpl>());
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   {
     // Software resource.
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(
         test_data_.mailbox3_,
-        SingleReleaseCallback::Create(test_data_.release_mailbox3_));
+        SingleReleaseCallbackImpl::Create(test_data_.release_mailbox3_impl_));
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   // Resourceless software mode.
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1);
     impl_layer->SetTextureMailbox(
         test_data_.mailbox1_,
-        SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+        SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_RESOURCELESS_SOFTWARE));
   }
 }
 
 TEST_F(TextureLayerImplWithMailboxTest, TestImplLayerCallbacks) {
   host_impl_.CreatePendingTree();
   scoped_ptr<TextureLayerImpl> pending_layer;
   pending_layer = TextureLayerImpl::Create(host_impl_.pending_tree(), 1);
   ASSERT_TRUE(pending_layer);
 
   scoped_ptr<LayerImpl> active_layer(
       pending_layer->CreateLayerImpl(host_impl_.active_tree()));
   ASSERT_TRUE(active_layer);
 
   pending_layer->SetTextureMailbox(
       test_data_.mailbox1_,
-      SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+      SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
 
   // Test multiple commits without an activation.
-  EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_,
-                      test_data_.sync_point1_,
-                      false))
+  EXPECT_CALL(
+      test_data_.mock_callback_,
+      ReleaseImpl(test_data_.mailbox_name1_, test_data_.sync_point1_, false, _))
       .Times(1);
   pending_layer->SetTextureMailbox(
       test_data_.mailbox2_,
-      SingleReleaseCallback::Create(test_data_.release_mailbox2_));
+      SingleReleaseCallbackImpl::Create(test_data_.release_mailbox2_impl_));
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test callback after activation.
   pending_layer->PushPropertiesTo(active_layer.get());
   active_layer->DidBecomeActive();
 
-  EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
+  EXPECT_CALL(test_data_.mock_callback_, ReleaseImpl(_, _, _, _)).Times(0);
   pending_layer->SetTextureMailbox(
       test_data_.mailbox1_,
-      SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+      SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name2_, _, false))
-      .Times(1);
+              ReleaseImpl(test_data_.mailbox_name2_, _, false, _)).Times(1);
   pending_layer->PushPropertiesTo(active_layer.get());
   active_layer->DidBecomeActive();
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test resetting the mailbox.
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_, _, false))
-      .Times(1);
+              ReleaseImpl(test_data_.mailbox_name1_, _, false, _)).Times(1);
   pending_layer->SetTextureMailbox(TextureMailbox(),
-                                   scoped_ptr<SingleReleaseCallback>());
+                                   scoped_ptr<SingleReleaseCallbackImpl>());
   pending_layer->PushPropertiesTo(active_layer.get());
   active_layer->DidBecomeActive();
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test destructor.
-  EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_,
-                      test_data_.sync_point1_,
-                      false))
+  EXPECT_CALL(
+      test_data_.mock_callback_,
+      ReleaseImpl(test_data_.mailbox_name1_, test_data_.sync_point1_, false, _))
       .Times(1);
   pending_layer->SetTextureMailbox(
       test_data_.mailbox1_,
-      SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+      SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
 }
 
 TEST_F(TextureLayerImplWithMailboxTest,
        TestDestructorCallbackOnCreatedResource) {
   scoped_ptr<TextureLayerImpl> impl_layer;
   impl_layer = TextureLayerImpl::Create(host_impl_.active_tree(), 1);
   ASSERT_TRUE(impl_layer);
 
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_, _, false))
-      .Times(1);
+              ReleaseImpl(test_data_.mailbox_name1_, _, false, _)).Times(1);
   impl_layer->SetTextureMailbox(
       test_data_.mailbox1_,
-      SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+      SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
   impl_layer->DidBecomeActive();
   EXPECT_TRUE(impl_layer->WillDraw(
       DRAW_MODE_HARDWARE, host_impl_.active_tree()->resource_provider()));
   impl_layer->DidDraw(host_impl_.active_tree()->resource_provider());
   impl_layer->SetTextureMailbox(TextureMailbox(),
-                                scoped_ptr<SingleReleaseCallback>());
+                                scoped_ptr<SingleReleaseCallbackImpl>());
 }
 
 TEST_F(TextureLayerImplWithMailboxTest, TestCallbackOnInUseResource) {
   ResourceProvider* provider = host_impl_.active_tree()->resource_provider();
-  ResourceProvider::ResourceId id =
-      provider->CreateResourceFromTextureMailbox(
-          test_data_.mailbox1_,
-          SingleReleaseCallback::Create(test_data_.release_mailbox1_));
+  ResourceProvider::ResourceId id = provider->CreateResourceFromTextureMailbox(
+      test_data_.mailbox1_,
+      SingleReleaseCallbackImpl::Create(test_data_.release_mailbox1_impl_));
   provider->AllocateForTesting(id);
 
   // Transfer some resources to the parent.
   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
   resource_ids_to_transfer.push_back(id);
   TransferableResourceArray list;
   provider->PrepareSendToParent(resource_ids_to_transfer, &list);
   EXPECT_TRUE(provider->InUseByConsumer(id));
-  EXPECT_CALL(test_data_.mock_callback_, Release(_, _, _)).Times(0);
+  EXPECT_CALL(test_data_.mock_callback_, ReleaseImpl(_, _, _, _)).Times(0);
   provider->DeleteResource(id);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
   EXPECT_CALL(test_data_.mock_callback_,
-              Release(test_data_.mailbox_name1_, _, false))
-      .Times(1);
+              ReleaseImpl(test_data_.mailbox_name1_, _, false, _)).Times(1);
   ReturnedResourceArray returned;
   TransferableResource::ReturnResources(list, &returned);
   provider->ReceiveReturnsFromParent(returned);
 }
 
 // Checks that TextureLayer::Update does not cause an extra commit when setting
 // the texture mailbox.
 class TextureLayerNoExtraCommitForMailboxTest
     : public LayerTreeTest,
       public TextureLayerClient {
@@ skipping 444 matching lines @@
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc