LayerChromiumTest.cpp [plain text]
#include "config.h"
#include "LayerChromium.h"
#include "CCLayerTreeTestCommon.h"
#include "FakeCCLayerTreeHostClient.h"
#include "LayerPainterChromium.h"
#include "NonCompositedContentHost.h"
#include "WebCompositor.h"
#include "cc/CCLayerImpl.h"
#include "cc/CCLayerTreeHost.h"
#include "cc/CCSingleThreadProxy.h"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
using namespace WebCore;
using namespace WebKitTests;
using ::testing::Mock;
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()); \
} while (0)
namespace {
class MockCCLayerTreeHost : public CCLayerTreeHost {
public:
MockCCLayerTreeHost()
: CCLayerTreeHost(&m_fakeClient, CCSettings())
{
initialize();
}
MOCK_METHOD0(setNeedsCommit, void());
private:
FakeCCLayerTreeHostClient m_fakeClient;
};
class MockLayerPainterChromium : public LayerPainterChromium {
public:
virtual void paint(GraphicsContext&, const IntRect&) { }
};
class LayerChromiumTest : public testing::Test {
protected:
virtual void SetUp()
{
WebKit::WebCompositor::initialize(0);
m_layerTreeHost = adoptPtr(new MockCCLayerTreeHost);
}
virtual void TearDown()
{
Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AnyNumber());
m_parent.clear();
m_child1.clear();
m_child2.clear();
m_child3.clear();
m_grandChild1.clear();
m_grandChild2.clear();
m_grandChild3.clear();
m_layerTreeHost->setRootLayer(0);
m_layerTreeHost.clear();
WebKit::WebCompositor::shutdown();
}
void verifyTestTreeInitialState() const
{
ASSERT_EQ(static_cast<size_t>(3), m_parent->children().size());
EXPECT_EQ(m_child1, m_parent->children()[0]);
EXPECT_EQ(m_child2, m_parent->children()[1]);
EXPECT_EQ(m_child3, m_parent->children()[2]);
EXPECT_EQ(m_parent.get(), m_child1->parent());
EXPECT_EQ(m_parent.get(), m_child2->parent());
EXPECT_EQ(m_parent.get(), m_child3->parent());
ASSERT_EQ(static_cast<size_t>(2), 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(static_cast<size_t>(1), m_child2->children().size());
EXPECT_EQ(m_grandChild3, m_child2->children()[0]);
EXPECT_EQ(m_child2.get(), m_grandChild3->parent());
ASSERT_EQ(static_cast<size_t>(0), m_child3->children().size());
}
void createSimpleTestTree()
{
m_parent = LayerChromium::create();
m_child1 = LayerChromium::create();
m_child2 = LayerChromium::create();
m_child3 = LayerChromium::create();
m_grandChild1 = LayerChromium::create();
m_grandChild2 = LayerChromium::create();
m_grandChild3 = LayerChromium::create();
EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).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();
}
OwnPtr<MockCCLayerTreeHost> m_layerTreeHost;
RefPtr<LayerChromium> m_parent, m_child1, m_child2, m_child3, m_grandChild1, m_grandChild2, m_grandChild3;
};
TEST_F(LayerChromiumTest, basicCreateAndDestroy)
{
RefPtr<LayerChromium> testLayer = LayerChromium::create();
ASSERT_TRUE(testLayer);
EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(0);
testLayer->setLayerTreeHost(m_layerTreeHost.get());
}
TEST_F(LayerChromiumTest, addAndRemoveChild)
{
RefPtr<LayerChromium> parent = LayerChromium::create();
RefPtr<LayerChromium> child = LayerChromium::create();
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));
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());
}
TEST_F(LayerChromiumTest, insertChild)
{
RefPtr<LayerChromium> parent = LayerChromium::create();
RefPtr<LayerChromium> child1 = LayerChromium::create();
RefPtr<LayerChromium> child2 = LayerChromium::create();
RefPtr<LayerChromium> child3 = LayerChromium::create();
RefPtr<LayerChromium> child4 = LayerChromium::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(child3, 0));
ASSERT_EQ(static_cast<size_t>(1), parent->children().size());
EXPECT_EQ(child3, parent->children()[0]);
EXPECT_EQ(parent.get(), child3->parent());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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));
}
TEST_F(LayerChromiumTest, insertChildPastEndOfList)
{
RefPtr<LayerChromium> parent = LayerChromium::create();
RefPtr<LayerChromium> child1 = LayerChromium::create();
RefPtr<LayerChromium> child2 = LayerChromium::create();
ASSERT_EQ(static_cast<size_t>(0), parent->children().size());
parent->insertChild(child1, 53);
ASSERT_EQ(static_cast<size_t>(1), parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
parent->insertChild(child2, 2459);
ASSERT_EQ(static_cast<size_t>(2), parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
EXPECT_EQ(child2, parent->children()[1]);
}
TEST_F(LayerChromiumTest, insertSameChildTwice)
{
RefPtr<LayerChromium> parent = LayerChromium::create();
RefPtr<LayerChromium> child1 = LayerChromium::create();
RefPtr<LayerChromium> child2 = LayerChromium::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));
ASSERT_EQ(static_cast<size_t>(2), parent->children().size());
EXPECT_EQ(child1, parent->children()[0]);
EXPECT_EQ(child2, parent->children()[1]);
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(AtLeast(1), parent->insertChild(child1, 1));
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));
}
TEST_F(LayerChromiumTest, replaceChildWithNewChild)
{
createSimpleTestTree();
RefPtr<LayerChromium> child4 = LayerChromium::create();
EXPECT_FALSE(child4->parent());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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(LayerChromiumTest, replaceChildWithNewChildThatHasOtherParent)
{
createSimpleTestTree();
RefPtr<LayerChromium> testLayer = LayerChromium::create();
RefPtr<LayerChromium> child4 = LayerChromium::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));
ASSERT_EQ(static_cast<size_t>(3), m_parent->children().size());
EXPECT_EQ(m_child1, m_parent->children()[0]);
EXPECT_EQ(child4, m_parent->children()[1]);
EXPECT_EQ(m_child3, m_parent->children()[2]);
EXPECT_EQ(m_parent.get(), child4->parent());
ASSERT_EQ(static_cast<size_t>(0), testLayer->children().size());
EXPECT_FALSE(m_child2->parent());
}
TEST_F(LayerChromiumTest, replaceChildWithSameChild)
{
createSimpleTestTree();
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, m_parent->replaceChild(m_child2.get(), m_child2));
verifyTestTreeInitialState();
}
TEST_F(LayerChromiumTest, removeAllChildren)
{
createSimpleTestTree();
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(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(LayerChromiumTest, setChildren)
{
RefPtr<LayerChromium> oldParent = LayerChromium::create();
RefPtr<LayerChromium> newParent = LayerChromium::create();
RefPtr<LayerChromium> child1 = LayerChromium::create();
RefPtr<LayerChromium> child2 = LayerChromium::create();
Vector<RefPtr<LayerChromium> > newChildren;
newChildren.append(child1);
newChildren.append(child2);
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));
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));
}
TEST_F(LayerChromiumTest, getRootLayerAfterTreeManipulations)
{
createSimpleTestTree();
EXPECT_CALL(*m_layerTreeHost, setNeedsCommit()).Times(AtLeast(1));
RefPtr<LayerChromium> child4 = LayerChromium::create();
EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
EXPECT_EQ(m_parent.get(), m_child1->rootLayer());
EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
EXPECT_EQ(child4.get(), child4->rootLayer());
EXPECT_EQ(m_parent.get(), m_grandChild1->rootLayer());
EXPECT_EQ(m_parent.get(), m_grandChild2->rootLayer());
EXPECT_EQ(m_parent.get(), m_grandChild3->rootLayer());
m_child1->removeFromParent();
EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
EXPECT_EQ(m_child1.get(), m_child1->rootLayer());
EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
EXPECT_EQ(child4.get(), child4->rootLayer());
EXPECT_EQ(m_child1.get(), m_grandChild1->rootLayer());
EXPECT_EQ(m_child1.get(), m_grandChild2->rootLayer());
EXPECT_EQ(m_parent.get(), m_grandChild3->rootLayer());
m_grandChild3->addChild(child4);
EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
EXPECT_EQ(m_child1.get(), m_child1->rootLayer());
EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
EXPECT_EQ(m_parent.get(), child4->rootLayer());
EXPECT_EQ(m_child1.get(), m_grandChild1->rootLayer());
EXPECT_EQ(m_child1.get(), m_grandChild2->rootLayer());
EXPECT_EQ(m_parent.get(), m_grandChild3->rootLayer());
m_child2->replaceChild(m_grandChild3.get(), m_child1);
EXPECT_EQ(m_parent.get(), m_parent->rootLayer());
EXPECT_EQ(m_parent.get(), m_child1->rootLayer());
EXPECT_EQ(m_parent.get(), m_child2->rootLayer());
EXPECT_EQ(m_parent.get(), m_child3->rootLayer());
EXPECT_EQ(m_grandChild3.get(), child4->rootLayer());
EXPECT_EQ(m_parent.get(), m_grandChild1->rootLayer());
EXPECT_EQ(m_parent.get(), m_grandChild2->rootLayer());
EXPECT_EQ(m_grandChild3.get(), m_grandChild3->rootLayer());
}
TEST_F(LayerChromiumTest, checkSetNeedsDisplayCausesCorrectBehavior)
{
RefPtr<LayerChromium> testLayer = LayerChromium::create();
testLayer->setLayerTreeHost(m_layerTreeHost.get());
IntSize testBounds = IntSize(501, 508);
FloatRect dirty1 = FloatRect(10.0f, 15.0f, 1.0f, 2.0f);
FloatRect dirty2 = FloatRect(20.0f, 25.0f, 3.0f, 4.0f);
FloatRect emptyDirtyRect = FloatRect(40.0f, 45.0f, 0, 0);
FloatRect outOfBoundsDirtyRect = FloatRect(400.0f, 405.0f, 500.0f, 502.0f);
EXPECT_FALSE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(testBounds));
testLayer = LayerChromium::create();
testLayer->setLayerTreeHost(m_layerTreeHost.get());
EXPECT_FALSE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(emptyDirtyRect));
EXPECT_FALSE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(dirty1));
EXPECT_TRUE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(dirty2));
EXPECT_TRUE(testLayer->needsDisplay());
testLayer = LayerChromium::create();
testLayer->setLayerTreeHost(m_layerTreeHost.get());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(testBounds));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplayRect(outOfBoundsDirtyRect));
EXPECT_TRUE(testLayer->needsDisplay());
testLayer = LayerChromium::create();
testLayer->setLayerTreeHost(m_layerTreeHost.get());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(testBounds));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setNeedsDisplay());
EXPECT_TRUE(testLayer->needsDisplay());
}
TEST_F(LayerChromiumTest, checkPropertyChangeCausesCorrectBehavior)
{
RefPtr<LayerChromium> testLayer = LayerChromium::create();
testLayer->setLayerTreeHost(m_layerTreeHost.get());
RefPtr<LayerChromium> dummyLayer = LayerChromium::create();
EXPECT_FALSE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setVisibleLayerRect(IntRect(0, 0, 40, 50)));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setUsesLayerClipping(true));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setIsNonCompositedContent(true));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setDrawOpacity(0.5f));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setClipRect(IntRect(3, 3, 8, 8)));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setTargetRenderSurface(0));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setDrawTransform(TransformationMatrix()));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setScreenSpaceTransform(TransformationMatrix()));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(0, testLayer->setDrawableContentRect(IntRect(4, 5, 6, 7)));
EXPECT_FALSE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setAnchorPoint(FloatPoint(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(Color(0.4f, 0.4f, 0.4f, 1.0f)));
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.5f));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setOpaque(true));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setPosition(FloatPoint(4.0f, 9.0f)));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setReplicaLayer(dummyLayer.get()));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setSublayerTransform(TransformationMatrix(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(Region(IntRect(1, 1, 2, 2))));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setHaveWheelEventHandlers(true));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setScrollPosition(IntPoint(10, 10)));
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setTransform(TransformationMatrix(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()));
EXPECT_FALSE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(IntSize(5, 10)));
EXPECT_TRUE(testLayer->needsDisplay());
}
TEST_F(LayerChromiumTest, verifyPushPropertiesAccumulatesUpdateRect)
{
DebugScopedSetImplThread setImplThread;
RefPtr<LayerChromium> testLayer = LayerChromium::create();
OwnPtr<CCLayerImpl> implLayer = CCLayerImpl::create(1);
testLayer->setNeedsDisplayRect(FloatRect(FloatPoint::zero(), FloatSize(5, 5)));
testLayer->pushPropertiesTo(implLayer.get());
EXPECT_FLOAT_RECT_EQ(FloatRect(FloatPoint::zero(), FloatSize(5, 5)), implLayer->updateRect());
testLayer->setNeedsDisplayRect(FloatRect(FloatPoint(10, 10), FloatSize(5, 5)));
testLayer->pushPropertiesTo(implLayer.get());
EXPECT_FLOAT_RECT_EQ(FloatRect(FloatPoint::zero(), FloatSize(15, 15)), implLayer->updateRect());
implLayer->resetAllChangeTrackingForSubtree();
testLayer->setNeedsDisplayRect(FloatRect(FloatPoint(10, 10), FloatSize(5, 5)));
testLayer->pushPropertiesTo(implLayer.get());
EXPECT_FLOAT_RECT_EQ(FloatRect(FloatPoint(10, 10), FloatSize(5, 5)), implLayer->updateRect());
}
class LayerChromiumWithContentScaling : public LayerChromium {
public:
explicit LayerChromiumWithContentScaling()
: LayerChromium()
{
}
virtual bool needsContentsScale() const OVERRIDE
{
return true;
}
virtual void setNeedsDisplayRect(const FloatRect& dirtyRect) OVERRIDE
{
m_lastNeedsDisplayRect = dirtyRect;
LayerChromium::setNeedsDisplayRect(dirtyRect);
}
void resetNeedsDisplay()
{
m_needsDisplay = false;
}
const FloatRect& lastNeedsDisplayRect() const { return m_lastNeedsDisplayRect; }
private:
FloatRect m_lastNeedsDisplayRect;
};
TEST_F(LayerChromiumTest, checkContentsScaleChangeTriggersNeedsDisplay)
{
RefPtr<LayerChromiumWithContentScaling> testLayer = adoptRef(new LayerChromiumWithContentScaling());
testLayer->setLayerTreeHost(m_layerTreeHost.get());
IntSize testBounds = IntSize(320, 240);
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setBounds(testBounds));
testLayer->resetNeedsDisplay();
EXPECT_FALSE(testLayer->needsDisplay());
EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setContentsScale(testLayer->contentsScale() + 1.f));
EXPECT_TRUE(testLayer->needsDisplay());
EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 320, 240), testLayer->lastNeedsDisplayRect());
}
class FakeCCLayerTreeHost : public CCLayerTreeHost {
public:
static PassOwnPtr<FakeCCLayerTreeHost> create()
{
OwnPtr<FakeCCLayerTreeHost> host(adoptPtr(new FakeCCLayerTreeHost));
host->initialize();
return host.release();
}
private:
FakeCCLayerTreeHost()
: CCLayerTreeHost(&m_client, CCSettings())
{
}
FakeCCLayerTreeHostClient m_client;
};
void assertLayerTreeHostMatchesForSubtree(LayerChromium* layer, CCLayerTreeHost* host)
{
EXPECT_EQ(host, layer->layerTreeHost());
for (size_t i = 0; i < layer->children().size(); ++i)
assertLayerTreeHostMatchesForSubtree(layer->children()[i].get(), host);
if (layer->maskLayer())
assertLayerTreeHostMatchesForSubtree(layer->maskLayer(), host);
if (layer->replicaLayer())
assertLayerTreeHostMatchesForSubtree(layer->replicaLayer(), host);
}
TEST(LayerChromiumLayerTreeHostTest, enteringTree)
{
WebKit::WebCompositor::initialize(0);
RefPtr<LayerChromium> parent = LayerChromium::create();
RefPtr<LayerChromium> child = LayerChromium::create();
RefPtr<LayerChromium> mask = LayerChromium::create();
RefPtr<LayerChromium> replica = LayerChromium::create();
RefPtr<LayerChromium> replicaMask = LayerChromium::create();
parent->addChild(child);
child->setMaskLayer(mask.get());
child->setReplicaLayer(replica.get());
replica->setMaskLayer(mask.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
OwnPtr<FakeCCLayerTreeHost> layerTreeHost(FakeCCLayerTreeHost::create());
layerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
layerTreeHost->setRootLayer(0);
assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
layerTreeHost.clear();
WebKit::WebCompositor::shutdown();
}
TEST(LayerChromiumLayerTreeHostTest, addingLayerSubtree)
{
WebKit::WebCompositor::initialize(0);
RefPtr<LayerChromium> parent = LayerChromium::create();
OwnPtr<FakeCCLayerTreeHost> layerTreeHost(FakeCCLayerTreeHost::create());
layerTreeHost->setRootLayer(parent.get());
EXPECT_EQ(parent->layerTreeHost(), layerTreeHost.get());
RefPtr<LayerChromium> child = LayerChromium::create();
RefPtr<LayerChromium> grandChild = LayerChromium::create();
child->addChild(grandChild);
RefPtr<LayerChromium> childMask = LayerChromium::create();
child->setMaskLayer(childMask.get());
RefPtr<LayerChromium> childReplica = LayerChromium::create();
child->setReplicaLayer(childReplica.get());
RefPtr<LayerChromium> childReplicaMask = LayerChromium::create();
childReplica->setMaskLayer(childReplicaMask.get());
parent->addChild(child);
assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
layerTreeHost->setRootLayer(0);
layerTreeHost.clear();
WebKit::WebCompositor::shutdown();
}
TEST(LayerChromiumLayerTreeHostTest, changeHost)
{
WebKit::WebCompositor::initialize(0);
RefPtr<LayerChromium> parent = LayerChromium::create();
RefPtr<LayerChromium> child = LayerChromium::create();
RefPtr<LayerChromium> mask = LayerChromium::create();
RefPtr<LayerChromium> replica = LayerChromium::create();
RefPtr<LayerChromium> replicaMask = LayerChromium::create();
parent->addChild(child);
child->setMaskLayer(mask.get());
child->setReplicaLayer(replica.get());
replica->setMaskLayer(mask.get());
OwnPtr<FakeCCLayerTreeHost> firstLayerTreeHost(FakeCCLayerTreeHost::create());
firstLayerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), firstLayerTreeHost.get());
OwnPtr<FakeCCLayerTreeHost> secondLayerTreeHost(FakeCCLayerTreeHost::create());
secondLayerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), secondLayerTreeHost.get());
secondLayerTreeHost->setRootLayer(0);
firstLayerTreeHost.clear();
secondLayerTreeHost.clear();
WebKit::WebCompositor::shutdown();
}
TEST(LayerChromiumLayerTreeHostTest, changeHostInSubtree)
{
WebKit::WebCompositor::initialize(0);
RefPtr<LayerChromium> firstParent = LayerChromium::create();
RefPtr<LayerChromium> firstChild = LayerChromium::create();
RefPtr<LayerChromium> secondParent = LayerChromium::create();
RefPtr<LayerChromium> secondChild = LayerChromium::create();
RefPtr<LayerChromium> secondGrandChild = LayerChromium::create();
firstParent->addChild(firstChild);
secondChild->addChild(secondGrandChild);
firstParent->addChild(secondChild);
OwnPtr<FakeCCLayerTreeHost> firstLayerTreeHost(FakeCCLayerTreeHost::create());
firstLayerTreeHost->setRootLayer(firstParent.get());
assertLayerTreeHostMatchesForSubtree(firstParent.get(), firstLayerTreeHost.get());
OwnPtr<FakeCCLayerTreeHost> secondLayerTreeHost(FakeCCLayerTreeHost::create());
secondLayerTreeHost->setRootLayer(secondParent.get());
secondParent->addChild(secondChild);
EXPECT_EQ(secondLayerTreeHost.get(), secondChild->layerTreeHost());
EXPECT_EQ(secondLayerTreeHost.get(), secondGrandChild->layerTreeHost());
firstLayerTreeHost->setRootLayer(0);
secondLayerTreeHost->setRootLayer(0);
firstLayerTreeHost.clear();
secondLayerTreeHost.clear();
WebKit::WebCompositor::shutdown();
}
TEST(LayerChromiumLayerTreeHostTest, replaceMaskAndReplicaLayer)
{
WebKit::WebCompositor::initialize(0);
RefPtr<LayerChromium> parent = LayerChromium::create();
RefPtr<LayerChromium> mask = LayerChromium::create();
RefPtr<LayerChromium> replica = LayerChromium::create();
RefPtr<LayerChromium> maskChild = LayerChromium::create();
RefPtr<LayerChromium> replicaChild = LayerChromium::create();
RefPtr<LayerChromium> maskReplacement = LayerChromium::create();
RefPtr<LayerChromium> replicaReplacement = LayerChromium::create();
parent->setMaskLayer(mask.get());
parent->setReplicaLayer(replica.get());
mask->addChild(maskChild);
replica->addChild(replicaChild);
OwnPtr<FakeCCLayerTreeHost> layerTreeHost(FakeCCLayerTreeHost::create());
layerTreeHost->setRootLayer(parent.get());
assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
parent->setMaskLayer(maskReplacement.get());
EXPECT_EQ(0, mask->layerTreeHost());
EXPECT_EQ(0, maskChild->layerTreeHost());
parent->setReplicaLayer(replicaReplacement.get());
EXPECT_EQ(0, replica->layerTreeHost());
EXPECT_EQ(0, replicaChild->layerTreeHost());
layerTreeHost->setRootLayer(0);
layerTreeHost.clear();
WebKit::WebCompositor::shutdown();
}
}