cc: Chromify Layer and LayerImpl classes.

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 55 matching lines @@
         m_layerTreeHost.reset();
     }
 
     scoped_ptr<MockLayerImplTreeHost> m_layerTreeHost;
     FakeImplProxy m_proxy;
     FakeLayerTreeHostImpl m_hostImpl;
 };
 
 TEST_F(TextureLayerTest, syncImplWhenChangingTextureId)
 {
-    scoped_refptr<TextureLayer> testLayer = TextureLayer::create(0);
+    scoped_refptr<TextureLayer> testLayer = TextureLayer::Create(NULL);
     ASSERT_TRUE(testLayer);
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(AnyNumber());
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AnyNumber());
     m_layerTreeHost->setRootLayer(testLayer);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
-    EXPECT_EQ(testLayer->layerTreeHost(), m_layerTreeHost.get());
+    EXPECT_EQ(testLayer->layer_tree_host(), m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
     testLayer->setTextureId(1);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(AtLeast(1));
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
     testLayer->setTextureId(2);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(AtLeast(1));
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
     testLayer->setTextureId(0);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 }
 
 TEST_F(TextureLayerTest, syncImplWhenDrawing)
 {
     gfx::RectF dirtyRect(0, 0, 1, 1);
 
-    scoped_refptr<TextureLayer> testLayer = TextureLayer::create(0);
+    scoped_refptr<TextureLayer> testLayer = TextureLayer::Create(NULL);
     ASSERT_TRUE(testLayer);
     scoped_ptr<TextureLayerImpl> implLayer;
-    implLayer = TextureLayerImpl::create(m_hostImpl.activeTree(), 1, false);
+    implLayer = TextureLayerImpl::Create(m_hostImpl.activeTree(), 1, false);
     ASSERT_TRUE(implLayer);
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(AnyNumber());
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AnyNumber());
     m_layerTreeHost->setRootLayer(testLayer);
     testLayer->setTextureId(1);
-    testLayer->setIsDrawable(true);
+    testLayer->SetIsDrawable(true);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
-    EXPECT_EQ(testLayer->layerTreeHost(), m_layerTreeHost.get());
+    EXPECT_EQ(testLayer->layer_tree_host(), m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(1);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(0);
     testLayer->willModifyTexture();
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(1);
-    testLayer->setNeedsDisplayRect(dirtyRect);
+    testLayer->SetNeedsDisplayRect(dirtyRect);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(1);
-    testLayer->pushPropertiesTo(implLayer.get()); // fake commit
-    testLayer->setIsDrawable(false);
+    testLayer->PushPropertiesTo(implLayer.get()); // fake commit
+    testLayer->SetIsDrawable(false);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     // Verify that non-drawable layers don't signal the compositor,
     // except for the first draw after last commit, which must acquire
     // the texture.
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(1);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(0);
     testLayer->willModifyTexture();
-    testLayer->setNeedsDisplayRect(dirtyRect);
-    testLayer->pushPropertiesTo(implLayer.get()); // fake commit
+    testLayer->SetNeedsDisplayRect(dirtyRect);
+    testLayer->PushPropertiesTo(implLayer.get()); // fake commit
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     // Second draw with layer in non-drawable state: no texture
     // acquisition.
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(0);
     testLayer->willModifyTexture();
-    testLayer->setNeedsDisplayRect(dirtyRect);
+    testLayer->SetNeedsDisplayRect(dirtyRect);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 }
 
 TEST_F(TextureLayerTest, syncImplWhenRemovingFromTree)
 {
-    scoped_refptr<Layer> rootLayer = Layer::create();
+    scoped_refptr<Layer> rootLayer = Layer::Create();
     ASSERT_TRUE(rootLayer);
-    scoped_refptr<Layer> childLayer = Layer::create();
+    scoped_refptr<Layer> childLayer = Layer::Create();
     ASSERT_TRUE(childLayer);
-    rootLayer->addChild(childLayer);
-    scoped_refptr<TextureLayer> testLayer = TextureLayer::create(0);
+    rootLayer->AddChild(childLayer);
+    scoped_refptr<TextureLayer> testLayer = TextureLayer::Create(NULL);
     ASSERT_TRUE(testLayer);
     testLayer->setTextureId(0);
-    childLayer->addChild(testLayer);
+    childLayer->AddChild(testLayer);
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(AnyNumber());
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AnyNumber());
     m_layerTreeHost->setRootLayer(rootLayer);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
