Only do full tree sync if tree is actually changed, otherwise just push properties

cc/layer_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer.h"
 
 #include "cc/keyframed_animation_curve.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_painter.h"
 #include "cc/layer_tree_host.h"
 #include "cc/math_util.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/thread.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/transform.h"
 
-using namespace WebKitTests;
+using ::testing::AnyNumber;
+using ::testing::AtLeast;
 using ::testing::Mock;
+using ::testing::StrictMock;
 using ::testing::_;
-using ::testing::AtLeast;
-using ::testing::AnyNumber;
 
-#define EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(numTimesExpectedSetNeedsCommit, codeToTest) do { \
-        EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times((numTimesExpectedSetNeedsCommit));      \
-        codeToTest;                                                                                   \
-        Mock::VerifyAndClearExpectations(m_layerTreeHost.get());                                      \
+#define EXPECT_SET_NEEDS_COMMIT(expect, codeToTest) do {                 \
+        EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times((expect)); \
+        codeToTest;                                                      \
+        Mock::VerifyAndClearExpectations(m_layerTreeHost.get());         \
     } while (0)
 
+#define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, codeToTest) do {               \
+        EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times((expect)); \
+        codeToTest;                                                            \
+        Mock::VerifyAndClearExpectations(m_layerTreeHost.get());               \
+    } while (0)
+
+
 namespace cc {
 namespace {
 
 class MockLayerImplTreeHost : public LayerTreeHost {
 public:
     MockLayerImplTreeHost()
         : LayerTreeHost(&m_fakeClient, LayerTreeSettings())
     {
         initialize(scoped_ptr<Thread>(NULL));
     }
 
     MOCK_METHOD0(setNeedsCommit, void());
+    MOCK_METHOD0(setNeedsFullTreeSync, void());
 
 private:
     FakeLayerImplTreeHostClient m_fakeClient;
 };
 
 class MockLayerPainter : public LayerPainter {
 public:
     virtual void paint(SkCanvas*, const gfx::Rect&, gfx::RectF&) OVERRIDE { }
 };
 
 
 class LayerTest : public testing::Test {
 public:
     LayerTest()
     {
     }
 
 protected:
     virtual void SetUp()
     {
-        m_layerTreeHost = scoped_ptr<MockLayerImplTreeHost>(new MockLayerImplTreeHost);
+        m_layerTreeHost.reset(new StrictMock<MockLayerImplTreeHost>);
     }
 
     virtual void TearDown()
     {
         Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
-        EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AnyNumber());
+        EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AnyNumber());
         m_parent = NULL;
         m_child1 = NULL;
         m_child2 = NULL;
         m_child3 = NULL;
         m_grandChild1 = NULL;
         m_grandChild2 = NULL;
         m_grandChild3 = NULL;
 
         m_layerTreeHost->setRootLayer(0);
         m_layerTreeHost.reset();
@@ skipping 25 matching lines @@
     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, setNeedsCommit()).Times(AnyNumber());
+        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());
 
         verifyTestTreeInitialState();
     }
 
