cc: Move TextureMailbox::ReleaseCallback to SingleReleaseCallback.

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 237 matching lines @@
   FakeTextureLayerClient() : context_(TestWebGraphicsContext3D::Create()) {}
 
   virtual unsigned PrepareTexture() OVERRIDE {
     return 0;
   }
 
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
     return context_.get();
   }
 
-  virtual bool PrepareTextureMailbox(TextureMailbox* mailbox,
-                                     bool use_shared_memory) OVERRIDE {
+  virtual bool PrepareTextureMailbox(
+      TextureMailbox* mailbox,
+      scoped_ptr<ScopedReleaseCallback>* release_callback,
+      bool use_shared_memory) OVERRIDE {
     *mailbox = TextureMailbox();
+    *release_callback = scoped_ptr<ScopedReleaseCallback>();
     return true;
   }
 
  private:
   scoped_ptr<TestWebGraphicsContext3D> context_;
   DISALLOW_COPY_AND_ASSIGN(FakeTextureLayerClient);
 };
 
 TEST_F(TextureLayerTest, RateLimiter) {
   FakeTextureLayerClient client;
@@ skipping 62 matching lines @@
         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_);
     gpu::Mailbox m1;
     m1.SetName(reinterpret_cast<const int8*>(mailbox_name1_.data()));
-    mailbox1_ = TextureMailbox(m1, release_mailbox1_, sync_point1_);
+    mailbox1_ = TextureMailbox(m1, sync_point1_);
     gpu::Mailbox m2;
     m2.SetName(reinterpret_cast<const int8*>(mailbox_name2_.data()));
-    mailbox2_ = TextureMailbox(m2, release_mailbox2_, sync_point2_);
+    mailbox2_ = TextureMailbox(m2, 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());
-    mailbox3_ = TextureMailbox(shared_memory_.get(), size, release_mailbox3_);
+    mailbox3_ = TextureMailbox(shared_memory_.get(), size);
   }
 
   std::string mailbox_name1_;
   std::string mailbox_name2_;
   MockMailboxCallback mock_callback_;
-  TextureMailbox::ReleaseCallback release_mailbox1_;
-  TextureMailbox::ReleaseCallback release_mailbox2_;
-  TextureMailbox::ReleaseCallback release_mailbox3_;
+  ReleaseCallback release_mailbox1_;
+  ReleaseCallback release_mailbox2_;
+  ReleaseCallback release_mailbox3_;
   TextureMailbox mailbox1_;
   TextureMailbox mailbox2_;
   TextureMailbox mailbox3_;
   unsigned sync_point1_;
   unsigned sync_point2_;
   scoped_ptr<base::SharedMemory> shared_memory_;
 };
 
 class TestMailboxHolder : public TextureLayer::MailboxHolder {
  public:
@@ skipping 21 matching lines @@
   scoped_refptr<TextureLayer> test_layer = TextureLayer::CreateForMailbox(NULL);
   ASSERT_TRUE(test_layer.get());
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  test_layer->SetTextureMailbox(test_data_.mailbox1_);
+  test_layer->SetTextureMailbox(
+      test_data_.mailbox1_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_,
                       test_data_.sync_point1_,
                       false))
       .Times(1);
-  test_layer->SetTextureMailbox(test_data_.mailbox2_);
+  test_layer->SetTextureMailbox(
+      test_data_.mailbox2_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox2_));
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name2_,
                       test_data_.sync_point2_,
                       false))
       .Times(1);
-  test_layer->SetTextureMailbox(TextureMailbox());
+  test_layer->SetTextureMailbox(TextureMailbox(),
+                                scoped_ptr<ScopedReleaseCallback>());
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  test_layer->SetTextureMailbox(test_data_.mailbox3_);
+  test_layer->SetTextureMailbox(
+      test_data_.mailbox3_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox3_));
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   EXPECT_CALL(*layer_tree_host_, AcquireLayerTextures()).Times(0);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   EXPECT_CALL(test_data_.mock_callback_,
               Release2(test_data_.shared_memory_.get(),
                        0, false))
       .Times(1);