-    testLayer->removeFromParent();
+    testLayer->RemoveFromParent();
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
-    childLayer->addChild(testLayer);
+    childLayer->AddChild(testLayer);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(0);
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
     testLayer->setTextureId(1);
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
     EXPECT_CALL(*m_layerTreeHost, acquireLayerTextures()).Times(AtLeast(1));
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
-    testLayer->removeFromParent();
+    testLayer->RemoveFromParent();
     Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 }
 
 class MockMailboxCallback {
 public:
     MOCK_METHOD2(Release, void(const std::string& mailbox, unsigned syncPoint));
 };
 
 struct CommonMailboxObjects {
     CommonMailboxObjects()
@@ skipping 36 matching lines @@
                     Release(m_testData.m_mailboxName1,
                             m_testData.m_syncPoint1)).Times(1);
         TextureLayerTest::TearDown();
     }
 
     CommonMailboxObjects m_testData;
 };
 
 TEST_F(TextureLayerWithMailboxTest, replaceMailboxOnMainThreadBeforeCommit)
 {
-    scoped_refptr<TextureLayer> testLayer = TextureLayer::createForMailbox();
+    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);
@@ skipping 41 matching lines @@
             std::string(64, mailbox_char),
             base::Bind(
                 &TextureLayerImplWithMailboxThreadedCallback::releaseCallback,
                 base::Unretained(this)));
         m_layer->setTextureMailbox(mailbox);
     }
 
     virtual void beginTest() OVERRIDE
     {
         gfx::Size bounds(100, 100);
-        m_root = Layer::create();
-        m_root->setAnchorPoint(gfx::PointF());
-        m_root->setBounds(bounds);
+        m_root = Layer::Create();
+        m_root->SetAnchorPoint(gfx::PointF());
+        m_root->SetBounds(bounds);
 
-        m_layer = TextureLayer::createForMailbox();
-        m_layer->setIsDrawable(true);
-        m_layer->setAnchorPoint(gfx::PointF());
-        m_layer->setBounds(bounds);
+        m_layer = TextureLayer::CreateForMailbox();
+        m_layer->SetIsDrawable(true);
+        m_layer->SetAnchorPoint(gfx::PointF());
+        m_layer->SetBounds(bounds);
 
-        m_root->addChild(m_layer);
+        m_root->AddChild(m_layer);
         m_layerTreeHost->setRootLayer(m_root);
         m_layerTreeHost->setViewportSize(bounds, bounds);
         setMailbox('1');
         EXPECT_EQ(0, m_callbackCount);
 
         // Case #1: change mailbox before the commit. The old mailbox should be
         // released immediately.
         setMailbox('2');
         EXPECT_EQ(1, m_callbackCount);
         postSetNeedsCommitToMainThread();
@@ skipping 14 matching lines @@
             // Old mailbox was released, task was posted, but won't execute
             // until this didCommit returns.
             // TODO(piman): fix this.
             EXPECT_EQ(1, m_callbackCount);
             m_layerTreeHost->setNeedsCommit();
             break;
         case 3:
             EXPECT_EQ(2, m_callbackCount);
             // Case #3: change mailbox when the layer doesn't draw. The old
             // mailbox should be released during the next commit.
-            m_layer->setBounds(gfx::Size());
+            m_layer->SetBounds(gfx::Size());
             setMailbox('4');
             break;
         case 4:
             // Old mailbox was released, task was posted, but won't execute
             // until this didCommit returns.
             // TODO(piman): fix this.
             EXPECT_EQ(2, m_callbackCount);
             m_layerTreeHost->setNeedsCommit();
             break;
         case 5:
@@ skipping 41 matching lines @@
         EXPECT_TRUE(m_hostImpl.initializeRenderer(createFakeOutputSurface()));
     }
 
     CommonMailboxObjects m_testData;
 };
 
 TEST_F(TextureLayerImplWithMailboxTest, testImplLayerCallbacks)
 {
     m_hostImpl.createPendingTree();
     scoped_ptr<TextureLayerImpl> pendingLayer;
-    pendingLayer = TextureLayerImpl::create(m_hostImpl.pendingTree(), 1, true);
+    pendingLayer = TextureLayerImpl::Create(m_hostImpl.pendingTree(), 1, true);
     ASSERT_TRUE(pendingLayer);
 
-    scoped_ptr<LayerImpl> activeLayer(pendingLayer->createLayerImpl(
+    scoped_ptr<LayerImpl> activeLayer(pendingLayer->CreateLayerImpl(
         m_hostImpl.activeTree()));
     ASSERT_TRUE(activeLayer);
 
     pendingLayer->setTextureMailbox(m_testData.m_mailbox1);
 
     // Test multiple commits without an activation.
     EXPECT_CALL(m_testData.m_mockCallback,
                 Release(m_testData.m_mailboxName1,
                         m_testData.m_syncPoint1)).Times(1);
     pendingLayer->setTextureMailbox(m_testData.m_mailbox2);
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     // Test callback after activation.
-    pendingLayer->pushPropertiesTo(activeLayer.get());
-    activeLayer->didBecomeActive();
+    pendingLayer->PushPropertiesTo(activeLayer.get());
+    activeLayer->DidBecomeActive();
 
     EXPECT_CALL(m_testData.m_mockCallback,
                 Release(_, _)).Times(0);
     pendingLayer->setTextureMailbox(m_testData.m_mailbox1);
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     EXPECT_CALL(m_testData.m_mockCallback,
                 Release(m_testData.m_mailboxName2, _)).Times(1);
-    pendingLayer->pushPropertiesTo(activeLayer.get());
-    activeLayer->didBecomeActive();
+    pendingLayer->PushPropertiesTo(activeLayer.get());
+    activeLayer->DidBecomeActive();
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     // Test resetting the mailbox.
     EXPECT_CALL(m_testData.m_mockCallback,
                 Release(m_testData.m_mailboxName1, _)).Times(1);
     pendingLayer->setTextureMailbox(TextureMailbox());
-    pendingLayer->pushPropertiesTo(activeLayer.get());
-    activeLayer->didBecomeActive();
+    pendingLayer->PushPropertiesTo(activeLayer.get());
+    activeLayer->DidBecomeActive();
     Mock::VerifyAndClearExpectations(&m_testData.m_mockCallback);
 
     // Test destructor.
     EXPECT_CALL(m_testData.m_mockCallback,
                 Release(m_testData.m_mailboxName1,
                         m_testData.m_syncPoint1)).Times(1);
     pendingLayer->setTextureMailbox(m_testData.m_mailbox1);
 }
 
 TEST_F(TextureLayerImplWithMailboxTest, testDestructorCallbackOnCreatedResource)
 {
     scoped_ptr<TextureLayerImpl> implLayer;
-    implLayer = TextureLayerImpl::create(m_hostImpl.activeTree(), 1, true);
+    implLayer = TextureLayerImpl::Create(m_hostImpl.activeTree(), 1, true);
     ASSERT_TRUE(implLayer);
 
     EXPECT_CALL(m_testData.m_mockCallback,
                 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->WillDraw(m_hostImpl.activeTree()->resource_provider());
+    implLayer->DidDraw(m_hostImpl.activeTree()->resource_provider());
     implLayer->setTextureMailbox(TextureMailbox());
 }
 
 TEST_F(TextureLayerImplWithMailboxTest, testCallbackOnInUseResource)
 {
     ResourceProvider *provider = m_hostImpl.activeTree()->resource_provider();
     ResourceProvider::ResourceId id =
         provider->CreateResourceFromTextureMailbox(m_testData.m_mailbox1);
     provider->AllocateForTesting(id);
 
     // Transfer some resources to the parent.
     ResourceProvider::ResourceIdArray resourceIdsToTransfer;
     resourceIdsToTransfer.push_back(id);
     TransferableResourceArray 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_mailboxName1, _)).Times(1);
     provider->ReceiveFromParent(list);
 }
 
 }  // namespace
 }  // namespace cc