Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(288)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/layer_unittest.cc

Issue 12774006: cc: Chromify Layer and LayerImpl classes. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: MoreAndroidCompilings Created 7 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/layer_tree_impl.cc ('k') | cc/nine_patch_layer.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/layer_unittest.cc
diff --git a/cc/layer_unittest.cc b/cc/layer_unittest.cc
index 2b1e418c4862f900c4a2fbfe984d2df81c766ccd..847288f08e7212b80bf98d98e3462b4067d5565d 100644
--- a/cc/layer_unittest.cc
+++ b/cc/layer_unittest.cc
@@ -26,15 +26,15 @@ using ::testing::StrictMock;
using ::testing::_;
#define EXPECT_SET_NEEDS_COMMIT(expect, codeToTest) do { \
- EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times((expect)); \
+ EXPECT_CALL(*layer_tree_host_, setNeedsCommit()).Times((expect)); \
codeToTest; \
- Mock::VerifyAndClearExpectations(m_layerTreeHost.get()); \
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
} while (0)
#define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, codeToTest) do { \
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times((expect)); \
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times((expect)); \
codeToTest; \
- Mock::VerifyAndClearExpectations(m_layerTreeHost.get()); \
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
} while (0)
@@ -72,14 +72,14 @@ public:
protected:
virtual void SetUp()
{
- m_layerTreeHost.reset(new StrictMock<MockLayerImplTreeHost>);
+ layer_tree_host_.reset(new StrictMock<MockLayerImplTreeHost>);
}
virtual void TearDown()
{
- Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AnyNumber());
- m_parent = NULL;
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get());
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(AnyNumber());
+ parent_ = NULL;
m_child1 = NULL;
m_child2 = NULL;
m_child3 = NULL;
@@ -87,19 +87,19 @@ protected:
m_grandChild2 = NULL;
m_grandChild3 = NULL;
- m_layerTreeHost->setRootLayer(0);
- m_layerTreeHost.reset();
+ layer_tree_host_->setRootLayer(0);
+ layer_tree_host_.reset();
}
void verifyTestTreeInitialState() const
{
- ASSERT_EQ(3U, m_parent->children().size());
- EXPECT_EQ(m_child1, m_parent->children()[0]);
- EXPECT_EQ(m_child2, m_parent->children()[1]);
- EXPECT_EQ(m_child3, m_parent->children()[2]);
- EXPECT_EQ(m_parent.get(), m_child1->parent());
- EXPECT_EQ(m_parent.get(), m_child2->parent());
- EXPECT_EQ(m_parent.get(), m_child3->parent());
+ ASSERT_EQ(3U, parent_->children().size());
+ EXPECT_EQ(m_child1, parent_->children()[0]);
+ EXPECT_EQ(m_child2, parent_->children()[1]);
+ EXPECT_EQ(m_child3, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), m_child1->parent());
+ EXPECT_EQ(parent_.get(), m_child2->parent());
+ EXPECT_EQ(parent_.get(), m_child3->parent());
ASSERT_EQ(2U, m_child1->children().size());
EXPECT_EQ(m_grandChild1, m_child1->children()[0]);
@@ -116,25 +116,25 @@ protected:
void createSimpleTestTree()
{
- m_parent = Layer::create();
- m_child1 = Layer::create();
- m_child2 = Layer::create();
- m_child3 = Layer::create();
- m_grandChild1 = Layer::create();
- m_grandChild2 = Layer::create();
- m_grandChild3 = Layer::create();
-
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AnyNumber());
- m_layerTreeHost->setRootLayer(m_parent);
-
- m_parent->addChild(m_child1);
- m_parent->addChild(m_child2);
- m_parent->addChild(m_child3);
- m_child1->addChild(m_grandChild1);
- m_child1->addChild(m_grandChild2);
- m_child2->addChild(m_grandChild3);
-
- Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
+ parent_ = Layer::Create();
+ m_child1 = Layer::Create();
+ m_child2 = Layer::Create();
+ m_child3 = Layer::Create();
+ m_grandChild1 = Layer::Create();
+ m_grandChild2 = Layer::Create();
+ m_grandChild3 = Layer::Create();
+
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(AnyNumber());
+ layer_tree_host_->setRootLayer(parent_);
+
+ parent_->AddChild(m_child1);
+ parent_->AddChild(m_child2);
+ parent_->AddChild(m_child3);
+ m_child1->AddChild(m_grandChild1);
+ m_child1->AddChild(m_grandChild2);
+ m_child2->AddChild(m_grandChild3);
+
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get());
verifyTestTreeInitialState();
}
@@ -142,8 +142,8 @@ protected:
FakeImplProxy m_proxy;
FakeLayerTreeHostImpl m_hostImpl;
- scoped_ptr<StrictMock<MockLayerImplTreeHost> > m_layerTreeHost;
- scoped_refptr<Layer> m_parent;
+ scoped_ptr<StrictMock<MockLayerImplTreeHost> > layer_tree_host_;
+ scoped_refptr<Layer> parent_;
scoped_refptr<Layer> m_child1;
scoped_refptr<Layer> m_child2;
scoped_refptr<Layer> m_child3;
@@ -154,80 +154,80 @@ protected:
TEST_F(LayerTest, basicCreateAndDestroy)
{
- scoped_refptr<Layer> testLayer = Layer::create();
+ scoped_refptr<Layer> testLayer = Layer::Create();
ASSERT_TRUE(testLayer);
- EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(0);
- testLayer->setLayerTreeHost(m_layerTreeHost.get());
+ EXPECT_CALL(*layer_tree_host_, setNeedsCommit()).Times(0);
+ testLayer->SetLayerTreeHost(layer_tree_host_.get());
}
TEST_F(LayerTest, addAndRemoveChild)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child = Layer::create();
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child = Layer::Create();
// Upon creation, layers should not have children or parent.
ASSERT_EQ(0U, parent->children().size());
EXPECT_FALSE(child->parent());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, m_layerTreeHost->setRootLayer(parent));
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->addChild(child));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->setRootLayer(parent));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->AddChild(child));
ASSERT_EQ(1U, parent->children().size());
EXPECT_EQ(child.get(), parent->children()[0]);
EXPECT_EQ(parent.get(), child->parent());
- EXPECT_EQ(parent.get(), child->rootLayer());
+ EXPECT_EQ(parent.get(), child->RootLayer());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), child->removeFromParent());
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), child->RemoveFromParent());
}
TEST_F(LayerTest, addSameChildTwice)
{
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AtLeast(1));
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(AtLeast(1));
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child = Layer::create();
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child = Layer::Create();
- m_layerTreeHost->setRootLayer(parent);
+ layer_tree_host_->setRootLayer(parent);
ASSERT_EQ(0u, parent->children().size());
- parent->addChild(child);
+ parent->AddChild(child);
ASSERT_EQ(1u, parent->children().size());
EXPECT_EQ(parent.get(), child->parent());
- parent->addChild(child);
+ parent->AddChild(child);
ASSERT_EQ(1u, parent->children().size());
EXPECT_EQ(parent.get(), child->parent());
}
TEST_F(LayerTest, insertChild)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child1 = Layer::create();
- scoped_refptr<Layer> child2 = Layer::create();
- scoped_refptr<Layer> child3 = Layer::create();
- scoped_refptr<Layer> child4 = Layer::create();
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child1 = Layer::Create();
+ scoped_refptr<Layer> child2 = Layer::Create();
+ scoped_refptr<Layer> child3 = Layer::Create();
+ scoped_refptr<Layer> child4 = Layer::Create();
- parent->setLayerTreeHost(m_layerTreeHost.get());
+ parent->SetLayerTreeHost(layer_tree_host_.get());
ASSERT_EQ(0U, parent->children().size());
// Case 1: inserting to empty list.
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child3, 0));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child3, 0));
ASSERT_EQ(1U, parent->children().size());
EXPECT_EQ(child3, parent->children()[0]);
EXPECT_EQ(parent.get(), child3->parent());
// Case 2: inserting to beginning of list
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child1, 0));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
ASSERT_EQ(2U, parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
EXPECT_EQ(child3, parent->children()[1]);
EXPECT_EQ(parent.get(), child1->parent());
// Case 3: inserting to middle of list
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child2, 1));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
ASSERT_EQ(3U, parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
EXPECT_EQ(child2, parent->children()[1]);
@@ -235,7 +235,7 @@ TEST_F(LayerTest, insertChild)
EXPECT_EQ(parent.get(), child2->parent());
// Case 4: inserting to end of list
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child4, 3));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child4, 3));
ASSERT_EQ(4U, parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
@@ -244,25 +244,25 @@ TEST_F(LayerTest, insertChild)
EXPECT_EQ(child4, parent->children()[3]);
EXPECT_EQ(parent.get(), child4->parent());
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AtLeast(1));
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(AtLeast(1));
}
TEST_F(LayerTest, insertChildPastEndOfList)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child1 = Layer::create();
- scoped_refptr<Layer> child2 = Layer::create();
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child1 = Layer::Create();
+ scoped_refptr<Layer> child2 = Layer::Create();
ASSERT_EQ(0U, parent->children().size());
// insert to an out-of-bounds index
- parent->insertChild(child1, 53);
+ parent->InsertChild(child1, 53);
ASSERT_EQ(1U, parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
// insert another child to out-of-bounds, when list is not already empty.
- parent->insertChild(child2, 2459);
+ parent->InsertChild(child2, 2459);
ASSERT_EQ(2U, parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
@@ -271,51 +271,51 @@ TEST_F(LayerTest, insertChildPastEndOfList)
TEST_F(LayerTest, insertSameChildTwice)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child1 = Layer::create();
- scoped_refptr<Layer> child2 = Layer::create();
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child1 = Layer::Create();
+ scoped_refptr<Layer> child2 = Layer::Create();
- parent->setLayerTreeHost(m_layerTreeHost.get());
+ parent->SetLayerTreeHost(layer_tree_host_.get());
ASSERT_EQ(0U, parent->children().size());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child1, 0));
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child2, 1));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
ASSERT_EQ(2U, parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
EXPECT_EQ(child2, parent->children()[1]);
// Inserting the same child again should cause the child to be removed and re-inserted at the new location.
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent->insertChild(child1, 1));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent->InsertChild(child1, 1));
// child1 should now be at the end of the list.
ASSERT_EQ(2U, parent->children().size());
EXPECT_EQ(child2, parent->children()[0]);
EXPECT_EQ(child1, parent->children()[1]);
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AtLeast(1));
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(AtLeast(1));
}
TEST_F(LayerTest, replaceChildWithNewChild)
{
createSimpleTestTree();
- scoped_refptr<Layer> child4 = Layer::create();
+ scoped_refptr<Layer> child4 = Layer::Create();
EXPECT_FALSE(child4->parent());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), m_parent->replaceChild(m_child2.get(), child4));
- EXPECT_FALSE(m_parent->needsDisplayForTesting());
- EXPECT_FALSE(m_child1->needsDisplayForTesting());
- EXPECT_FALSE(m_child2->needsDisplayForTesting());
- EXPECT_FALSE(m_child3->needsDisplayForTesting());
- EXPECT_FALSE(child4->needsDisplayForTesting());
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent_->ReplaceChild(m_child2.get(), child4));
+ EXPECT_FALSE(parent_->NeedsDisplayForTesting());
+ EXPECT_FALSE(m_child1->NeedsDisplayForTesting());
+ EXPECT_FALSE(m_child2->NeedsDisplayForTesting());
+ EXPECT_FALSE(m_child3->NeedsDisplayForTesting());
+ EXPECT_FALSE(child4->NeedsDisplayForTesting());
- ASSERT_EQ(static_cast<size_t>(3), m_parent->children().size());
- EXPECT_EQ(m_child1, m_parent->children()[0]);
- EXPECT_EQ(child4, m_parent->children()[1]);
- EXPECT_EQ(m_child3, m_parent->children()[2]);
- EXPECT_EQ(m_parent.get(), child4->parent());
+ ASSERT_EQ(static_cast<size_t>(3), parent_->children().size());
+ EXPECT_EQ(m_child1, parent_->children()[0]);
+ EXPECT_EQ(child4, parent_->children()[1]);
+ EXPECT_EQ(m_child3, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), child4->parent());
EXPECT_FALSE(m_child2->parent());
}
@@ -323,25 +323,25 @@ TEST_F(LayerTest, replaceChildWithNewChild)
TEST_F(LayerTest, replaceChildWithNewChildAutomaticRasterScale)
{
createSimpleTestTree();
- scoped_refptr<Layer> child4 = Layer::create();
- EXPECT_SET_NEEDS_COMMIT(1, m_child1->setAutomaticallyComputeRasterScale(true));
- EXPECT_SET_NEEDS_COMMIT(1, m_child2->setAutomaticallyComputeRasterScale(true));
- EXPECT_SET_NEEDS_COMMIT(1, m_child3->setAutomaticallyComputeRasterScale(true));
+ scoped_refptr<Layer> child4 = Layer::Create();
+ EXPECT_SET_NEEDS_COMMIT(1, m_child1->SetAutomaticallyComputeRasterScale(true));
+ EXPECT_SET_NEEDS_COMMIT(1, m_child2->SetAutomaticallyComputeRasterScale(true));
+ EXPECT_SET_NEEDS_COMMIT(1, m_child3->SetAutomaticallyComputeRasterScale(true));
EXPECT_FALSE(child4->parent());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), m_parent->replaceChild(m_child2.get(), child4));
- EXPECT_FALSE(m_parent->needsDisplayForTesting());
- EXPECT_FALSE(m_child1->needsDisplayForTesting());
- EXPECT_FALSE(m_child2->needsDisplayForTesting());
- EXPECT_FALSE(m_child3->needsDisplayForTesting());
- EXPECT_FALSE(child4->needsDisplayForTesting());
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent_->ReplaceChild(m_child2.get(), child4));
+ EXPECT_FALSE(parent_->NeedsDisplayForTesting());
+ EXPECT_FALSE(m_child1->NeedsDisplayForTesting());
+ EXPECT_FALSE(m_child2->NeedsDisplayForTesting());
+ EXPECT_FALSE(m_child3->NeedsDisplayForTesting());
+ EXPECT_FALSE(child4->NeedsDisplayForTesting());
- ASSERT_EQ(3U, m_parent->children().size());
- EXPECT_EQ(m_child1, m_parent->children()[0]);
- EXPECT_EQ(child4, m_parent->children()[1]);
- EXPECT_EQ(m_child3, m_parent->children()[2]);
- EXPECT_EQ(m_parent.get(), child4->parent());
+ ASSERT_EQ(3U, parent_->children().size());
+ EXPECT_EQ(m_child1, parent_->children()[0]);
+ EXPECT_EQ(child4, parent_->children()[1]);
+ EXPECT_EQ(m_child3, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), child4->parent());
EXPECT_FALSE(m_child2->parent());
}
@@ -351,20 +351,20 @@ TEST_F(LayerTest, replaceChildWithNewChildThatHasOtherParent)
createSimpleTestTree();
// create another simple tree with testLayer and child4.
- scoped_refptr<Layer> testLayer = Layer::create();
- scoped_refptr<Layer> child4 = Layer::create();
- testLayer->addChild(child4);
+ scoped_refptr<Layer> testLayer = Layer::Create();
+ scoped_refptr<Layer> child4 = Layer::Create();
+ testLayer->AddChild(child4);
ASSERT_EQ(1U, testLayer->children().size());
EXPECT_EQ(child4, testLayer->children()[0]);
EXPECT_EQ(testLayer.get(), child4->parent());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), m_parent->replaceChild(m_child2.get(), child4));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent_->ReplaceChild(m_child2.get(), child4));
- ASSERT_EQ(3U, m_parent->children().size());
- EXPECT_EQ(m_child1, m_parent->children()[0]);
- EXPECT_EQ(child4, m_parent->children()[1]);
- EXPECT_EQ(m_child3, m_parent->children()[2]);
- EXPECT_EQ(m_parent.get(), child4->parent());
+ ASSERT_EQ(3U, parent_->children().size());
+ EXPECT_EQ(m_child1, parent_->children()[0]);
+ EXPECT_EQ(child4, parent_->children()[1]);
+ EXPECT_EQ(m_child3, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), child4->parent());
// testLayer should no longer have child4,
// and child2 should no longer have a parent.
@@ -377,9 +377,9 @@ TEST_F(LayerTest, replaceChildWithSameChild)
createSimpleTestTree();
// setNeedsFullTreeSync / setNeedsCommit should not be called because its the same child
- EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(0);
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(0);
- m_parent->replaceChild(m_child2.get(), m_child2);
+ EXPECT_CALL(*layer_tree_host_, setNeedsCommit()).Times(0);
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(0);
+ parent_->ReplaceChild(m_child2.get(), m_child2);
verifyTestTreeInitialState();
}
@@ -388,9 +388,9 @@ TEST_F(LayerTest, removeAllChildren)
{
createSimpleTestTree();
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(3), m_parent->removeAllChildren());
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(3), parent_->RemoveAllChildren());
- ASSERT_EQ(0U, m_parent->children().size());
+ ASSERT_EQ(0U, parent_->children().size());
EXPECT_FALSE(m_child1->parent());
EXPECT_FALSE(m_child2->parent());
EXPECT_FALSE(m_child3->parent());
@@ -398,31 +398,31 @@ TEST_F(LayerTest, removeAllChildren)
TEST_F(LayerTest, setChildren)
{
- scoped_refptr<Layer> oldParent = Layer::create();
- scoped_refptr<Layer> newParent = Layer::create();
+ scoped_refptr<Layer> oldParent = Layer::Create();
+ scoped_refptr<Layer> newParent = Layer::Create();
- scoped_refptr<Layer> child1 = Layer::create();
- scoped_refptr<Layer> child2 = Layer::create();
+ scoped_refptr<Layer> child1 = Layer::Create();
+ scoped_refptr<Layer> child2 = Layer::Create();
std::vector<scoped_refptr<Layer> > newChildren;
newChildren.push_back(child1);
newChildren.push_back(child2);
// Set up and verify initial test conditions: child1 has a parent, child2 has no parent.
- oldParent->addChild(child1);
+ oldParent->AddChild(child1);
ASSERT_EQ(0U, newParent->children().size());
EXPECT_EQ(oldParent.get(), child1->parent());
EXPECT_FALSE(child2->parent());
- newParent->setLayerTreeHost(m_layerTreeHost.get());
+ newParent->SetLayerTreeHost(layer_tree_host_.get());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), newParent->setChildren(newChildren));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), newParent->SetChildren(newChildren));
ASSERT_EQ(2U, newParent->children().size());
EXPECT_EQ(newParent.get(), child1->parent());
EXPECT_EQ(newParent.get(), child2->parent());
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AtLeast(1));
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(AtLeast(1));
}
TEST_F(LayerTest, getRootLayerAfterTreeManipulations)
@@ -430,53 +430,53 @@ TEST_F(LayerTest, getRootLayerAfterTreeManipulations)
createSimpleTestTree();
// For this test we don't care about setNeedsFullTreeSync calls.
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AnyNumber());
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times(AnyNumber());
- scoped_refptr<Layer> child4 = Layer::create();
+ scoped_refptr<Layer> child4 = Layer::Create();
- EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child1->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
- EXPECT_EQ(child4.get(), child4->rootLayer());
- EXPECT_EQ(m_parent.get(), m_grandChild1->rootLayer());
- EXPECT_EQ(m_parent.get(), m_grandChild2->rootLayer());
- EXPECT_EQ(m_parent.get(), m_grandChild3->rootLayer());
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child1->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child2->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child3->RootLayer());
+ EXPECT_EQ(child4.get(), child4->RootLayer());
+ EXPECT_EQ(parent_.get(), m_grandChild1->RootLayer());
+ EXPECT_EQ(parent_.get(), m_grandChild2->RootLayer());
+ EXPECT_EQ(parent_.get(), m_grandChild3->RootLayer());
- m_child1->removeFromParent();
+ m_child1->RemoveFromParent();
// child1 and its children, grandChild1 and grandChild2 are now on a separate subtree.
- EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
- EXPECT_EQ(m_child1.get(), m_child1->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
- EXPECT_EQ(child4.get(), child4->rootLayer());
- EXPECT_EQ(m_child1.get(), m_grandChild1->rootLayer());
- EXPECT_EQ(m_child1.get(), m_grandChild2->rootLayer());
- EXPECT_EQ(m_parent.get(), m_grandChild3->rootLayer());
-
- m_grandChild3->addChild(child4);
-
- EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
- EXPECT_EQ(m_child1.get(), m_child1->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
- EXPECT_EQ(m_parent.get(), child4->rootLayer());
- EXPECT_EQ(m_child1.get(), m_grandChild1->rootLayer());
- EXPECT_EQ(m_child1.get(), m_grandChild2->rootLayer());
- EXPECT_EQ(m_parent.get(), m_grandChild3->rootLayer());
-
- m_child2->replaceChild(m_grandChild3.get(), m_child1);
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(m_child1.get(), m_child1->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child2->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child3->RootLayer());
+ EXPECT_EQ(child4.get(), child4->RootLayer());
+ EXPECT_EQ(m_child1.get(), m_grandChild1->RootLayer());
+ EXPECT_EQ(m_child1.get(), m_grandChild2->RootLayer());
+ EXPECT_EQ(parent_.get(), m_grandChild3->RootLayer());
+
+ m_grandChild3->AddChild(child4);
+
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(m_child1.get(), m_child1->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child2->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child3->RootLayer());
+ EXPECT_EQ(parent_.get(), child4->RootLayer());
+ EXPECT_EQ(m_child1.get(), m_grandChild1->RootLayer());
+ EXPECT_EQ(m_child1.get(), m_grandChild2->RootLayer());
+ EXPECT_EQ(parent_.get(), m_grandChild3->RootLayer());
+
+ m_child2->ReplaceChild(m_grandChild3.get(), m_child1);
// grandChild3 gets orphaned and the child1 subtree gets planted back into the tree under child2.
- EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child1->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
- EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
- EXPECT_EQ(m_grandChild3.get(), child4->rootLayer());
- EXPECT_EQ(m_parent.get(), m_grandChild1->rootLayer());
- EXPECT_EQ(m_parent.get(), m_grandChild2->rootLayer());
- EXPECT_EQ(m_grandChild3.get(), m_grandChild3->rootLayer());
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child1->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child2->RootLayer());
+ EXPECT_EQ(parent_.get(), m_child3->RootLayer());
+ EXPECT_EQ(m_grandChild3.get(), child4->RootLayer());
+ EXPECT_EQ(parent_.get(), m_grandChild1->RootLayer());
+ EXPECT_EQ(parent_.get(), m_grandChild2->RootLayer());
+ EXPECT_EQ(m_grandChild3.get(), m_grandChild3->RootLayer());
}
TEST_F(LayerTest, checkSetNeedsDisplayCausesCorrectBehavior)
@@ -485,9 +485,9 @@ TEST_F(LayerTest, checkSetNeedsDisplayCausesCorrectBehavior)
// 1. sets needsDisplay flag appropriately.
// 2. indirectly calls setNeedsCommit, exactly once for each call to setNeedsDisplay.
- scoped_refptr<Layer> testLayer = Layer::create();
- testLayer->setLayerTreeHost(m_layerTreeHost.get());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(true));
+ scoped_refptr<Layer> testLayer = Layer::Create();
+ testLayer->SetLayerTreeHost(layer_tree_host_.get());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetIsDrawable(true));
gfx::Size testBounds = gfx::Size(501, 508);
@@ -497,191 +497,191 @@ TEST_F(LayerTest, checkSetNeedsDisplayCausesCorrectBehavior)
gfx::RectF outOfBoundsDirtyRect = gfx::RectF(400, 405, 500, 502);
// Before anything, testLayer should not be dirty.
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
// This is just initialization, but setNeedsCommit behavior is verified anyway to avoid warnings.
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(testBounds));
- EXPECT_TRUE(testLayer->needsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetBounds(testBounds));
+ EXPECT_TRUE(testLayer->NeedsDisplayForTesting());
// The real test begins here.
- testLayer->resetNeedsDisplayForTesting();
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
+ testLayer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
// Case 1: Layer should accept dirty rects that go beyond its bounds.
- testLayer->resetNeedsDisplayForTesting();
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNeedsDisplayRect(outOfBoundsDirtyRect));
- EXPECT_TRUE(testLayer->needsDisplayForTesting());
- testLayer->resetNeedsDisplayForTesting();
-
- // Case 2: setNeedsDisplay() without the dirty rect arg.
- testLayer->resetNeedsDisplayForTesting();
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNeedsDisplay());
- EXPECT_TRUE(testLayer->needsDisplayForTesting());
- testLayer->resetNeedsDisplayForTesting();
-
- // Case 3: setNeedsDisplay() with a non-drawable layer
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(false));
- testLayer->resetNeedsDisplayForTesting();
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
- EXPECT_SET_NEEDS_COMMIT(0, testLayer->setNeedsDisplayRect(dirty1));
- EXPECT_TRUE(testLayer->needsDisplayForTesting());
+ testLayer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetNeedsDisplayRect(outOfBoundsDirtyRect));
+ EXPECT_TRUE(testLayer->NeedsDisplayForTesting());
+ testLayer->ResetNeedsDisplayForTesting();
+
+ // Case 2: SetNeedsDisplay() without the dirty rect arg.
+ testLayer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetNeedsDisplay());
+ EXPECT_TRUE(testLayer->NeedsDisplayForTesting());
+ testLayer->ResetNeedsDisplayForTesting();
+
+ // Case 3: SetNeedsDisplay() with a non-drawable layer
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetIsDrawable(false));
+ testLayer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(0, testLayer->SetNeedsDisplayRect(dirty1));
+ EXPECT_TRUE(testLayer->NeedsDisplayForTesting());
}
TEST_F(LayerTest, checkPropertyChangeCausesCorrectBehavior)
{
- scoped_refptr<Layer> testLayer = Layer::create();
- testLayer->setLayerTreeHost(m_layerTreeHost.get());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(true));
+ scoped_refptr<Layer> testLayer = Layer::Create();
+ testLayer->SetLayerTreeHost(layer_tree_host_.get());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetIsDrawable(true));
- scoped_refptr<Layer> dummyLayer1 = Layer::create(); // just a dummy layer for this test case.
- scoped_refptr<Layer> dummyLayer2 = Layer::create(); // just a dummy layer for this test case.
+ scoped_refptr<Layer> dummyLayer1 = Layer::Create(); // just a dummy layer for this test case.
+ scoped_refptr<Layer> dummyLayer2 = Layer::Create(); // just a dummy layer for this test case.
// sanity check of initial test condition
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
// Next, test properties that should call setNeedsCommit (but not setNeedsDisplay)
// All properties need to be set to new values in order for setNeedsCommit to be called.
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setAnchorPoint(gfx::PointF(1.23f, 4.56f)));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setAnchorPointZ(0.7f));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBackgroundColor(SK_ColorLTGRAY));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setMasksToBounds(true));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setOpacity(0.5));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setContentsOpaque(true));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setPosition(gfx::PointF(4, 9)));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setSublayerTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setScrollable(true));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setScrollOffset(gfx::Vector2d(10, 10)));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setShouldScrollOnMainThread(true));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNonFastScrollableRegion(gfx::Rect(1, 1, 2, 2)));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setHaveWheelEventHandlers(true));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setDoubleSided(false));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setDebugName("Test Layer"));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setDrawCheckerboardForMissingTiles(!testLayer->drawCheckerboardForMissingTiles()));
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setForceRenderSurface(true));
-
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, testLayer->setMaskLayer(dummyLayer1.get()));
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, testLayer->setReplicaLayer(dummyLayer2.get()));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetAnchorPoint(gfx::PointF(1.23f, 4.56f)));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetAnchorPointZ(0.7f));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetBackgroundColor(SK_ColorLTGRAY));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetMasksToBounds(true));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetOpacity(0.5));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetContentsOpaque(true));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetPosition(gfx::PointF(4, 9)));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetSublayerTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetScrollable(true));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetScrollOffset(gfx::Vector2d(10, 10)));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetShouldScrollOnMainThread(true));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetNonFastScrollableRegion(gfx::Rect(1, 1, 2, 2)));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetHaveWheelEventHandlers(true));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetDoubleSided(false));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetDebugName("Test Layer"));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetDrawCheckerboardForMissingTiles(!testLayer->DrawCheckerboardForMissingTiles()));
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetForceRenderSurface(true));
+
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, testLayer->SetMaskLayer(dummyLayer1.get()));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, testLayer->SetReplicaLayer(dummyLayer2.get()));
// The above tests should not have caused a change to the needsDisplay flag.
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
// As layers are removed from the tree, they will cause a tree sync.
- EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times((AnyNumber()));
+ EXPECT_CALL(*layer_tree_host_, setNeedsFullTreeSync()).Times((AnyNumber()));
}
TEST_F(LayerTest, setBoundsTriggersSetNeedsRedrawAfterGettingNonEmptyBounds)
{
- scoped_refptr<Layer> testLayer = Layer::create();
- testLayer->setLayerTreeHost(m_layerTreeHost.get());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(true));
+ scoped_refptr<Layer> testLayer = Layer::Create();
+ testLayer->SetLayerTreeHost(layer_tree_host_.get());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetIsDrawable(true));
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(gfx::Size(0, 10)));
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(gfx::Size(10, 10)));
- EXPECT_TRUE(testLayer->needsDisplayForTesting());
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetBounds(gfx::Size(0, 10)));
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetBounds(gfx::Size(10, 10)));
+ EXPECT_TRUE(testLayer->NeedsDisplayForTesting());
- testLayer->resetNeedsDisplayForTesting();
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
+ testLayer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
// Calling setBounds only invalidates on the first time.
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(gfx::Size(7, 10)));
- EXPECT_FALSE(testLayer->needsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetBounds(gfx::Size(7, 10)));
+ EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
}
TEST_F(LayerTest, verifyPushPropertiesAccumulatesUpdateRect)
{
- scoped_refptr<Layer> testLayer = Layer::create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::create(m_hostImpl.activeTree(), 1);
+ scoped_refptr<Layer> testLayer = Layer::Create();
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
- testLayer->setNeedsDisplayRect(gfx::RectF(gfx::PointF(), gfx::SizeF(5, 5)));
- testLayer->pushPropertiesTo(implLayer.get());
- EXPECT_FLOAT_RECT_EQ(gfx::RectF(gfx::PointF(), gfx::SizeF(5, 5)), implLayer->updateRect());
+ testLayer->SetNeedsDisplayRect(gfx::RectF(gfx::PointF(), gfx::SizeF(5, 5)));
+ testLayer->PushPropertiesTo(implLayer.get());
+ EXPECT_FLOAT_RECT_EQ(gfx::RectF(gfx::PointF(), gfx::SizeF(5, 5)), implLayer->update_rect());
// The LayerImpl's updateRect should be accumulated here, since we did not do anything to clear it.
- testLayer->setNeedsDisplayRect(gfx::RectF(gfx::PointF(10, 10), gfx::SizeF(5, 5)));
- testLayer->pushPropertiesTo(implLayer.get());
- EXPECT_FLOAT_RECT_EQ(gfx::RectF(gfx::PointF(), gfx::SizeF(15, 15)), implLayer->updateRect());
+ testLayer->SetNeedsDisplayRect(gfx::RectF(gfx::PointF(10, 10), gfx::SizeF(5, 5)));
+ testLayer->PushPropertiesTo(implLayer.get());
+ EXPECT_FLOAT_RECT_EQ(gfx::RectF(gfx::PointF(), gfx::SizeF(15, 15)), implLayer->update_rect());
// If we do clear the LayerImpl side, then the next updateRect should be fresh without accumulation.
- implLayer->resetAllChangeTrackingForSubtree();
- testLayer->setNeedsDisplayRect(gfx::RectF(gfx::PointF(10, 10), gfx::SizeF(5, 5)));
- testLayer->pushPropertiesTo(implLayer.get());
- EXPECT_FLOAT_RECT_EQ(gfx::RectF(gfx::PointF(10, 10), gfx::SizeF(5, 5)), implLayer->updateRect());
+ implLayer->ResetAllChangeTrackingForSubtree();
+ testLayer->SetNeedsDisplayRect(gfx::RectF(gfx::PointF(10, 10), gfx::SizeF(5, 5)));
+ testLayer->PushPropertiesTo(implLayer.get());
+ EXPECT_FLOAT_RECT_EQ(gfx::RectF(gfx::PointF(10, 10), gfx::SizeF(5, 5)), implLayer->update_rect());
}
TEST_F(LayerTest, verifyPushPropertiesCausesSurfacePropertyChangedForTransform)
{
- scoped_refptr<Layer> testLayer = Layer::create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::create(m_hostImpl.activeTree(), 1);
+ scoped_refptr<Layer> testLayer = Layer::Create();
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
gfx::Transform transform;
transform.Rotate(45.0);
- testLayer->setTransform(transform);
+ testLayer->SetTransform(transform);
- EXPECT_FALSE(implLayer->layerSurfacePropertyChanged());
+ EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
- testLayer->pushPropertiesTo(implLayer.get());
+ testLayer->PushPropertiesTo(implLayer.get());
- EXPECT_TRUE(implLayer->layerSurfacePropertyChanged());
+ EXPECT_TRUE(implLayer->LayerSurfacePropertyChanged());
}
TEST_F(LayerTest, verifyPushPropertiesCausesSurfacePropertyChangedForOpacity)
{
- scoped_refptr<Layer> testLayer = Layer::create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::create(m_hostImpl.activeTree(), 1);
+ scoped_refptr<Layer> testLayer = Layer::Create();
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
- testLayer->setOpacity(0.5);
+ testLayer->SetOpacity(0.5);
- EXPECT_FALSE(implLayer->layerSurfacePropertyChanged());
+ EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
- testLayer->pushPropertiesTo(implLayer.get());
+ testLayer->PushPropertiesTo(implLayer.get());
- EXPECT_TRUE(implLayer->layerSurfacePropertyChanged());
+ EXPECT_TRUE(implLayer->LayerSurfacePropertyChanged());
}
TEST_F(LayerTest, maskAndReplicaHasParent)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child = Layer::create();
- scoped_refptr<Layer> mask = Layer::create();
- scoped_refptr<Layer> replica = Layer::create();
- scoped_refptr<Layer> replicaMask = Layer::create();
- scoped_refptr<Layer> maskReplacement = Layer::create();
- scoped_refptr<Layer> replicaReplacement = Layer::create();
- scoped_refptr<Layer> replicaMaskReplacement = Layer::create();
-
- parent->addChild(child);
- child->setMaskLayer(mask.get());
- child->setReplicaLayer(replica.get());
- replica->setMaskLayer(replicaMask.get());
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child = Layer::Create();
+ scoped_refptr<Layer> mask = Layer::Create();
+ scoped_refptr<Layer> replica = Layer::Create();
+ scoped_refptr<Layer> replicaMask = Layer::Create();
+ scoped_refptr<Layer> maskReplacement = Layer::Create();
+ scoped_refptr<Layer> replicaReplacement = Layer::Create();
+ scoped_refptr<Layer> replicaMaskReplacement = Layer::Create();
+
+ parent->AddChild(child);
+ child->SetMaskLayer(mask.get());
+ child->SetReplicaLayer(replica.get());
+ replica->SetMaskLayer(replicaMask.get());
EXPECT_EQ(parent, child->parent());
EXPECT_EQ(child, mask->parent());
EXPECT_EQ(child, replica->parent());
EXPECT_EQ(replica, replicaMask->parent());
- replica->setMaskLayer(replicaMaskReplacement.get());
+ replica->SetMaskLayer(replicaMaskReplacement.get());
EXPECT_EQ(NULL, replicaMask->parent());
EXPECT_EQ(replica, replicaMaskReplacement->parent());
- child->setMaskLayer(maskReplacement.get());
+ child->SetMaskLayer(maskReplacement.get());
EXPECT_EQ(NULL, mask->parent());
EXPECT_EQ(child, maskReplacement->parent());
- child->setReplicaLayer(replicaReplacement.get());
+ child->SetReplicaLayer(replicaReplacement.get());
EXPECT_EQ(NULL, replica->parent());
EXPECT_EQ(child, replicaReplacement->parent());
- EXPECT_EQ(replica, replica->maskLayer()->parent());
+ EXPECT_EQ(replica, replica->mask_layer()->parent());
}
class FakeLayerImplTreeHost : public LayerTreeHost {
public:
- static scoped_ptr<FakeLayerImplTreeHost> create()
+ static scoped_ptr<FakeLayerImplTreeHost> Create()
{
scoped_ptr<FakeLayerImplTreeHost> host(new FakeLayerImplTreeHost(LayerTreeSettings()));
// The initialize call will fail, since our client doesn't provide a valid GraphicsContext3D, but it doesn't matter in the tests that use this fake so ignore the return value.
@@ -689,7 +689,7 @@ public:
return host.Pass();
}
- static scoped_ptr<FakeLayerImplTreeHost> create(LayerTreeSettings settings)
+ static scoped_ptr<FakeLayerImplTreeHost> Create(LayerTreeSettings settings)
{
scoped_ptr<FakeLayerImplTreeHost> host(new FakeLayerImplTreeHost(settings));
host->initialize(scoped_ptr<Thread>(NULL));
@@ -707,69 +707,69 @@ private:
void assertLayerTreeHostMatchesForSubtree(Layer* layer, LayerTreeHost* host)
{
- EXPECT_EQ(host, layer->layerTreeHost());
+ EXPECT_EQ(host, layer->layer_tree_host());
for (size_t i = 0; i < layer->children().size(); ++i)
assertLayerTreeHostMatchesForSubtree(layer->children()[i].get(), host);
- if (layer->maskLayer())
- assertLayerTreeHostMatchesForSubtree(layer->maskLayer(), host);
+ if (layer->mask_layer())
+ assertLayerTreeHostMatchesForSubtree(layer->mask_layer(), host);
- if (layer->replicaLayer())
- assertLayerTreeHostMatchesForSubtree(layer->replicaLayer(), host);
+ if (layer->replica_layer())
+ assertLayerTreeHostMatchesForSubtree(layer->replica_layer(), host);
}
TEST(LayerLayerTreeHostTest, enteringTree)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child = Layer::create();
- scoped_refptr<Layer> mask = Layer::create();
- scoped_refptr<Layer> replica = Layer::create();
- scoped_refptr<Layer> replicaMask = Layer::create();
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child = Layer::Create();
+ scoped_refptr<Layer> mask = Layer::Create();
+ scoped_refptr<Layer> replica = Layer::Create();
+ scoped_refptr<Layer> replicaMask = Layer::Create();
// Set up a detached tree of layers. The host pointer should be nil for these layers.
- parent->addChild(child);
- child->setMaskLayer(mask.get());
- child->setReplicaLayer(replica.get());
- replica->setMaskLayer(replicaMask.get());
+ parent->AddChild(child);
+ child->SetMaskLayer(mask.get());
+ child->SetReplicaLayer(replica.get());
+ replica->SetMaskLayer(replicaMask.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
- scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::Create());
// Setting the root layer should set the host pointer for all layers in the tree.
layerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
// Clearing the root layer should also clear out the host pointers for all layers in the tree.
- layerTreeHost->setRootLayer(0);
+ layerTreeHost->setRootLayer(NULL);
assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
}
TEST(LayerLayerTreeHostTest, addingLayerSubtree)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::Create());
layerTreeHost->setRootLayer(parent.get());
- EXPECT_EQ(parent->layerTreeHost(), layerTreeHost.get());
+ EXPECT_EQ(parent->layer_tree_host(), layerTreeHost.get());
// Adding a subtree to a layer already associated with a host should set the host pointer on all layers in that subtree.
- scoped_refptr<Layer> child = Layer::create();
- scoped_refptr<Layer> grandChild = Layer::create();
- child->addChild(grandChild);
+ scoped_refptr<Layer> child = Layer::Create();
+ scoped_refptr<Layer> grandChild = Layer::Create();
+ child->AddChild(grandChild);
// Masks, replicas, and replica masks should pick up the new host too.
- scoped_refptr<Layer> childMask = Layer::create();
- child->setMaskLayer(childMask.get());
- scoped_refptr<Layer> childReplica = Layer::create();
- child->setReplicaLayer(childReplica.get());
- scoped_refptr<Layer> childReplicaMask = Layer::create();
- childReplica->setMaskLayer(childReplicaMask.get());
-
- parent->addChild(child);
+ scoped_refptr<Layer> childMask = Layer::Create();
+ child->SetMaskLayer(childMask.get());
+ scoped_refptr<Layer> childReplica = Layer::Create();
+ child->SetReplicaLayer(childReplica.get());
+ scoped_refptr<Layer> childReplicaMask = Layer::Create();
+ childReplica->SetMaskLayer(childReplicaMask.get());
+
+ parent->AddChild(child);
assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
layerTreeHost->setRootLayer(0);
@@ -777,26 +777,26 @@ TEST(LayerLayerTreeHostTest, addingLayerSubtree)
TEST(LayerLayerTreeHostTest, changeHost)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> child = Layer::create();
- scoped_refptr<Layer> mask = Layer::create();
- scoped_refptr<Layer> replica = Layer::create();
- scoped_refptr<Layer> replicaMask = Layer::create();
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child = Layer::Create();
+ scoped_refptr<Layer> mask = Layer::Create();
+ scoped_refptr<Layer> replica = Layer::Create();
+ scoped_refptr<Layer> replicaMask = Layer::Create();
// Same setup as the previous test.
- parent->addChild(child);
- child->setMaskLayer(mask.get());
- child->setReplicaLayer(replica.get());
- replica->setMaskLayer(replicaMask.get());
+ parent->AddChild(child);
+ child->SetMaskLayer(mask.get());
+ child->SetReplicaLayer(replica.get());
+ replica->SetMaskLayer(replicaMask.get());
- scoped_ptr<FakeLayerImplTreeHost> firstLayerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_ptr<FakeLayerImplTreeHost> firstLayerTreeHost(FakeLayerImplTreeHost::Create());
firstLayerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), firstLayerTreeHost.get());
// Now re-root the tree to a new host (simulating what we do on a context lost event).
// This should update the host pointers for all layers in the tree.
- scoped_ptr<FakeLayerImplTreeHost> secondLayerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_ptr<FakeLayerImplTreeHost> secondLayerTreeHost(FakeLayerImplTreeHost::Create());
secondLayerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), secondLayerTreeHost.get());
@@ -806,31 +806,31 @@ TEST(LayerLayerTreeHostTest, changeHost)
TEST(LayerLayerTreeHostTest, changeHostInSubtree)
{
- scoped_refptr<Layer> firstParent = Layer::create();
- scoped_refptr<Layer> firstChild = Layer::create();
- scoped_refptr<Layer> secondParent = Layer::create();
- scoped_refptr<Layer> secondChild = Layer::create();
- scoped_refptr<Layer> secondGrandChild = Layer::create();
+ scoped_refptr<Layer> firstParent = Layer::Create();
+ scoped_refptr<Layer> firstChild = Layer::Create();
+ scoped_refptr<Layer> secondParent = Layer::Create();
+ scoped_refptr<Layer> secondChild = Layer::Create();
+ scoped_refptr<Layer> secondGrandChild = Layer::Create();
// First put all children under the first parent and set the first host.
- firstParent->addChild(firstChild);
- secondChild->addChild(secondGrandChild);
- firstParent->addChild(secondChild);
+ firstParent->AddChild(firstChild);
+ secondChild->AddChild(secondGrandChild);
+ firstParent->AddChild(secondChild);
- scoped_ptr<FakeLayerImplTreeHost> firstLayerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_ptr<FakeLayerImplTreeHost> firstLayerTreeHost(FakeLayerImplTreeHost::Create());
firstLayerTreeHost->setRootLayer(firstParent.get());
assertLayerTreeHostMatchesForSubtree(firstParent.get(), firstLayerTreeHost.get());
// Now reparent the subtree starting at secondChild to a layer in a different tree.
- scoped_ptr<FakeLayerImplTreeHost> secondLayerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_ptr<FakeLayerImplTreeHost> secondLayerTreeHost(FakeLayerImplTreeHost::Create());
secondLayerTreeHost->setRootLayer(secondParent.get());
- secondParent->addChild(secondChild);
+ secondParent->AddChild(secondChild);
// The moved layer and its children should point to the new host.
- EXPECT_EQ(secondLayerTreeHost.get(), secondChild->layerTreeHost());
- EXPECT_EQ(secondLayerTreeHost.get(), secondGrandChild->layerTreeHost());
+ EXPECT_EQ(secondLayerTreeHost.get(), secondChild->layer_tree_host());
+ EXPECT_EQ(secondLayerTreeHost.get(), secondGrandChild->layer_tree_host());
// Test over, cleanup time.
firstLayerTreeHost->setRootLayer(0);
@@ -839,33 +839,33 @@ TEST(LayerLayerTreeHostTest, changeHostInSubtree)
TEST(LayerLayerTreeHostTest, replaceMaskAndReplicaLayer)
{
- scoped_refptr<Layer> parent = Layer::create();
- scoped_refptr<Layer> mask = Layer::create();
- scoped_refptr<Layer> replica = Layer::create();
- scoped_refptr<Layer> maskChild = Layer::create();
- scoped_refptr<Layer> replicaChild = Layer::create();
- scoped_refptr<Layer> maskReplacement = Layer::create();
- scoped_refptr<Layer> replicaReplacement = Layer::create();
-
- parent->setMaskLayer(mask.get());
- parent->setReplicaLayer(replica.get());
- mask->addChild(maskChild);
- replica->addChild(replicaChild);
-
- scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> mask = Layer::Create();
+ scoped_refptr<Layer> replica = Layer::Create();
+ scoped_refptr<Layer> maskChild = Layer::Create();
+ scoped_refptr<Layer> replicaChild = Layer::Create();
+ scoped_refptr<Layer> maskReplacement = Layer::Create();
+ scoped_refptr<Layer> replicaReplacement = Layer::Create();
+
+ parent->SetMaskLayer(mask.get());
+ parent->SetReplicaLayer(replica.get());
+ mask->AddChild(maskChild);
+ replica->AddChild(replicaChild);
+
+ scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::Create());
layerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
// Replacing the mask should clear out the old mask's subtree's host pointers.
- parent->setMaskLayer(maskReplacement.get());
- EXPECT_EQ(0, mask->layerTreeHost());
- EXPECT_EQ(0, maskChild->layerTreeHost());
+ parent->SetMaskLayer(maskReplacement.get());
+ EXPECT_EQ(0, mask->layer_tree_host());
+ EXPECT_EQ(0, maskChild->layer_tree_host());
// Same for replacing a replica layer.
- parent->setReplicaLayer(replicaReplacement.get());
- EXPECT_EQ(0, replica->layerTreeHost());
- EXPECT_EQ(0, replicaChild->layerTreeHost());
+ parent->SetReplicaLayer(replicaReplacement.get());
+ EXPECT_EQ(0, replica->layer_tree_host());
+ EXPECT_EQ(0, replicaChild->layer_tree_host());
// Test over, cleanup time.
layerTreeHost->setRootLayer(0);
@@ -873,10 +873,10 @@ TEST(LayerLayerTreeHostTest, replaceMaskAndReplicaLayer)
TEST(LayerLayerTreeHostTest, destroyHostWithNonNullRootLayer)
{
- scoped_refptr<Layer> root = Layer::create();
- scoped_refptr<Layer> child = Layer::create();
- root->addChild(child);
- scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
+ scoped_refptr<Layer> root = Layer::Create();
+ scoped_refptr<Layer> child = Layer::Create();
+ root->AddChild(child);
+ scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::Create());
layerTreeHost->setRootLayer(root);
}
@@ -892,23 +892,23 @@ static bool addTestAnimation(Layer* layer)
TEST(LayerLayerTreeHostTest, shouldNotAddAnimationWithoutAnimationRegistrar)
{
- scoped_refptr<Layer> layer = Layer::create();
+ scoped_refptr<Layer> layer = Layer::Create();
// Case 1: without a LayerTreeHost and without an AnimationRegistrar, the
// animation should not be accepted.
EXPECT_FALSE(addTestAnimation(layer.get()));
scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
- layer->layerAnimationController()->SetAnimationRegistrar(registrar.get());
+ layer->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
// Case 2: with an AnimationRegistrar, the animation should be accepted.
EXPECT_TRUE(addTestAnimation(layer.get()));
LayerTreeSettings settings;
settings.acceleratedAnimationEnabled = false;
- scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create(settings));
+ scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::Create(settings));
layerTreeHost->setRootLayer(layer.get());
- layer->setLayerTreeHost(layerTreeHost.get());
+ layer->SetLayerTreeHost(layerTreeHost.get());
assertLayerTreeHostMatchesForSubtree(layer.get(), layerTreeHost.get());
// Case 3: with a LayerTreeHost where accelerated animation is disabled, the
« no previous file with comments | « cc/layer_tree_impl.cc ('k') | cc/nine_patch_layer.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698