-  test_layer->SetTextureMailbox(TextureMailbox());
+  test_layer->SetTextureMailbox(TextureMailbox(),
+                                scoped_ptr<ScopedReleaseCallback>());
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   // Test destructor.
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
-  test_layer->SetTextureMailbox(test_data_.mailbox1_);
+  test_layer->SetTextureMailbox(
+      test_data_.mailbox1_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
 }
 
 class TextureLayerMailboxHolderTest : public TextureLayerTest {
  public:
   TextureLayerMailboxHolderTest()
       : main_thread_("MAIN") {
     main_thread_.Start();
   }
 
   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_).Pass();
+        test_data_.mailbox1_,
+        ScopedReleaseCallback::Create(test_data_.release_mailbox1_)).Pass();
   }
 
   void ReleaseMainRef() {
     main_ref_.reset();
   }
 
-  void CreateImplRef(TextureMailbox::ReleaseCallback* impl_ref) {
+  void CreateImplRef(scoped_ptr<ScopedReleaseCallback>* 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;
     wait_for_capture->Signal();
     stop_capture->Wait();
@@ 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.
-  TextureMailbox::ReleaseCallback compositor1;
+  scoped_ptr<ScopedReleaseCallback> 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.
-  TextureMailbox::ReleaseCallback compositor2;
+  scoped_ptr<ScopedReleaseCallback> 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);
+  compositor2->Run(200, false);
 
   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.
-  TextureMailbox::ReleaseCallback compositor1;
+  scoped_ptr<ScopedReleaseCallback> 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.
-  TextureMailbox::ReleaseCallback compositor2;
+  scoped_ptr<ScopedReleaseCallback> 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);
 
   // 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);
   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.
-  TextureMailbox::ReleaseCallback compositor1;
+  scoped_ptr<ScopedReleaseCallback> 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.
-  TextureMailbox::ReleaseCallback compositor2;
+  scoped_ptr<ScopedReleaseCallback> 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);
 
   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);
   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.
-  TextureMailbox::ReleaseCallback compositor1;
+  scoped_ptr<ScopedReleaseCallback> 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.
-  TextureMailbox::ReleaseCallback compositor2;
+  scoped_ptr<ScopedReleaseCallback> 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);
 
   // 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);
 
   stop_capture.Signal();
   Wait(main_thread_);
 
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
  public:
   TextureLayerImplWithMailboxThreadedCallback()
       : callback_count_(0),
         commit_count_(0) {}
 
   // Make sure callback is received on main and doesn't block the impl thread.
   void ReleaseCallback(unsigned sync_point, bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
-    TextureMailbox mailbox(
-        std::string(64, mailbox_char),
+    TextureMailbox mailbox(std::string(64, mailbox_char));
+    scoped_ptr<ScopedReleaseCallback> callback = ScopedReleaseCallback::Create(
         base::Bind(
             &TextureLayerImplWithMailboxThreadedCallback::ReleaseCallback,
             base::Unretained(this)));
-    layer_->SetTextureMailbox(mailbox);
+    layer_->SetTextureMailbox(mailbox, callback.Pass());
   }
 
   virtual void BeginTest() OVERRIDE {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetBounds(bounds);
 
@@ skipping 29 matching lines @@
         EXPECT_EQ(2, callback_count_);
         // Case #3: change mailbox when the layer doesn't draw. The old
         // mailbox should be released during the next commit.
         layer_->SetBounds(gfx::Size());
         SetMailbox('4');
         break;
       case 3:
         EXPECT_EQ(3, callback_count_);
         // Case #4: release mailbox that was committed but never drawn. The
         // old mailbox should be released during the next commit.
-        layer_->SetTextureMailbox(TextureMailbox());
+        layer_->SetTextureMailbox(TextureMailbox(),
+                                  scoped_ptr<ScopedReleaseCallback>());
         break;
       case 4:
         if (layer_tree_host()->settings().impl_side_painting) {
           // With impl painting, the texture mailbox will still be on the impl
           // thread when the commit finishes, because the layer is not drawble
           // when it has no texture mailbox, and thus does not block the commit
           // on activation. So, we wait for activation.
           // TODO(danakj): fix this. crbug.com/277953
           layer_tree_host()->SetNeedsCommit();
           break;
@@ skipping 18 matching lines @@
           // block the commit on activation anymore. So, we wait for activation.
           // TODO(danakj): fix this. crbug.com/277953
           layer_tree_host()->SetNeedsCommit();
           break;
         } else {
           ++commit_count_;
         }
       case 8:
         EXPECT_EQ(4, callback_count_);
         // Resetting the mailbox will call the callback now.
-        layer_->SetTextureMailbox(TextureMailbox());
+        layer_->SetTextureMailbox(TextureMailbox(),
+                                  scoped_ptr<ScopedReleaseCallback>());
         EXPECT_EQ(5, callback_count_);
         EndTest();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 40 matching lines @@
   }
 
   // TextureLayerClient implementation.
   virtual unsigned PrepareTexture() OVERRIDE {
     return OffscreenContextProviderForMainThread()
         ->Context3d()->createTexture();
   }
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
     return OffscreenContextProviderForMainThread()->Context3d();
   }