-    scoped_ptr<MockLayerImplTreeHost> m_layerTreeHost;
+    scoped_ptr<StrictMock<MockLayerImplTreeHost> > m_layerTreeHost;
     scoped_refptr<Layer> m_parent, m_child1, m_child2, m_child3, m_grandChild1, m_grandChild2, m_grandChild3;
 };
 
 TEST_F(LayerTest, basicCreateAndDestroy)
 {
     scoped_refptr<Layer> testLayer = Layer::create();
     ASSERT_TRUE(testLayer);
 
     EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(0);
     testLayer->setLayerTreeHost(m_layerTreeHost.get());
 }
 
 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(static_cast<size_t>(0), parent->children().size());
     EXPECT_FALSE(child->parent());
 
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, m_layerTreeHost->setRootLayer(parent));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, parent->addChild(child));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, m_layerTreeHost->setRootLayer(parent));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->addChild(child));
 
     ASSERT_EQ(static_cast<size_t>(1), parent->children().size());
     EXPECT_EQ(child.get(), parent->children()[0]);
     EXPECT_EQ(parent.get(), child->parent());
     EXPECT_EQ(parent.get(), child->rootLayer());
 
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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));
+
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
 
     m_layerTreeHost->setRootLayer(parent);
 
     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());
 }
 
 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(m_layerTreeHost.get());
 
     ASSERT_EQ(static_cast<size_t>(0), parent->children().size());
 
     // Case 1: inserting to empty list.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, parent->insertChild(child3, 0));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child3, 0));
     ASSERT_EQ(static_cast<size_t>(1), parent->children().size());
     EXPECT_EQ(child3, parent->children()[0]);
     EXPECT_EQ(parent.get(), child3->parent());
 
     // Case 2: inserting to beginning of list
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, parent->insertChild(child1, 0));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child1, 0));
     ASSERT_EQ(static_cast<size_t>(2), 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
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, parent->insertChild(child2, 1));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child2, 1));
     ASSERT_EQ(static_cast<size_t>(3), 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
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, parent->insertChild(child4, 3));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->insertChild(child4, 3));
 
     ASSERT_EQ(static_cast<size_t>(4), 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(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
+    EXPECT_CALL(*m_layerTreeHost, 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();
 
     ASSERT_EQ(static_cast<size_t>(0), parent->children().size());
 
@@ skipping 14 matching lines @@
 TEST_F(LayerTest, insertSameChildTwice)
 {
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child1 = Layer::create();
     scoped_refptr<Layer> child2 = Layer::create();
 
     parent->setLayerTreeHost(m_layerTreeHost.get());
 
     ASSERT_EQ(static_cast<size_t>(0), parent->children().size());
 
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, parent->insertChild(child1, 0));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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(static_cast<size_t>(2), 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.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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(static_cast<size_t>(2), parent->children().size());
     EXPECT_EQ(child2, parent->children()[0]);
     EXPECT_EQ(child1, parent->children()[1]);
 
-    EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
+    EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AtLeast(1));
 }
 
 TEST_F(LayerTest, replaceChildWithNewChild)
 {
     createSimpleTestTree();
     scoped_refptr<Layer> child4 = Layer::create();
 
     EXPECT_FALSE(child4->parent());
 
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(AtLeast(1), m_parent->replaceChild(m_child2.get(), child4));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), m_parent->replaceChild(m_child2.get(), child4));
 
     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());
 
     EXPECT_FALSE(m_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(static_cast<size_t>(1), testLayer->children().size());
     EXPECT_EQ(child4, testLayer->children()[0]);
     EXPECT_EQ(testLayer.get(), child4->parent());
 
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(AtLeast(1), m_parent->replaceChild(m_child2.get(), child4));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), m_parent->replaceChild(m_child2.get(), child4));
 
     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());
 
     // testLayer should no longer have child4,
     // and child2 should no longer have a parent.
     ASSERT_EQ(static_cast<size_t>(0), testLayer->children().size());
     EXPECT_FALSE(m_child2->parent());
 }
 
 TEST_F(LayerTest, replaceChildWithSameChild)
 {
     createSimpleTestTree();
 
-    // setNeedsCommit should not be called because its the same child
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, m_parent->replaceChild(m_child2.get(), m_child2));
+    // 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);
 
     verifyTestTreeInitialState();
 }
 
 TEST_F(LayerTest, removeAllChildren)
 {
     createSimpleTestTree();
 
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(AtLeast(3), m_parent->removeAllChildren());
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(3), m_parent->removeAllChildren());
 
     ASSERT_EQ(static_cast<size_t>(0), m_parent->children().size());
     EXPECT_FALSE(m_child1->parent());
     EXPECT_FALSE(m_child2->parent());
     EXPECT_FALSE(m_child3->parent());
 }
 
 TEST_F(LayerTest, setChildren)
 {
     scoped_refptr<Layer> oldParent = Layer::create();
     scoped_refptr<Layer> newParent = 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);
     ASSERT_EQ(static_cast<size_t>(0), newParent->children().size());
     EXPECT_EQ(oldParent.get(), child1->parent());
     EXPECT_FALSE(child2->parent());
 
     newParent->setLayerTreeHost(m_layerTreeHost.get());
 
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(AtLeast(1), newParent->setChildren(newChildren));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), newParent->setChildren(newChildren));
 
     ASSERT_EQ(static_cast<size_t>(2), newParent->children().size());
     EXPECT_EQ(newParent.get(), child1->parent());
     EXPECT_EQ(newParent.get(), child2->parent());
 
-    EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
+    EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AtLeast(1));
 }
 
 TEST_F(LayerTest, getRootLayerAfterTreeManipulations)
 {
     createSimpleTestTree();
 
-    // For this test we don't care about setNeedsCommit calls.
-    EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
+    // For this test we don't care about setNeedsFullTreeSync calls.
+    EXPECT_CALL(*m_layerTreeHost, setNeedsFullTreeSync()).Times(AnyNumber());
 
     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());
