Cosmetic cleanup to texture_layer mailboxes.

cc/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/texture_layer.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "cc/layer_tree_host.h"
@@ skipping 178 matching lines @@
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 }
 
 class MockMailboxCallback {
 public:
     MOCK_METHOD2(Release, void(const std::string& mailbox, unsigned syncPoint));
 };
 
 struct CommonMailboxObjects {
     CommonMailboxObjects()
-        : m_mailbox1(64, '1')
-        , m_mailbox2(64, '2')
+        : m_mailboxName1(64, '1')
+        , m_mailboxName2(64, '2')
     {
         m_releaseMailbox1 = base::Bind(&MockMailboxCallback::Release,
                                        base::Unretained(&m_mockCallback),
-                                       m_mailbox1);
+                                       m_mailboxName1);
         m_releaseMailbox2 = base::Bind(&MockMailboxCallback::Release,
                                        base::Unretained(&m_mockCallback),
-                                       m_mailbox2);
+                                       m_mailboxName2);
+
+        m_mailbox1 = TextureMailbox(m_mailboxName1, m_releaseMailbox1);
+        m_mailbox2 = TextureMailbox(m_mailboxName2, m_releaseMailbox2);
     }
 
-    std::string m_mailbox1;
-    std::string m_mailbox2;
+    std::string m_mailboxName1;
+    std::string m_mailboxName2;
     MockMailboxCallback m_mockCallback;
-    TextureLayer::MailboxCallback m_releaseMailbox1;
-    TextureLayer::MailboxCallback m_releaseMailbox2;
+    TextureMailbox::ReleaseCallback m_releaseMailbox1;
+    TextureMailbox::ReleaseCallback m_releaseMailbox2;
+    TextureMailbox m_mailbox1;
+    TextureMailbox m_mailbox2;
 };
 
 class TextureLayerWithMailboxTest : public TextureLayerTest {
 protected:
     virtual void TearDown()
     {
         Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
         EXPECT_CALL(m_testData.m_mockCallback,
-                    Release(m_testData.m_mailbox1, _)).Times(1);
+                    Release(m_testData.m_mailboxName1, _)).Times(1);
         TextureLayerTest::TearDown();
     }
 
     CommonMailboxObjects m_testData;
 };
 
 TEST_F(TextureLayerWithMailboxTest, replaceMailboxOnMainThreadBeforeCommit)
 {
     scoped_refptr<TextureLayer> testLayer = TextureLayer::createForMailbox();
     ASSERT_TRUE(testLayer);
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AnyNumber());
     m_layerTreeHost->setRootLayer(testLayer);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