-  virtual bool PrepareTextureMailbox(TextureMailbox* mailbox,
-                                     bool use_shared_memory) OVERRIDE {
+  virtual bool PrepareTextureMailbox(
+      TextureMailbox* mailbox,
+      scoped_ptr<ScopedReleaseCallback>* release_callback,
+      bool use_shared_memory) OVERRIDE {
     return false;
   }
 
   virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // Slow down activation so the main thread DidCommit() will run if
     // not blocked.
     wait_thread_.message_loop()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&base::WaitableEvent::Signal,
                    base::Unretained(&wait_event_)),
@@ skipping 73 matching lines @@
  protected:
   TextureLayerMailboxIsActivatedDuringCommit()
       : wait_thread_("WAIT"),
         wait_event_(false, false) {
     wait_thread_.Start();
   }
 
   static void ReleaseCallback(unsigned sync_point, bool lost_resource) {}
 
   void SetMailbox(char mailbox_char) {
-    TextureMailbox mailbox(
-        std::string(64, mailbox_char),
+    TextureMailbox mailbox(std::string(64, mailbox_char));
+    scoped_ptr<ScopedReleaseCallback> callback = ScopedReleaseCallback::Create(
         base::Bind(
             &TextureLayerMailboxIsActivatedDuringCommit::ReleaseCallback));
-    layer_->SetTextureMailbox(mailbox);
+    layer_->SetTextureMailbox(mailbox, callback.Pass());
   }
 
   virtual void BeginTest() OVERRIDE {
     activate_count_ = 0;
 
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetBounds(bounds);
 
@@ skipping 120 matching lines @@
                       test_data_.sync_point1_,
                       false))
       .Times(AnyNumber());
   EXPECT_CALL(test_data_.mock_callback_,
               Release2(test_data_.shared_memory_.get(), 0, false))
       .Times(AnyNumber());
   // Hardware mode.
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
-    impl_layer->SetTextureMailbox(test_data_.mailbox1_);
+    impl_layer->SetTextureMailbox(
+        test_data_.mailbox1_,
+        ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
-    impl_layer->SetTextureMailbox(TextureMailbox());
+    impl_layer->SetTextureMailbox(TextureMailbox(),
+                                  scoped_ptr<ScopedReleaseCallback>());
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   {
     // Software resource.
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
-    impl_layer->SetTextureMailbox(test_data_.mailbox3_);
+    impl_layer->SetTextureMailbox(
+        test_data_.mailbox3_,
+        ScopedReleaseCallback::Create(test_data_.release_mailbox3_));
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, false);
     ContextProvider* context_provider =
         host_impl_.output_surface()->context_provider();
     unsigned texture =
         context_provider->Context3d()->createTexture();
     impl_layer->set_texture_id(texture);
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, false);
     impl_layer->set_texture_id(0);
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_HARDWARE));
   }
 
   // Software mode.
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
-    impl_layer->SetTextureMailbox(test_data_.mailbox1_);
+    impl_layer->SetTextureMailbox(
+        test_data_.mailbox1_,
+        ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
-    impl_layer->SetTextureMailbox(TextureMailbox());
+    impl_layer->SetTextureMailbox(TextureMailbox(),
+                                  scoped_ptr<ScopedReleaseCallback>());
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   {
     // Software resource.
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
-    impl_layer->SetTextureMailbox(test_data_.mailbox3_);
+    impl_layer->SetTextureMailbox(
+        test_data_.mailbox3_,
+        ScopedReleaseCallback::Create(test_data_.release_mailbox3_));
     EXPECT_TRUE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, false);
     ContextProvider* context_provider =
         host_impl_.output_surface()->context_provider();
     unsigned texture =
         context_provider->Context3d()->createTexture();
     impl_layer->set_texture_id(texture);
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, false);
     impl_layer->set_texture_id(0);
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_SOFTWARE));
   }
 
   // Resourceless software mode.
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
-    impl_layer->SetTextureMailbox(test_data_.mailbox1_);
+    impl_layer->SetTextureMailbox(
+        test_data_.mailbox1_,
+        ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
     EXPECT_FALSE(WillDraw(impl_layer.get(), DRAW_MODE_RESOURCELESS_SOFTWARE));
   }
 
   {
     scoped_ptr<TextureLayerImpl> impl_layer =
         TextureLayerImpl::Create(host_impl_.active_tree(), 1, false);
     ContextProvider* context_provider =
         host_impl_.output_surface()->context_provider();
     unsigned texture =
         context_provider->Context3d()->createTexture();
     impl_layer->set_texture_id(texture);
     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, true);
   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_);