@@ skipping 36 matching lines @@
 }
 
 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(m_layerTreeHost.get());
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setIsDrawable(true));
+    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->needsDisplay());
 
     // This is just initialization, but setNeedsCommit behavior is verified anyway to avoid warnings.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(testBounds));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(testBounds));
     testLayer = Layer::create();
     testLayer->setLayerTreeHost(m_layerTreeHost.get());
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setIsDrawable(true));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(true));
     EXPECT_FALSE(testLayer->needsDisplay());
 
     // The real test begins here.
 
     // Case 1: needsDisplay flag should not change because of an empty dirty rect.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(emptyDirtyRect));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNeedsDisplayRect(emptyDirtyRect));
     EXPECT_FALSE(testLayer->needsDisplay());
 
     // Case 2: basic.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(dirty1));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNeedsDisplayRect(dirty1));
     EXPECT_TRUE(testLayer->needsDisplay());
 
     // Case 3: a second dirty rect.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(dirty2));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNeedsDisplayRect(dirty2));
     EXPECT_TRUE(testLayer->needsDisplay());
 
     // Case 4: Layer should accept dirty rects that go beyond its bounds.
     testLayer = Layer::create();
     testLayer->setLayerTreeHost(m_layerTreeHost.get());
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setIsDrawable(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(testBounds));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(outOfBoundsDirtyRect));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(true));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(testBounds));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNeedsDisplayRect(outOfBoundsDirtyRect));
     EXPECT_TRUE(testLayer->needsDisplay());
 
     // Case 5: setNeedsDisplay() without the dirty rect arg.
     testLayer = Layer::create();
     testLayer->setLayerTreeHost(m_layerTreeHost.get());
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setIsDrawable(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(testBounds));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplay());
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(true));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(testBounds));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setNeedsDisplay());
     EXPECT_TRUE(testLayer->needsDisplay());
 
     // Case 6: setNeedsDisplay() with a non-drawable layer
     testLayer = Layer::create();
     testLayer->setLayerTreeHost(m_layerTreeHost.get());
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setBounds(testBounds));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setNeedsDisplayRect(dirty1));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setBounds(testBounds));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setNeedsDisplayRect(dirty1));
     EXPECT_TRUE(testLayer->needsDisplay());
 }
 
 TEST_F(LayerTest, checkPropertyChangeCausesCorrectBehavior)
 {
     scoped_refptr<Layer> testLayer = Layer::create();
     testLayer->setLayerTreeHost(m_layerTreeHost.get());
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setIsDrawable(true));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setIsDrawable(true));
 
     scoped_refptr<Layer> dummyLayer = Layer::create(); // just a dummy layer for this test case.
 
     // sanity check of initial test condition
     EXPECT_FALSE(testLayer->needsDisplay());
 
     // Test properties that should not call needsDisplay and needsCommit when changed.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setVisibleContentRect(gfx::Rect(0, 0, 40, 50)));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setUseLCDText(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setDrawOpacity(0.5));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setRenderTarget(0));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setDrawTransform(gfx::Transform()));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setScreenSpaceTransform(gfx::Transform()));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setDrawableContentRect(gfx::Rect(4, 5, 6, 7)));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setVisibleContentRect(gfx::Rect(0, 0, 40, 50)));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setUseLCDText(true));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setDrawOpacity(0.5));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setRenderTarget(0));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setDrawTransform(gfx::Transform()));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setScreenSpaceTransform(gfx::Transform()));
+    EXPECT_SET_NEEDS_COMMIT(0, testLayer->setDrawableContentRect(gfx::Rect(4, 5, 6, 7)));
     EXPECT_FALSE(testLayer->needsDisplay());
 
     // 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.
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setAnchorPoint(gfx::PointF(1.23f, 4.56f)));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setAnchorPointZ(0.7f));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBackgroundColor(SK_ColorLTGRAY));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setMasksToBounds(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setMaskLayer(dummyLayer.get()));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setOpacity(0.5));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setContentsOpaque(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setPosition(gfx::PointF(4, 9)));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setReplicaLayer(dummyLayer.get()));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setSublayerTransform(MathUtil::createGfxTransform(0, 0, 0, 0, 0, 0)));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setScrollable(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setShouldScrollOnMainThread(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNonFastScrollableRegion(gfx::Rect(1, 1, 2, 2)));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setHaveWheelEventHandlers(true));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setScrollOffset(gfx::Vector2d(10, 10)));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setTransform(MathUtil::createGfxTransform(0, 0, 0, 0, 0, 0)));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDoubleSided(false));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDebugName("Test Layer"));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDrawCheckerboardForMissingTiles(!testLayer->drawCheckerboardForMissingTiles()));
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setForceRenderSurface(true));
+    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(MathUtil::createGfxTransform(0, 0, 0, 0, 0, 0)));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setScrollable(true));
+    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(MathUtil::createGfxTransform(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(dummyLayer.get()));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, testLayer->setReplicaLayer(dummyLayer.get()));
+    EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, testLayer->setScrollOffset(gfx::Vector2d(10, 10)));
 
     // The above tests should not have caused a change to the needsDisplay flag.
     EXPECT_FALSE(testLayer->needsDisplay());
 
     // Test properties that should call setNeedsDisplay and setNeedsCommit
-    EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(gfx::Size(5, 10)));
+    EXPECT_SET_NEEDS_COMMIT(1, testLayer->setBounds(gfx::Size(5, 10)));
     EXPECT_TRUE(testLayer->needsDisplay());
 }
 
 TEST_F(LayerTest, verifyPushPropertiesAccumulatesUpdateRect)
 {
     scoped_refptr<Layer> testLayer = Layer::create();
     scoped_ptr<LayerImpl> implLayer = LayerImpl::create(1);
 
     testLayer->setNeedsDisplayRect(gfx::RectF(gfx::PointF(), gfx::SizeF(5, 5)));
     testLayer->pushPropertiesTo(implLayer.get());
@@ skipping 258 matching lines @@
     scoped_refptr<MockLayer> layer(new MockLayer);
     EXPECT_FALSE(layer->needsDisplay());
     layer->setBounds(gfx::Size(0, 10));
     EXPECT_FALSE(layer->needsDisplay());
     layer->setBounds(gfx::Size(10, 10));
     EXPECT_TRUE(layer->needsDisplay());
 }
 
 }  // namespace
 }  // namespace cc