-    testLayer->setTextureMailbox(m_testData.m_mailbox1,
-                                 m_testData.m_releaseMailbox1);
+    testLayer->setTextureMailbox(m_testData.m_mailbox1);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
     EXPECT_CALL(m_testData.m_mockCallback,
-                Release(m_testData.m_mailbox1, _)).Times(1);
-    testLayer->setTextureMailbox(m_testData.m_mailbox2,
-                                 m_testData.m_releaseMailbox2);
+                Release(m_testData.m_mailboxName1, _)).Times(1);
+    testLayer->setTextureMailbox(m_testData.m_mailbox2);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
     EXPECT_CALL(m_testData.m_mockCallback,
-                Release(m_testData.m_mailbox2, _)).Times(1);
-    testLayer->setTextureMailbox(std::string(),
-                                 TextureLayer::MailboxCallback());
+                Release(m_testData.m_mailboxName2, _)).Times(1);
+    testLayer->setTextureMailbox(TextureMailbox());
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     // Test destructor.
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
-    testLayer->setTextureMailbox(m_testData.m_mailbox1,
-                                 m_testData.m_releaseMailbox1);
+    testLayer->setTextureMailbox(m_testData.m_mailbox1);
 }
 
 class TextureLayerImplWithMailboxThreadedCallback : public ThreadedTest {
 public:
     TextureLayerImplWithMailboxThreadedCallback()
         : m_resetMailbox(false)
     {
     }
 
     // Make sure callback is received on main and doesn't block the impl thread.
     void releaseCallback(unsigned syncPoint) {
         EXPECT_EQ(true, proxy()->isMainThread());
         endTest();
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layer = TextureLayer::createForMailbox();
         m_layer->setIsDrawable(true);
         m_layerTreeHost->setRootLayer(m_layer);
-        m_layer->setTextureMailbox(
+        TextureMailbox mailbox(
             std::string(64, '1'),
             base::Bind(
                 &TextureLayerImplWithMailboxThreadedCallback::releaseCallback,
                 base::Unretained(this)));
+        m_layer->setTextureMailbox(mailbox);
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
     {
         if (m_resetMailbox)
             return;
 
-        m_layer->setTextureMailbox(std::string(),
-                                   TextureLayer::MailboxCallback());
+        m_layer->setTextureMailbox(TextureMailbox());
         m_resetMailbox = true;
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     bool m_resetMailbox;
     scoped_refptr<TextureLayer> m_layer;
@@ skipping 14 matching lines @@
 };
 
 TEST_F(TextureLayerImplWithMailboxTest, testImplLayerCallbacks)
 {
     scoped_ptr<TextureLayerImpl> implLayer;
     implLayer = TextureLayerImpl::create(m_hostImpl.activeTree(), 1, true);
     ASSERT_TRUE(implLayer);
 
     // Test setting identical mailbox.
     EXPECT_CALL(m_testData.m_mockCallback, Release(_, _)).Times(0);
-    implLayer->setTextureMailbox(m_testData.m_mailbox1,
-                                 m_testData.m_releaseMailbox1);
-    implLayer->setTextureMailbox(m_testData.m_mailbox1,
-                                 m_testData.m_releaseMailbox1);
+    implLayer->setTextureMailbox(m_testData.m_mailbox1);
+    implLayer->setTextureMailbox(m_testData.m_mailbox1);
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     // Test multiple commits without a draw.
     EXPECT_CALL(m_testData.m_mockCallback,
-                Release(m_testData.m_mailbox1, _)).Times(1);
-    implLayer->setTextureMailbox(m_testData.m_mailbox2,
-                                 m_testData.m_releaseMailbox2);
+                Release(m_testData.m_mailboxName1, _)).Times(1);
+    implLayer->setTextureMailbox(m_testData.m_mailbox2);
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     // Test resetting the mailbox.
     EXPECT_CALL(m_testData.m_mockCallback,
-                Release(m_testData.m_mailbox2, _)).Times(1);
-    implLayer->setTextureMailbox(std::string(),
-                                 TextureLayer::MailboxCallback());
+                Release(m_testData.m_mailboxName2, _)).Times(1);
+    implLayer->setTextureMailbox(TextureMailbox());
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     // Test destructor.
     EXPECT_CALL(m_testData.m_mockCallback,
-                Release(m_testData.m_mailbox1, _)).Times(1);
-    implLayer->setTextureMailbox(m_testData.m_mailbox1,
-                                 m_testData.m_releaseMailbox1);
+                Release(m_testData.m_mailboxName1, _)).Times(1);
+    implLayer->setTextureMailbox(m_testData.m_mailbox1);
 }
 
 TEST_F(TextureLayerImplWithMailboxTest, testDestructorCallbackOnCreatedResource)
 {
     scoped_ptr<TextureLayerImpl> implLayer;
     implLayer = TextureLayerImpl::create(m_hostImpl.activeTree(), 1, true);
     ASSERT_TRUE(implLayer);
 
     EXPECT_CALL(m_testData.m_mockCallback,
-                Release(m_testData.m_mailbox1, _)).Times(1);
-    implLayer->setTextureMailbox(m_testData.m_mailbox1,
-                                 m_testData.m_releaseMailbox1);
+                Release(m_testData.m_mailboxName1, _)).Times(1);
+    implLayer->setTextureMailbox(m_testData.m_mailbox1);
     implLayer->willDraw(m_hostImpl.activeTree()->resource_provider());
     implLayer->didDraw(m_hostImpl.activeTree()->resource_provider());
-    implLayer->setTextureMailbox(std::string(),
-                                 TextureLayer::MailboxCallback());
+    implLayer->setTextureMailbox(TextureMailbox());
 }
 
 TEST_F(TextureLayerImplWithMailboxTest, testCallbackOnInUseResource)
 {
     ResourceProvider *provider = m_hostImpl.activeTree()->resource_provider();
     ResourceProvider::ResourceId id =
-        provider->createResourceFromTextureMailbox(
-           m_testData.m_mailbox1,
-           m_testData.m_releaseMailbox1);
+        provider->createResourceFromTextureMailbox(m_testData.m_mailbox1);
     provider->allocateForTesting(id);
 
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resourceIdsToTransfer;
     resourceIdsToTransfer.push_back(id);
     TransferableResourceList list;
     provider->prepareSendToParent(resourceIdsToTransfer, &list);
     EXPECT_TRUE(provider->inUseByConsumer(id));
     EXPECT_CALL(m_testData.m_mockCallback, Release(_, _)).Times(0);
     provider->deleteResource(id);
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
     EXPECT_CALL(m_testData.m_mockCallback,
-                Release(m_testData.m_mailbox1, _)).Times(1);
+                Release(m_testData.m_mailboxName1, _)).Times(1);
     provider->receiveFromParent(list);
 }
 
 }  // namespace
 }  // namespace cc