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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/layers/layer_unittest.cc

Issue 12917014: cc: Chromify layer_unittest.cc (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: 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 | « no previous file | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/layers/layer_unittest.cc
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index 7b0dbcc134ec2a0623343039a1d0525313b5f6ee..41064840308acd09f52729acc61032f972b1f39a 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -26,951 +26,992 @@ using ::testing::Mock;
using ::testing::StrictMock;
using ::testing::_;
-#define EXPECT_SET_NEEDS_COMMIT(expect, codeToTest) do { \
- EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times((expect)); \
- codeToTest; \
- Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
- } while (0)
+#define EXPECT_SET_NEEDS_COMMIT(expect, codeToTest) do { \
+ EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times((expect)); \
+ codeToTest; \
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
+ } while (false)
-#define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, codeToTest) do { \
- EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((expect)); \
- codeToTest; \
- Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
- } while (0)
+#define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, codeToTest) do { \
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((expect)); \
+ codeToTest; \
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get()); \
+ } while (false)
namespace cc {
namespace {
-class MockLayerImplTreeHost : public LayerTreeHost {
-public:
- MockLayerImplTreeHost()
- : LayerTreeHost(&m_fakeClient, LayerTreeSettings())
- {
- Initialize(scoped_ptr<Thread>(NULL));
- }
+class MockLayerTreeHost : public LayerTreeHost {
+ public:
+ MockLayerTreeHost()
+ : LayerTreeHost(&fake_client_, LayerTreeSettings()) {
+ Initialize(scoped_ptr<Thread>(NULL));
+ }
- MOCK_METHOD0(SetNeedsCommit, void());
- MOCK_METHOD0(SetNeedsFullTreeSync, void());
+ MOCK_METHOD0(SetNeedsCommit, void());
+ MOCK_METHOD0(SetNeedsFullTreeSync, void());
-private:
- FakeLayerImplTreeHostClient m_fakeClient;
+ private:
+ FakeLayerImplTreeHostClient fake_client_;
};
class MockLayerPainter : public LayerPainter {
-public:
- virtual void Paint(SkCanvas* canvas, gfx::Rect content_rect, gfx::RectF* opaque) OVERRIDE { }
+ public:
+ virtual void Paint(SkCanvas* canvas,
+ gfx::Rect content_rect,
+ gfx::RectF* opaque) OVERRIDE {}
};
class LayerTest : public testing::Test {
-public:
- LayerTest()
- : m_hostImpl(&m_proxy)
- {
- }
-
-protected:
- virtual void SetUp()
- {
- layer_tree_host_.reset(new StrictMock<MockLayerImplTreeHost>);
- }
-
- virtual void TearDown()
- {
- 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;
- m_grandChild1 = NULL;
- m_grandChild2 = NULL;
- m_grandChild3 = NULL;
-
- layer_tree_host_->SetRootLayer(NULL);
- layer_tree_host_.reset();
- }
-
- void verifyTestTreeInitialState() const
- {
- 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]);
- EXPECT_EQ(m_grandChild2, m_child1->children()[1]);
- EXPECT_EQ(m_child1.get(), m_grandChild1->parent());
- EXPECT_EQ(m_child1.get(), m_grandChild2->parent());
-
- ASSERT_EQ(1U, m_child2->children().size());
- EXPECT_EQ(m_grandChild3, m_child2->children()[0]);
- EXPECT_EQ(m_child2.get(), m_grandChild3->parent());
-
- ASSERT_EQ(0U, m_child3->children().size());
- }
-
- void createSimpleTestTree()
- {
- 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();
- }
-
- FakeImplProxy m_proxy;
- FakeLayerTreeHostImpl m_hostImpl;
-
- 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;
- scoped_refptr<Layer> m_grandChild1;
- scoped_refptr<Layer> m_grandChild2;
- scoped_refptr<Layer> m_grandChild3;
+ public:
+ LayerTest()
+ : host_impl_(&proxy_) {}
+
+ protected:
+ virtual void SetUp() OVERRIDE {
+ layer_tree_host_.reset(new StrictMock<MockLayerTreeHost>);
+ }
+
+ virtual void TearDown() OVERRIDE {
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get());
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
+ parent_ = NULL;
+ child1_ = NULL;
+ child2_ = NULL;
+ child3_ = NULL;
+ grand_child1_ = NULL;
+ grand_child2_ = NULL;
+ grand_child3_ = NULL;
+
+ layer_tree_host_->SetRootLayer(NULL);
+ layer_tree_host_.reset();
+ }
+
+ void VerifyTestTreeInitialState() const {
+ ASSERT_EQ(3U, parent_->children().size());
+ EXPECT_EQ(child1_, parent_->children()[0]);
+ EXPECT_EQ(child2_, parent_->children()[1]);
+ EXPECT_EQ(child3_, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), child1_->parent());
+ EXPECT_EQ(parent_.get(), child2_->parent());
+ EXPECT_EQ(parent_.get(), child3_->parent());
+
+ ASSERT_EQ(2U, child1_->children().size());
+ EXPECT_EQ(grand_child1_, child1_->children()[0]);
+ EXPECT_EQ(grand_child2_, child1_->children()[1]);
+ EXPECT_EQ(child1_.get(), grand_child1_->parent());
+ EXPECT_EQ(child1_.get(), grand_child2_->parent());
+
+ ASSERT_EQ(1U, child2_->children().size());
+ EXPECT_EQ(grand_child3_, child2_->children()[0]);
+ EXPECT_EQ(child2_.get(), grand_child3_->parent());
+
+ ASSERT_EQ(0U, child3_->children().size());
+ }
+
+ void CreateSimpleTestTree() {
+ parent_ = Layer::Create();
+ child1_ = Layer::Create();
+ child2_ = Layer::Create();
+ child3_ = Layer::Create();
+ grand_child1_ = Layer::Create();
+ grand_child2_ = Layer::Create();
+ grand_child3_ = Layer::Create();
+
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
+ layer_tree_host_->SetRootLayer(parent_);
+
+ parent_->AddChild(child1_);
+ parent_->AddChild(child2_);
+ parent_->AddChild(child3_);
+ child1_->AddChild(grand_child1_);
+ child1_->AddChild(grand_child2_);
+ child2_->AddChild(grand_child3_);
+
+ Mock::VerifyAndClearExpectations(layer_tree_host_.get());
+
+ VerifyTestTreeInitialState();
+ }
+
+ FakeImplProxy proxy_;
+ FakeLayerTreeHostImpl host_impl_;
+
+ scoped_ptr<StrictMock<MockLayerTreeHost> > layer_tree_host_;
+ scoped_refptr<Layer> parent_;
+ scoped_refptr<Layer> child1_;
+ scoped_refptr<Layer> child2_;
+ scoped_refptr<Layer> child3_;
+ scoped_refptr<Layer> grand_child1_;
+ scoped_refptr<Layer> grand_child2_;
+ scoped_refptr<Layer> grand_child3_;
};
-TEST_F(LayerTest, basicCreateAndDestroy)
-{
- scoped_refptr<Layer> testLayer = Layer::Create();
- ASSERT_TRUE(testLayer);
+TEST_F(LayerTest, BasicCreateAndDestroy) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ ASSERT_TRUE(test_layer);
- EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
- testLayer->SetLayerTreeHost(layer_tree_host_.get());
+ EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
+ test_layer->SetLayerTreeHost(layer_tree_host_.get());
}
-TEST_F(LayerTest, addAndRemoveChild)
-{
- scoped_refptr<Layer> parent = Layer::Create();
- scoped_refptr<Layer> child = Layer::Create();
+TEST_F(LayerTest, AddAndRemoveChild) {
+ 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());
+ // 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, layer_tree_host_->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());
+ 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_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(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
+TEST_F(LayerTest, AddSameChildTwice) {
+ 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();
- layer_tree_host_->SetRootLayer(parent);
+ layer_tree_host_->SetRootLayer(parent);
- ASSERT_EQ(0u, parent->children().size());
+ ASSERT_EQ(0u, parent->children().size());
- parent->AddChild(child);
- ASSERT_EQ(1u, parent->children().size());
- EXPECT_EQ(parent.get(), child->parent());
+ parent->AddChild(child);
+ ASSERT_EQ(1u, parent->children().size());
+ EXPECT_EQ(parent.get(), child->parent());
- parent->AddChild(child);
- ASSERT_EQ(1u, parent->children().size());
- EXPECT_EQ(parent.get(), child->parent());
+ 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();
-
- 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));
- 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));
- 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));
- ASSERT_EQ(3U, parent->children().size());
- EXPECT_EQ(child1, parent->children()[0]);
- EXPECT_EQ(child2, parent->children()[1]);
- EXPECT_EQ(child3, parent->children()[2]);
- EXPECT_EQ(parent.get(), child2->parent());
-
- // Case 4: inserting to end of list
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child4, 3));
-
- ASSERT_EQ(4U, parent->children().size());
- EXPECT_EQ(child1, parent->children()[0]);
- EXPECT_EQ(child2, parent->children()[1]);
- EXPECT_EQ(child3, parent->children()[2]);
- EXPECT_EQ(child4, parent->children()[3]);
- EXPECT_EQ(parent.get(), child4->parent());
-
- EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
+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();
+
+ 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));
+ 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));
+ 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));
+ ASSERT_EQ(3U, parent->children().size());
+ EXPECT_EQ(child1, parent->children()[0]);
+ EXPECT_EQ(child2, parent->children()[1]);
+ EXPECT_EQ(child3, parent->children()[2]);
+ EXPECT_EQ(parent.get(), child2->parent());
+
+ // Case 4: inserting to end of list
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child4, 3));
+
+ ASSERT_EQ(4U, parent->children().size());
+ EXPECT_EQ(child1, parent->children()[0]);
+ EXPECT_EQ(child2, parent->children()[1]);
+ EXPECT_EQ(child3, parent->children()[2]);
+ EXPECT_EQ(child4, parent->children()[3]);
+ EXPECT_EQ(parent.get(), child4->parent());
+
+ 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();
+TEST_F(LayerTest, InsertChildPastEndOfList) {
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child1 = Layer::Create();
+ scoped_refptr<Layer> child2 = Layer::Create();
- ASSERT_EQ(0U, parent->children().size());
+ ASSERT_EQ(0U, parent->children().size());
- // insert to an out-of-bounds index
- parent->InsertChild(child1, 53);
+ // insert to an out-of-bounds index
+ parent->InsertChild(child1, 53);
- ASSERT_EQ(1U, parent->children().size());
- EXPECT_EQ(child1, parent->children()[0]);
+ 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);
+ // insert another child to out-of-bounds, when list is not already empty.
+ parent->InsertChild(child2, 2459);
- ASSERT_EQ(2U, parent->children().size());
- EXPECT_EQ(child1, parent->children()[0]);
- EXPECT_EQ(child2, parent->children()[1]);
+ ASSERT_EQ(2U, parent->children().size());
+ EXPECT_EQ(child1, parent->children()[0]);
+ EXPECT_EQ(child2, parent->children()[1]);
}
-TEST_F(LayerTest, insertSameChildTwice)
-{
- scoped_refptr<Layer> parent = Layer::Create();
- scoped_refptr<Layer> child1 = Layer::Create();
- scoped_refptr<Layer> child2 = Layer::Create();
+TEST_F(LayerTest, InsertSameChildTwice) {
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> child1 = Layer::Create();
+ scoped_refptr<Layer> child2 = Layer::Create();
- parent->SetLayerTreeHost(layer_tree_host_.get());
+ parent->SetLayerTreeHost(layer_tree_host_.get());
- ASSERT_EQ(0U, parent->children().size());
+ 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]);
+ 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));
+ // 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));
- // 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]);
+ // 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(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
}
-TEST_F(LayerTest, replaceChildWithNewChild)
-{
- createSimpleTestTree();
- scoped_refptr<Layer> child4 = Layer::Create();
+TEST_F(LayerTest, ReplaceChildWithNewChild) {
+ CreateSimpleTestTree();
+ scoped_refptr<Layer> child4 = Layer::Create();
- EXPECT_FALSE(child4->parent());
+ EXPECT_FALSE(child4->parent());
- 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());
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(
+ AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
+ EXPECT_FALSE(parent_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child1_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child2_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child3_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child4->NeedsDisplayForTesting());
- 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());
+ ASSERT_EQ(static_cast<size_t>(3), parent_->children().size());
+ EXPECT_EQ(child1_, parent_->children()[0]);
+ EXPECT_EQ(child4, parent_->children()[1]);
+ EXPECT_EQ(child3_, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), child4->parent());
- EXPECT_FALSE(m_child2->parent());
+ EXPECT_FALSE(child2_->parent());
}
-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));
-
- EXPECT_FALSE(child4->parent());
-
- 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, 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());
+TEST_F(LayerTest, ReplaceChildWithNewChildAutomaticRasterScale) {
+ CreateSimpleTestTree();
+ scoped_refptr<Layer> child4 = Layer::Create();
+ EXPECT_SET_NEEDS_COMMIT(1, child1_->SetAutomaticallyComputeRasterScale(true));
+ EXPECT_SET_NEEDS_COMMIT(1, child2_->SetAutomaticallyComputeRasterScale(true));
+ EXPECT_SET_NEEDS_COMMIT(1, child3_->SetAutomaticallyComputeRasterScale(true));
+
+ EXPECT_FALSE(child4->parent());
+
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(
+ AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
+ EXPECT_FALSE(parent_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child1_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child2_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child3_->NeedsDisplayForTesting());
+ EXPECT_FALSE(child4->NeedsDisplayForTesting());
+
+ ASSERT_EQ(3U, parent_->children().size());
+ EXPECT_EQ(child1_, parent_->children()[0]);
+ EXPECT_EQ(child4, parent_->children()[1]);
+ EXPECT_EQ(child3_, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), child4->parent());
+
+ EXPECT_FALSE(child2_->parent());
}
-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);
- 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), parent_->ReplaceChild(m_child2.get(), child4));
-
- 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.
- ASSERT_EQ(0U, testLayer->children().size());
- EXPECT_FALSE(m_child2->parent());
+TEST_F(LayerTest, ReplaceChildWithNewChildThatHasOtherParent) {
+ CreateSimpleTestTree();
+
+ // create another simple tree with test_layer and child4.
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ scoped_refptr<Layer> child4 = Layer::Create();
+ test_layer->AddChild(child4);
+ ASSERT_EQ(1U, test_layer->children().size());
+ EXPECT_EQ(child4, test_layer->children()[0]);
+ EXPECT_EQ(test_layer.get(), child4->parent());
+
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(
+ AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
+
+ ASSERT_EQ(3U, parent_->children().size());
+ EXPECT_EQ(child1_, parent_->children()[0]);
+ EXPECT_EQ(child4, parent_->children()[1]);
+ EXPECT_EQ(child3_, parent_->children()[2]);
+ EXPECT_EQ(parent_.get(), child4->parent());
+
+ // test_layer should no longer have child4,
+ // and child2 should no longer have a parent.
+ ASSERT_EQ(0U, test_layer->children().size());
+ EXPECT_FALSE(child2_->parent());
}
-TEST_F(LayerTest, replaceChildWithSameChild)
-{
- createSimpleTestTree();
+TEST_F(LayerTest, ReplaceChildWithSameChild) {
+ CreateSimpleTestTree();
- // SetNeedsFullTreeSync / SetNeedsCommit should not be called because its the same child
- EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
- EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(0);
- parent_->ReplaceChild(m_child2.get(), m_child2);
+ // SetNeedsFullTreeSync / SetNeedsCommit should not be called because its the
+ // same child.
+ EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(0);
+ parent_->ReplaceChild(child2_.get(), child2_);
- verifyTestTreeInitialState();
+ VerifyTestTreeInitialState();
}
-TEST_F(LayerTest, removeAllChildren)
-{
- createSimpleTestTree();
+TEST_F(LayerTest, RemoveAllChildren) {
+ CreateSimpleTestTree();
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(3), parent_->RemoveAllChildren());
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(3), parent_->RemoveAllChildren());
- ASSERT_EQ(0U, parent_->children().size());
- EXPECT_FALSE(m_child1->parent());
- EXPECT_FALSE(m_child2->parent());
- EXPECT_FALSE(m_child3->parent());
+ ASSERT_EQ(0U, parent_->children().size());
+ EXPECT_FALSE(child1_->parent());
+ EXPECT_FALSE(child2_->parent());
+ EXPECT_FALSE(child3_->parent());
}
-TEST_F(LayerTest, setChildren)
-{
- scoped_refptr<Layer> oldParent = Layer::Create();
- scoped_refptr<Layer> newParent = Layer::Create();
+TEST_F(LayerTest, SetChildren) {
+ scoped_refptr<Layer> old_parent = Layer::Create();
+ scoped_refptr<Layer> new_parent = 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);
+ 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);
- ASSERT_EQ(0U, newParent->children().size());
- EXPECT_EQ(oldParent.get(), child1->parent());
- EXPECT_FALSE(child2->parent());
+ // Set up and verify initial test conditions: child1 has a parent, child2 has
+ // no parent.
+ old_parent->AddChild(child1);
+ ASSERT_EQ(0U, new_parent->children().size());
+ EXPECT_EQ(old_parent.get(), child1->parent());
+ EXPECT_FALSE(child2->parent());
- newParent->SetLayerTreeHost(layer_tree_host_.get());
+ new_parent->SetLayerTreeHost(layer_tree_host_.get());
- EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), newParent->SetChildren(newChildren));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(
+ AtLeast(1), new_parent->SetChildren(newChildren));
- ASSERT_EQ(2U, newParent->children().size());
- EXPECT_EQ(newParent.get(), child1->parent());
- EXPECT_EQ(newParent.get(), child2->parent());
+ ASSERT_EQ(2U, new_parent->children().size());
+ EXPECT_EQ(new_parent.get(), child1->parent());
+ EXPECT_EQ(new_parent.get(), child2->parent());
- EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
}
-TEST_F(LayerTest, getRootLayerAfterTreeManipulations)
-{
- createSimpleTestTree();
-
- // For this test we don't care about SetNeedsFullTreeSync calls.
- EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
-
- scoped_refptr<Layer> child4 = Layer::Create();
-
- 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();
-
- // child1 and its children, grandChild1 and grandChild2 are now on a separate subtree.
- 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(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, GetRootLayerAfterTreeManipulations) {
+ CreateSimpleTestTree();
+
+ // For this test we don't care about SetNeedsFullTreeSync calls.
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
+
+ scoped_refptr<Layer> child4 = Layer::Create();
+
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(parent_.get(), child1_->RootLayer());
+ EXPECT_EQ(parent_.get(), child2_->RootLayer());
+ EXPECT_EQ(parent_.get(), child3_->RootLayer());
+ EXPECT_EQ(child4.get(), child4->RootLayer());
+ EXPECT_EQ(parent_.get(), grand_child1_->RootLayer());
+ EXPECT_EQ(parent_.get(), grand_child2_->RootLayer());
+ EXPECT_EQ(parent_.get(), grand_child3_->RootLayer());
+
+ child1_->RemoveFromParent();
+
+ // |child1| and its children, grand_child1 and grand_child2 are now on a
+ // separate subtree.
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(child1_.get(), child1_->RootLayer());
+ EXPECT_EQ(parent_.get(), child2_->RootLayer());
+ EXPECT_EQ(parent_.get(), child3_->RootLayer());
+ EXPECT_EQ(child4.get(), child4->RootLayer());
+ EXPECT_EQ(child1_.get(), grand_child1_->RootLayer());
+ EXPECT_EQ(child1_.get(), grand_child2_->RootLayer());
+ EXPECT_EQ(parent_.get(), grand_child3_->RootLayer());
+
+ grand_child3_->AddChild(child4);
+
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(child1_.get(), child1_->RootLayer());
+ EXPECT_EQ(parent_.get(), child2_->RootLayer());
+ EXPECT_EQ(parent_.get(), child3_->RootLayer());
+ EXPECT_EQ(parent_.get(), child4->RootLayer());
+ EXPECT_EQ(child1_.get(), grand_child1_->RootLayer());
+ EXPECT_EQ(child1_.get(), grand_child2_->RootLayer());
+ EXPECT_EQ(parent_.get(), grand_child3_->RootLayer());
+
+ child2_->ReplaceChild(grand_child3_.get(), child1_);
+
+ // |grand_child3| gets orphaned and the child1 subtree gets planted back into
+ // the tree under child2.
+ EXPECT_EQ(parent_.get(), parent_->RootLayer());
+ EXPECT_EQ(parent_.get(), child1_->RootLayer());
+ EXPECT_EQ(parent_.get(), child2_->RootLayer());
+ EXPECT_EQ(parent_.get(), child3_->RootLayer());
+ EXPECT_EQ(grand_child3_.get(), child4->RootLayer());
+ EXPECT_EQ(parent_.get(), grand_child1_->RootLayer());
+ EXPECT_EQ(parent_.get(), grand_child2_->RootLayer());
+ EXPECT_EQ(grand_child3_.get(), grand_child3_->RootLayer());
}
-TEST_F(LayerTest, checkSetNeedsDisplayCausesCorrectBehavior)
-{
- // The semantics for setNeedsDisplay which are tested here:
- // 1. sets needsDisplay flag appropriately.
- // 2. indirectly calls SetNeedsCommit, exactly once for each call to setNeedsDisplay.
-
- 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);
-
- gfx::RectF dirty1 = gfx::RectF(10, 15, 1, 2);
- gfx::RectF dirty2 = gfx::RectF(20, 25, 3, 4);
- gfx::RectF emptyDirtyRect = gfx::RectF(40, 45, 0, 0);
- gfx::RectF outOfBoundsDirtyRect = gfx::RectF(400, 405, 500, 502);
-
- // Before anything, testLayer should not be dirty.
- 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());
-
- // The real test begins here.
- 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());
+TEST_F(LayerTest, CheckSetNeedsDisplayCausesCorrectBehavior) {
+ // The semantics for setNeedsDisplay which are tested here:
+ // 1. sets NeedsDisplay flag appropriately.
+ // 2. indirectly calls SetNeedsCommit, exactly once for each call to
+ // SetNeedsDisplay.
+
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ test_layer->SetLayerTreeHost(layer_tree_host_.get());
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(true));
+
+ gfx::Size test_bounds = gfx::Size(501, 508);
+
+ gfx::RectF dirty1 = gfx::RectF(10.f, 15.f, 1.f, 2.f);
+ gfx::RectF dirty2 = gfx::RectF(20.f, 25.f, 3.f, 4.f);
+ gfx::RectF empty_dirty_rect = gfx::RectF(40.f, 45.f, 0.f, 0.f);
+ gfx::RectF out_of_bounds_dirty_rect = gfx::RectF(400.f, 405.f, 500.f, 502.f);
+
+ // Before anything, test_layer should not be dirty.
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
+
+ // This is just initialization, but SetNeedsCommit behavior is verified anyway
+ // to avoid warnings.
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBounds(test_bounds));
+ EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
+
+ // The real test begins here.
+ test_layer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
+
+ // Case 1: Layer should accept dirty rects that go beyond its bounds.
+ test_layer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(
+ 1, test_layer->SetNeedsDisplayRect(out_of_bounds_dirty_rect));
+ EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
+ test_layer->ResetNeedsDisplayForTesting();
+
+ // Case 2: SetNeedsDisplay() without the dirty rect arg.
+ test_layer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetNeedsDisplay());
+ EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
+ test_layer->ResetNeedsDisplayForTesting();
+
+ // Case 3: SetNeedsDisplay() with a non-drawable layer
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(false));
+ test_layer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(0, test_layer->SetNeedsDisplayRect(dirty1));
+ EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
}
-TEST_F(LayerTest, checkPropertyChangeCausesCorrectBehavior)
-{
- 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.
-
- // sanity check of initial test condition
- 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()));
-
- // The above tests should not have caused a change to the needsDisplay flag.
- EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
-
- // As layers are removed from the tree, they will cause a tree sync.
- EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((AnyNumber()));
+TEST_F(LayerTest, CheckPropertyChangeCausesCorrectBehavior) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ test_layer->SetLayerTreeHost(layer_tree_host_.get());
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(true));
+
+ scoped_refptr<Layer> dummy_layer1 = Layer::Create();
+ scoped_refptr<Layer> dummy_layer2 = Layer::Create();
+
+ // sanity check of initial test condition
+ EXPECT_FALSE(test_layer->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, test_layer->SetAnchorPoint(
+ gfx::PointF(1.23f, 4.56f)));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetAnchorPointZ(0.7f));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBackgroundColor(SK_ColorLTGRAY));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetMasksToBounds(true));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.5f));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetContentsOpaque(true));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetPosition(gfx::PointF(4.f, 9.f)));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetSublayerTransform(
+ gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetScrollable(true));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetScrollOffset(
+ gfx::Vector2d(10, 10)));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetShouldScrollOnMainThread(true));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetNonFastScrollableRegion(
+ gfx::Rect(1, 1, 2, 2)));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetHaveWheelEventHandlers(true));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(
+ gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0)));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetDoubleSided(false));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetDebugName("Test Layer"));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetDrawCheckerboardForMissingTiles(
+ !test_layer->DrawCheckerboardForMissingTiles()));
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetForceRenderSurface(true));
+
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, test_layer->SetMaskLayer(
+ dummy_layer1.get()));
+ EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, test_layer->SetReplicaLayer(
+ dummy_layer2.get()));
+
+ // The above tests should not have caused a change to the needsDisplay flag.
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
+
+ // As layers are removed from the tree, they will cause a tree sync.
+ EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((AnyNumber()));
}
-TEST_F(LayerTest, setBoundsTriggersSetNeedsRedrawAfterGettingNonEmptyBounds)
-{
- scoped_refptr<Layer> testLayer = Layer::Create();
- testLayer->SetLayerTreeHost(layer_tree_host_.get());
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetIsDrawable(true));
+TEST_F(LayerTest, SetBoundsTriggersSetNeedsRedrawAfterGettingNonEmptyBounds) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ test_layer->SetLayerTreeHost(layer_tree_host_.get());
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->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(test_layer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBounds(gfx::Size(0, 10)));
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBounds(gfx::Size(10, 10)));
+ EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
- testLayer->ResetNeedsDisplayForTesting();
- EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
+ test_layer->ResetNeedsDisplayForTesting();
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
- // Calling setBounds only invalidates on the first time.
- EXPECT_SET_NEEDS_COMMIT(1, testLayer->SetBounds(gfx::Size(7, 10)));
- EXPECT_FALSE(testLayer->NeedsDisplayForTesting());
+ // Calling setBounds only invalidates on the first time.
+ EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBounds(gfx::Size(7, 10)));
+ EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
}
-TEST_F(LayerTest, verifyPushPropertiesAccumulatesUpdateRect)
-{
- scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 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->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->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->update_rect());
+TEST_F(LayerTest, PushPropertiesAccumulatesUpdateRect) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ scoped_ptr<LayerImpl> impl_layer =
+ LayerImpl::Create(host_impl_.active_tree(), 1);
+
+ test_layer->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
+ test_layer->PushPropertiesTo(impl_layer.get());
+ EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 5.f, 5.f),
+ impl_layer->update_rect());
+
+ // The LayerImpl's update_rect() should be accumulated here, since we did not
+ // do anything to clear it.
+ test_layer->SetNeedsDisplayRect(gfx::RectF(10.f, 10.f, 5.f, 5.f));
+ test_layer->PushPropertiesTo(impl_layer.get());
+ EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 15.f, 15.f),
+ impl_layer->update_rect());
+
+ // If we do clear the LayerImpl side, then the next update_rect() should be
+ // fresh without accumulation.
+ impl_layer->ResetAllChangeTrackingForSubtree();
+ test_layer->SetNeedsDisplayRect(gfx::RectF(10.f, 10.f, 5.f, 5.f));
+ test_layer->PushPropertiesTo(impl_layer.get());
+ EXPECT_FLOAT_RECT_EQ(gfx::RectF(10.f, 10.f, 5.f, 5.f),
+ impl_layer->update_rect());
}
-TEST_F(LayerTest, verifyPushPropertiesCausesSurfacePropertyChangedForTransform)
-{
- scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
+TEST_F(LayerTest, PushPropertiesCausesSurfacePropertyChangedForTransform) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ scoped_ptr<LayerImpl> impl_layer =
+ LayerImpl::Create(host_impl_.active_tree(), 1);
- gfx::Transform transform;
- transform.Rotate(45.0);
- testLayer->SetTransform(transform);
+ gfx::Transform transform;
+ transform.Rotate(45.0);
+ test_layer->SetTransform(transform);
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
- testLayer->PushPropertiesTo(implLayer.get());
+ test_layer->PushPropertiesTo(impl_layer.get());
- EXPECT_TRUE(implLayer->LayerSurfacePropertyChanged());
+ EXPECT_TRUE(impl_layer->LayerSurfacePropertyChanged());
}
-TEST_F(LayerTest, verifyPushPropertiesCausesSurfacePropertyChangedForOpacity)
-{
- scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
+TEST_F(LayerTest, PushPropertiesCausesSurfacePropertyChangedForOpacity) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ scoped_ptr<LayerImpl> impl_layer =
+ LayerImpl::Create(host_impl_.active_tree(), 1);
- testLayer->SetOpacity(0.5);
+ test_layer->SetOpacity(0.5f);
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
- testLayer->PushPropertiesTo(implLayer.get());
+ test_layer->PushPropertiesTo(impl_layer.get());
- EXPECT_TRUE(implLayer->LayerSurfacePropertyChanged());
+ EXPECT_TRUE(impl_layer->LayerSurfacePropertyChanged());
}
-TEST_F(LayerTest, verifyPushPropertiesDoesNotCauseSurfacePropertyChangedDuringImplOnlyTransformAnimation)
-{
- scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
-
- scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
- implLayer->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
-
- addAnimatedTransformToController(*implLayer->layer_animation_controller(), 1.0, 0, 100);
-
- gfx::Transform transform;
- transform.Rotate(45.0);
- testLayer->SetTransform(transform);
-
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
- testLayer->PushPropertiesTo(implLayer.get());
- EXPECT_TRUE(implLayer->LayerSurfacePropertyChanged());
-
- implLayer->ResetAllChangeTrackingForSubtree();
- addAnimatedTransformToController(*implLayer->layer_animation_controller(), 1.0, 0, 100);
- implLayer->layer_animation_controller()->GetAnimation(Animation::Transform)->set_is_impl_only(true);
- transform.Rotate(45.0);
- testLayer->SetTransform(transform);
-
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
- testLayer->PushPropertiesTo(implLayer.get());
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
+TEST_F(LayerTest,
+ PushPropertiesDoesNotCauseSurfacePropertyChangedDuringImplOnlyTransformAnimation) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ scoped_ptr<LayerImpl> impl_layer =
+ LayerImpl::Create(host_impl_.active_tree(), 1);
+
+ scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
+ impl_layer->layer_animation_controller()->SetAnimationRegistrar(
+ registrar.get());
+
+ addAnimatedTransformToController(*impl_layer->layer_animation_controller(),
+ 1.0,
+ 0,
+ 100);
+
+ gfx::Transform transform;
+ transform.Rotate(45.0);
+ test_layer->SetTransform(transform);
+
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
+ test_layer->PushPropertiesTo(impl_layer.get());
+ EXPECT_TRUE(impl_layer->LayerSurfacePropertyChanged());
+
+ impl_layer->ResetAllChangeTrackingForSubtree();
+ addAnimatedTransformToController(*impl_layer->layer_animation_controller(),
+ 1.0,
+ 0,
+ 100);
+ impl_layer->layer_animation_controller()->GetAnimation(Animation::Transform)->
+ set_is_impl_only(true);
+ transform.Rotate(45.0);
+ test_layer->SetTransform(transform);
+
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
+ test_layer->PushPropertiesTo(impl_layer.get());
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
}
-TEST_F(LayerTest, verifyPushPropertiesDoesNotCauseSurfacePropertyChangedDuringImplOnlyOpacityAnimation)
-{
- scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
+TEST_F(LayerTest,
+ PushPropertiesDoesNotCauseSurfacePropertyChangedDuringImplOnlyOpacityAnimation) {
+ scoped_refptr<Layer> test_layer = Layer::Create();
+ scoped_ptr<LayerImpl> impl_layer =
+ LayerImpl::Create(host_impl_.active_tree(), 1);
+
+ scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
+ impl_layer->layer_animation_controller()->SetAnimationRegistrar(
+ registrar.get());
+
+ addOpacityTransitionToController(*impl_layer->layer_animation_controller(),
+ 1.0,
+ 0.3f,
+ 0.7f,
+ false);
+
+ test_layer->SetOpacity(0.5f);
+
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
+ test_layer->PushPropertiesTo(impl_layer.get());
+ EXPECT_TRUE(impl_layer->LayerSurfacePropertyChanged());
+
+ impl_layer->ResetAllChangeTrackingForSubtree();
+ addOpacityTransitionToController(*impl_layer->layer_animation_controller(),
+ 1.0,
+ 0.3f,
+ 0.7f,
+ false);
+ impl_layer->layer_animation_controller()->GetAnimation(Animation::Opacity)->
+ set_is_impl_only(true);
+ test_layer->SetOpacity(0.75f);
+
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
+ test_layer->PushPropertiesTo(impl_layer.get());
+ EXPECT_FALSE(impl_layer->LayerSurfacePropertyChanged());
+}
- scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
- implLayer->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
- addOpacityTransitionToController(*implLayer->layer_animation_controller(), 1.0, 0.3f, 0.7f, false);
+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> replica_mask = Layer::Create();
+ scoped_refptr<Layer> mask_replacement = Layer::Create();
+ scoped_refptr<Layer> replica_replacement = Layer::Create();
+ scoped_refptr<Layer> replica_mask_replacement = Layer::Create();
- testLayer->SetOpacity(0.5f);
+ parent->AddChild(child);
+ child->SetMaskLayer(mask.get());
+ child->SetReplicaLayer(replica.get());
+ replica->SetMaskLayer(replica_mask.get());
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
- testLayer->PushPropertiesTo(implLayer.get());
- EXPECT_TRUE(implLayer->LayerSurfacePropertyChanged());
+ EXPECT_EQ(parent, child->parent());
+ EXPECT_EQ(child, mask->parent());
+ EXPECT_EQ(child, replica->parent());
+ EXPECT_EQ(replica, replica_mask->parent());
- implLayer->ResetAllChangeTrackingForSubtree();
- addOpacityTransitionToController(*implLayer->layer_animation_controller(), 1.0, 0.3f, 0.7f, false);
- implLayer->layer_animation_controller()->GetAnimation(Animation::Opacity)->set_is_impl_only(true);
- testLayer->SetOpacity(0.75f);
+ replica->SetMaskLayer(replica_mask_replacement.get());
+ EXPECT_EQ(NULL, replica_mask->parent());
+ EXPECT_EQ(replica, replica_mask_replacement->parent());
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
- testLayer->PushPropertiesTo(implLayer.get());
- EXPECT_FALSE(implLayer->LayerSurfacePropertyChanged());
-}
+ child->SetMaskLayer(mask_replacement.get());
+ EXPECT_EQ(NULL, mask->parent());
+ EXPECT_EQ(child, mask_replacement->parent());
+ child->SetReplicaLayer(replica_replacement.get());
+ EXPECT_EQ(NULL, replica->parent());
+ EXPECT_EQ(child, replica_replacement->parent());
-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());
-
- EXPECT_EQ(parent, child->parent());
- EXPECT_EQ(child, mask->parent());
- EXPECT_EQ(child, replica->parent());
- EXPECT_EQ(replica, replicaMask->parent());
-
- replica->SetMaskLayer(replicaMaskReplacement.get());
- EXPECT_EQ(NULL, replicaMask->parent());
- EXPECT_EQ(replica, replicaMaskReplacement->parent());
-
- child->SetMaskLayer(maskReplacement.get());
- EXPECT_EQ(NULL, mask->parent());
- EXPECT_EQ(child, maskReplacement->parent());
-
- child->SetReplicaLayer(replicaReplacement.get());
- EXPECT_EQ(NULL, replica->parent());
- EXPECT_EQ(child, replicaReplacement->parent());
-
- EXPECT_EQ(replica, replica->mask_layer()->parent());
+ EXPECT_EQ(replica, replica->mask_layer()->parent());
}
class FakeLayerImplTreeHost : public LayerTreeHost {
-public:
- 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.
- host->Initialize(scoped_ptr<Thread>(NULL));
- return host.Pass();
- }
-
- static scoped_ptr<FakeLayerImplTreeHost> Create(LayerTreeSettings settings)
- {
- scoped_ptr<FakeLayerImplTreeHost> host(new FakeLayerImplTreeHost(settings));
- host->Initialize(scoped_ptr<Thread>(NULL));
- return host.Pass();
- }
-
-private:
- FakeLayerImplTreeHost(const LayerTreeSettings& settings)
- : LayerTreeHost(&m_client, settings)
- {
- }
-
- FakeLayerImplTreeHostClient m_client;
+ public:
+ static scoped_ptr<FakeLayerImplTreeHost> Create() {
+ scoped_ptr<FakeLayerImplTreeHost> host =
+ make_scoped_ptr(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.
+ host->Initialize(scoped_ptr<Thread>(NULL));
+ return host.Pass();
+ }
+
+ static scoped_ptr<FakeLayerImplTreeHost> Create(LayerTreeSettings settings) {
+ scoped_ptr<FakeLayerImplTreeHost> host(new FakeLayerImplTreeHost(settings));
+ host->Initialize(scoped_ptr<Thread>(NULL));
+ return host.Pass();
+ }
+
+ private:
+ FakeLayerImplTreeHost(const LayerTreeSettings& settings)
+ : LayerTreeHost(&client_, settings) {}
+
+ FakeLayerImplTreeHostClient client_;
};
-void assertLayerTreeHostMatchesForSubtree(Layer* layer, LayerTreeHost* host)
-{
- EXPECT_EQ(host, layer->layer_tree_host());
+void AssertLayerTreeHostMatchesForSubtree(Layer* layer, LayerTreeHost* host) {
+ EXPECT_EQ(host, layer->layer_tree_host());
- for (size_t i = 0; i < layer->children().size(); ++i)
- assertLayerTreeHostMatchesForSubtree(layer->children()[i].get(), host);
+ for (size_t i = 0; i < layer->children().size(); ++i)
+ AssertLayerTreeHostMatchesForSubtree(layer->children()[i].get(), host);
- if (layer->mask_layer())
- assertLayerTreeHostMatchesForSubtree(layer->mask_layer(), host);
+ if (layer->mask_layer())
+ AssertLayerTreeHostMatchesForSubtree(layer->mask_layer(), host);
- if (layer->replica_layer())
- assertLayerTreeHostMatchesForSubtree(layer->replica_layer(), 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();
+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> replica_mask = 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());
+ // 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(replica_mask.get());
- assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
+ AssertLayerTreeHostMatchesForSubtree(parent.get(), NULL);
- 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());
+ scoped_ptr<FakeLayerImplTreeHost> layer_tree_host =
+ FakeLayerImplTreeHost::Create();
+ // Setting the root layer should set the host pointer for all layers in the
+ // tree.
+ layer_tree_host->SetRootLayer(parent.get());
- assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
+ AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
- // Clearing the root layer should also clear out the host pointers for all layers in the tree.
- layerTreeHost->SetRootLayer(NULL);
+ // Clearing the root layer should also clear out the host pointers for all
+ // layers in the tree.
+ layer_tree_host->SetRootLayer(NULL);
- assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
+ AssertLayerTreeHostMatchesForSubtree(parent.get(), NULL);
}
-TEST(LayerLayerTreeHostTest, addingLayerSubtree)
-{
- scoped_refptr<Layer> parent = Layer::Create();
- scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::Create());
+TEST(LayerLayerTreeHostTest, AddingLayerSubtree) {
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_ptr<FakeLayerImplTreeHost> layer_tree_host =
+ FakeLayerImplTreeHost::Create();
- layerTreeHost->SetRootLayer(parent.get());
+ layer_tree_host->SetRootLayer(parent.get());
- EXPECT_EQ(parent->layer_tree_host(), layerTreeHost.get());
+ EXPECT_EQ(parent->layer_tree_host(), layer_tree_host.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);
+ // 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> grand_child = Layer::Create();
+ child->AddChild(grand_child);
- // 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());
+ // Masks, replicas, and replica masks should pick up the new host too.
+ scoped_refptr<Layer> child_mask = Layer::Create();
+ child->SetMaskLayer(child_mask.get());
+ scoped_refptr<Layer> child_replica = Layer::Create();
+ child->SetReplicaLayer(child_replica.get());
+ scoped_refptr<Layer> child_replica_mask = Layer::Create();
+ child_replica->SetMaskLayer(child_replica_mask.get());
- parent->AddChild(child);
- assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
+ parent->AddChild(child);
+ AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
- layerTreeHost->SetRootLayer(NULL);
+ layer_tree_host->SetRootLayer(NULL);
}
-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();
+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> replica_mask = Layer::Create();
- // Same setup as the previous test.
- parent->AddChild(child);
- child->SetMaskLayer(mask.get());
- child->SetReplicaLayer(replica.get());
- replica->SetMaskLayer(replicaMask.get());
+ // Same setup as the previous test.
+ parent->AddChild(child);
+ child->SetMaskLayer(mask.get());
+ child->SetReplicaLayer(replica.get());
+ replica->SetMaskLayer(replica_mask.get());
- scoped_ptr<FakeLayerImplTreeHost> firstLayerTreeHost(FakeLayerImplTreeHost::Create());
- firstLayerTreeHost->SetRootLayer(parent.get());
+ scoped_ptr<FakeLayerImplTreeHost> first_layer_tree_host =
+ FakeLayerImplTreeHost::Create();
+ first_layer_tree_host->SetRootLayer(parent.get());
- assertLayerTreeHostMatchesForSubtree(parent.get(), firstLayerTreeHost.get());
+ AssertLayerTreeHostMatchesForSubtree(parent.get(),
+ first_layer_tree_host.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());
- secondLayerTreeHost->SetRootLayer(parent.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> second_layer_tree_host =
+ FakeLayerImplTreeHost::Create();
+ second_layer_tree_host->SetRootLayer(parent.get());
- assertLayerTreeHostMatchesForSubtree(parent.get(), secondLayerTreeHost.get());
+ AssertLayerTreeHostMatchesForSubtree(parent.get(),
+ second_layer_tree_host.get());
- secondLayerTreeHost->SetRootLayer(NULL);
+ second_layer_tree_host->SetRootLayer(NULL);
}
-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();
-
- // First put all children under the first parent and set the first host.
- firstParent->AddChild(firstChild);
- secondChild->AddChild(secondGrandChild);
- firstParent->AddChild(secondChild);
-
- 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());
- secondLayerTreeHost->SetRootLayer(secondParent.get());
-
- secondParent->AddChild(secondChild);
-
- // The moved layer and its children should point to the new host.
- EXPECT_EQ(secondLayerTreeHost.get(), secondChild->layer_tree_host());
- EXPECT_EQ(secondLayerTreeHost.get(), secondGrandChild->layer_tree_host());
-
- // Test over, cleanup time.
- firstLayerTreeHost->SetRootLayer(NULL);
- secondLayerTreeHost->SetRootLayer(NULL);
+TEST(LayerLayerTreeHostTest, ChangeHostInSubtree) {
+ scoped_refptr<Layer> first_parent = Layer::Create();
+ scoped_refptr<Layer> first_child = Layer::Create();
+ scoped_refptr<Layer> second_parent = Layer::Create();
+ scoped_refptr<Layer> second_child = Layer::Create();
+ scoped_refptr<Layer> second_grand_child = Layer::Create();
+
+ // First put all children under the first parent and set the first host.
+ first_parent->AddChild(first_child);
+ second_child->AddChild(second_grand_child);
+ first_parent->AddChild(second_child);
+
+ scoped_ptr<FakeLayerImplTreeHost> first_layer_tree_host =
+ FakeLayerImplTreeHost::Create();
+ first_layer_tree_host->SetRootLayer(first_parent.get());
+
+ AssertLayerTreeHostMatchesForSubtree(first_parent.get(),
+ first_layer_tree_host.get());
+
+ // Now reparent the subtree starting at second_child to a layer in a different
+ // tree.
+ scoped_ptr<FakeLayerImplTreeHost> second_layer_tree_host =
+ FakeLayerImplTreeHost::Create();
+ second_layer_tree_host->SetRootLayer(second_parent.get());
+
+ second_parent->AddChild(second_child);
+
+ // The moved layer and its children should point to the new host.
+ EXPECT_EQ(second_layer_tree_host.get(), second_child->layer_tree_host());
+ EXPECT_EQ(second_layer_tree_host.get(),
+ second_grand_child->layer_tree_host());
+
+ // Test over, cleanup time.
+ first_layer_tree_host->SetRootLayer(NULL);
+ second_layer_tree_host->SetRootLayer(NULL);
}
-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());
- 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->layer_tree_host());
- EXPECT_EQ(0, maskChild->layer_tree_host());
-
- // Same for replacing a replica layer.
- parent->SetReplicaLayer(replicaReplacement.get());
- EXPECT_EQ(0, replica->layer_tree_host());
- EXPECT_EQ(0, replicaChild->layer_tree_host());
-
- // Test over, cleanup time.
- layerTreeHost->SetRootLayer(NULL);
+TEST(LayerLayerTreeHostTest, ReplaceMaskAndReplicaLayer) {
+ scoped_refptr<Layer> parent = Layer::Create();
+ scoped_refptr<Layer> mask = Layer::Create();
+ scoped_refptr<Layer> replica = Layer::Create();
+ scoped_refptr<Layer> mask_child = Layer::Create();
+ scoped_refptr<Layer> replica_child = Layer::Create();
+ scoped_refptr<Layer> mask_replacement = Layer::Create();
+ scoped_refptr<Layer> replica_replacement = Layer::Create();
+
+ parent->SetMaskLayer(mask.get());
+ parent->SetReplicaLayer(replica.get());
+ mask->AddChild(mask_child);
+ replica->AddChild(replica_child);
+
+ scoped_ptr<FakeLayerImplTreeHost> layer_tree_host =
+ FakeLayerImplTreeHost::Create();
+ layer_tree_host->SetRootLayer(parent.get());
+
+ AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
+
+ // Replacing the mask should clear out the old mask's subtree's host pointers.
+ parent->SetMaskLayer(mask_replacement.get());
+ EXPECT_EQ(NULL, mask->layer_tree_host());
+ EXPECT_EQ(NULL, mask_child->layer_tree_host());
+
+ // Same for replacing a replica layer.
+ parent->SetReplicaLayer(replica_replacement.get());
+ EXPECT_EQ(NULL, replica->layer_tree_host());
+ EXPECT_EQ(NULL, replica_child->layer_tree_host());
+
+ // Test over, cleanup time.
+ layer_tree_host->SetRootLayer(NULL);
}
-TEST(LayerLayerTreeHostTest, destroyHostWithNonNullRootLayer)
-{
- scoped_refptr<Layer> root = Layer::Create();
- scoped_refptr<Layer> child = Layer::Create();
- root->AddChild(child);
- scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::Create());
- layerTreeHost->SetRootLayer(root);
+TEST(LayerLayerTreeHostTest, DestroyHostWithNonNullRootLayer) {
+ scoped_refptr<Layer> root = Layer::Create();
+ scoped_refptr<Layer> child = Layer::Create();
+ root->AddChild(child);
+ scoped_ptr<FakeLayerImplTreeHost> layer_tree_host =
+ FakeLayerImplTreeHost::Create();
+ layer_tree_host->SetRootLayer(root);
}
-static bool addTestAnimation(Layer* layer)
-{
- scoped_ptr<KeyframedFloatAnimationCurve> curve(KeyframedFloatAnimationCurve::Create());
- curve->AddKeyframe(FloatKeyframe::Create(0.0, 0.3f, scoped_ptr<TimingFunction>()));
- curve->AddKeyframe(FloatKeyframe::Create(1.0, 0.7f, scoped_ptr<TimingFunction>()));
- scoped_ptr<Animation> animation(Animation::Create(curve.PassAs<AnimationCurve>(), 0, 0, Animation::Opacity));
-
- return layer->AddAnimation(animation.Pass());
+static bool AddTestAnimation(Layer* layer) {
+ scoped_ptr<KeyframedFloatAnimationCurve> curve =
+ KeyframedFloatAnimationCurve::Create();
+ curve->AddKeyframe(FloatKeyframe::Create(0.0,
+ 0.3f,
+ scoped_ptr<TimingFunction>()));
+ curve->AddKeyframe(FloatKeyframe::Create(1.0,
+ 0.7f,
+ scoped_ptr<TimingFunction>()));
+ scoped_ptr<Animation> animation =
+ Animation::Create(curve.PassAs<AnimationCurve>(),
+ 0,
+ 0,
+ Animation::Opacity);
+
+ return layer->AddAnimation(animation.Pass());
}
-TEST(LayerLayerTreeHostTest, shouldNotAddAnimationWithoutAnimationRegistrar)
-{
- scoped_refptr<Layer> layer = Layer::Create();
+TEST(LayerLayerTreeHostTest, ShouldNotAddAnimationWithoutAnimationRegistrar) {
+ 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()));
+ // 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->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
+ scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
+ layer->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
- // Case 2: with an AnimationRegistrar, the animation should be accepted.
- EXPECT_TRUE(addTestAnimation(layer.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));
- layerTreeHost->SetRootLayer(layer);
- layer->SetLayerTreeHost(layerTreeHost.get());
- assertLayerTreeHostMatchesForSubtree(layer.get(), layerTreeHost.get());
+ LayerTreeSettings settings;
+ settings.acceleratedAnimationEnabled = false;
+ scoped_ptr<FakeLayerImplTreeHost> layer_tree_host =
+ FakeLayerImplTreeHost::Create(settings);
+ layer_tree_host->SetRootLayer(layer);
+ layer->SetLayerTreeHost(layer_tree_host.get());
+ AssertLayerTreeHostMatchesForSubtree(layer.get(), layer_tree_host.get());
- // Case 3: with a LayerTreeHost where accelerated animation is disabled, the
- // animation should be rejected.
- EXPECT_FALSE(addTestAnimation(layer.get()));
+ // Case 3: with a LayerTreeHost where accelerated animation is disabled, the
+ // animation should be rejected.
+ EXPECT_FALSE(AddTestAnimation(layer.get()));
}
} // namespace
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698