+  pending_layer->SetTextureMailbox(
+      test_data_.mailbox1_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
 
   // Test multiple commits without an activation.
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_,
                       test_data_.sync_point1_,
                       false))
       .Times(1);
-  pending_layer->SetTextureMailbox(test_data_.mailbox2_);
+  pending_layer->SetTextureMailbox(
+      test_data_.mailbox2_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox2_));
   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);
-  pending_layer->SetTextureMailbox(test_data_.mailbox1_);
+  pending_layer->SetTextureMailbox(
+      test_data_.mailbox1_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 
   EXPECT_CALL(test_data_.mock_callback_,
               Release(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);
-  pending_layer->SetTextureMailbox(TextureMailbox());
+  pending_layer->SetTextureMailbox(TextureMailbox(),
+                                   scoped_ptr<ScopedReleaseCallback>());
   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))
       .Times(1);
-  pending_layer->SetTextureMailbox(test_data_.mailbox1_);
+  pending_layer->SetTextureMailbox(
+      test_data_.mailbox1_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
 }
 
 TEST_F(TextureLayerImplWithMailboxTest,
        TestDestructorCallbackOnCreatedResource) {
   scoped_ptr<TextureLayerImpl> impl_layer;
   impl_layer = TextureLayerImpl::Create(host_impl_.active_tree(), 1, true);
   ASSERT_TRUE(impl_layer);
 
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_, _, false))
       .Times(1);
-  impl_layer->SetTextureMailbox(test_data_.mailbox1_);
+  impl_layer->SetTextureMailbox(
+      test_data_.mailbox1_,
+      ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
   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());
+  impl_layer->SetTextureMailbox(TextureMailbox(),
+                                scoped_ptr<ScopedReleaseCallback>());
 }
 
 TEST_F(TextureLayerImplWithMailboxTest, TestCallbackOnInUseResource) {
   ResourceProvider* provider = host_impl_.active_tree()->resource_provider();
   ResourceProvider::ResourceId id =
-      provider->CreateResourceFromTextureMailbox(test_data_.mailbox1_);
+      provider->CreateResourceFromTextureMailbox(
+          test_data_.mailbox1_,
+          ScopedReleaseCallback::Create(test_data_.release_mailbox1_));
   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);
   provider->DeleteResource(id);
@@ skipping 30 matching lines @@
 
   virtual unsigned PrepareTexture() OVERRIDE {
     return texture_;
   }
 
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
     return context_;
   }
 
   virtual bool PrepareTextureMailbox(
-      cc::TextureMailbox* mailbox, bool use_shared_memory) OVERRIDE {
+      TextureMailbox* mailbox,
+      scoped_ptr<ScopedReleaseCallback>* release_callback,
+      bool use_shared_memory) OVERRIDE {
     return false;
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetAnchorPoint(gfx::PointF());
     root->SetIsDrawable(true);
 
     texture_layer_ = TextureLayer::Create(this);
@@ skipping 95 matching lines @@
     return texture_;
   }
 
   // TextureLayerClient implementation.
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
     return client_context_.get();
   }
 
   // TextureLayerClient implementation.
   virtual bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox, bool use_shared_memory) OVERRIDE {

[piman, 2013/09/14 01:51:33]

post-rebase, you need to fix this one, and the other one below...

[danakj, 2013/09/16 16:42:21]

Done.

     return false;
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetAnchorPoint(gfx::PointF());
     root->SetIsDrawable(true);
 
     solid_layer_ = SolidColorLayer::Create();
@@ skipping 311 matching lines @@
           GL_INNOCENT_CONTEXT_RESET_ARB);
     }
     return texture_;
   }
 
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
     return texture_context_.get();
   }
 
   virtual bool PrepareTextureMailbox(
-      cc::TextureMailbox* mailbox, bool use_shared_memory) OVERRIDE {
+      TextureMailbox* mailbox,
+      scoped_ptr<ScopedReleaseCallback>* release_callback,
+      bool use_shared_memory) OVERRIDE {
     return false;
   }
 
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
     texture_layer_ = TextureLayer::Create(this);
     texture_layer_->SetBounds(gfx::Size(10, 10));
@@ skipping 40 matching lines @@
  public:
   void ReleaseCallback(unsigned sync_point, bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
     EndTest();
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
-    TextureMailbox mailbox(
-        std::string(64, mailbox_char),
+    TextureMailbox mailbox(std::string(64, mailbox_char));
+    scoped_ptr<ScopedReleaseCallback> callback = ScopedReleaseCallback::Create(
         base::Bind(
             &TextureLayerWithMailboxMainThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
-    layer_->SetTextureMailbox(mailbox);
+    layer_->SetTextureMailbox(mailbox, callback.Pass());
   }
 
   virtual void SetupTree() OVERRIDE {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(NULL);
     layer_->SetIsDrawable(true);
@@ skipping 46 matching lines @@
  public:
   void ReleaseCallback(unsigned sync_point, bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
     EndTest();
   }
 
   void SetMailbox(char mailbox_char) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
-    TextureMailbox mailbox(
-        std::string(64, mailbox_char),
+    TextureMailbox mailbox(std::string(64, mailbox_char));
+    scoped_ptr<ScopedReleaseCallback> callback = ScopedReleaseCallback::Create(
         base::Bind(
             &TextureLayerWithMailboxImplThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
-    layer_->SetTextureMailbox(mailbox);
+    layer_->SetTextureMailbox(mailbox, callback.Pass());
   }
 
   virtual void SetupTree() OVERRIDE {
     gfx::Size bounds(100, 100);
     root_ = Layer::Create();
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetBounds(bounds);
 
     layer_ = TextureLayer::CreateForMailbox(NULL);
     layer_->SetIsDrawable(true);
@@ skipping 40 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