Remove WebKit::Platform dependencies from cc

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 "config.h"
 
 #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/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/test_common.h"
-#include "cc/test/web_compositor_initializer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebTransformationMatrix.h>
 
 using namespace cc;
 using namespace WebKitTests;
 using WebKit::WebTransformationMatrix;
 using ::testing::Mock;
 using ::testing::_;
 using ::testing::AtLeast;
@@ skipping 23 matching lines @@
 
 class MockLayerPainter : public LayerPainter {
 public:
     virtual void paint(SkCanvas*, const IntRect&, FloatRect&) OVERRIDE { }
 };
 
 
 class LayerTest : public testing::Test {
 public:
     LayerTest()
-        : m_compositorInitializer(0)
     {
     }
 
 protected:
     virtual void SetUp()
     {
         m_layerTreeHost = scoped_ptr<MockLayerImplTreeHost>(new MockLayerImplTreeHost);
     }
 
     virtual void TearDown()
@@ skipping 55 matching lines @@
         m_child1->addChild(m_grandChild2);
         m_child2->addChild(m_grandChild3);
 
         Mock::VerifyAndClearExpectations(m_layerTreeHost.get());
 
         verifyTestTreeInitialState();
     }
 
     scoped_ptr<MockLayerImplTreeHost> m_layerTreeHost;
     scoped_refptr<Layer> m_parent, m_child1, m_child2, m_child3, m_grandChild1, m_grandChild2, m_grandChild3;
-    WebCompositorInitializer m_compositorInitializer;
 };
 
 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());
 }
@@ skipping 482 matching lines @@
     if (layer->maskLayer())
         assertLayerTreeHostMatchesForSubtree(layer->maskLayer(), host);
 
     if (layer->replicaLayer())
         assertLayerTreeHostMatchesForSubtree(layer->replicaLayer(), host);
 }
 
 
 TEST(LayerLayerTreeHostTest, enteringTree)
 {
-    WebCompositorInitializer compositorInitializer(0);
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> mask = Layer::create();
     scoped_refptr<Layer> replica = Layer::create();
     scoped_refptr<Layer> replicaMask = Layer::create();
 
     // Set up a detached tree of layers. The host pointer should be nil for these layers.
     parent->addChild(child);
     child->setMaskLayer(mask.get());
     child->setReplicaLayer(replica.get());
     replica->setMaskLayer(mask.get());
 
     assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
 
     scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
     // Setting the root layer should set the host pointer for all layers in the tree.
     layerTreeHost->setRootLayer(parent.get());
 
     assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
 
     // Clearing the root layer should also clear out the host pointers for all layers in the tree.
     layerTreeHost->setRootLayer(0);
 
     assertLayerTreeHostMatchesForSubtree(parent.get(), 0);
 }
 
 TEST(LayerLayerTreeHostTest, addingLayerSubtree)
 {
-    WebCompositorInitializer compositorInitializer(0);
     scoped_refptr<Layer> parent = Layer::create();
     scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
 
     layerTreeHost->setRootLayer(parent.get());
 
     EXPECT_EQ(parent->layerTreeHost(), layerTreeHost.get());
 
     // Adding a subtree to a layer already associated with a host should set the host pointer on all layers in that subtree.
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> grandChild = Layer::create();
     child->addChild(grandChild);
 
     // Masks, replicas, and replica masks should pick up the new host too.
     scoped_refptr<Layer> childMask = Layer::create();
     child->setMaskLayer(childMask.get());
     scoped_refptr<Layer> childReplica = Layer::create();
     child->setReplicaLayer(childReplica.get());
     scoped_refptr<Layer> childReplicaMask = Layer::create();
     childReplica->setMaskLayer(childReplicaMask.get());
 
     parent->addChild(child);
     assertLayerTreeHostMatchesForSubtree(parent.get(), layerTreeHost.get());
 
     layerTreeHost->setRootLayer(0);
 }
 
 TEST(LayerLayerTreeHostTest, changeHost)
 {
-    WebCompositorInitializer compositorInitializer(0);
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<Layer> mask = Layer::create();
     scoped_refptr<Layer> replica = Layer::create();
     scoped_refptr<Layer> replicaMask = Layer::create();
 
     // Same setup as the previous test.
     parent->addChild(child);
     child->setMaskLayer(mask.get());
     child->setReplicaLayer(replica.get());
     replica->setMaskLayer(mask.get());
 
     scoped_ptr<FakeLayerImplTreeHost> firstLayerTreeHost(FakeLayerImplTreeHost::create());
     firstLayerTreeHost->setRootLayer(parent.get());
 
     assertLayerTreeHostMatchesForSubtree(parent.get(), firstLayerTreeHost.get());
 
     // Now re-root the tree to a new host (simulating what we do on a context lost event).
     // This should update the host pointers for all layers in the tree.
     scoped_ptr<FakeLayerImplTreeHost> secondLayerTreeHost(FakeLayerImplTreeHost::create());
     secondLayerTreeHost->setRootLayer(parent.get());
 
     assertLayerTreeHostMatchesForSubtree(parent.get(), secondLayerTreeHost.get());
 
     secondLayerTreeHost->setRootLayer(0);
 }
 
 TEST(LayerLayerTreeHostTest, changeHostInSubtree)
 {
-    WebCompositorInitializer compositorInitializer(0);
     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);
@@ skipping 13 matching lines @@
     EXPECT_EQ(secondLayerTreeHost.get(), secondChild->layerTreeHost());
     EXPECT_EQ(secondLayerTreeHost.get(), secondGrandChild->layerTreeHost());
 
     // Test over, cleanup time.
     firstLayerTreeHost->setRootLayer(0);
     secondLayerTreeHost->setRootLayer(0);
 }
 
 TEST(LayerLayerTreeHostTest, replaceMaskAndReplicaLayer)
 {
-    WebCompositorInitializer compositorInitializer(0);
     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());
@@ skipping 14 matching lines @@
     parent->setReplicaLayer(replicaReplacement.get());
     EXPECT_EQ(0, replica->layerTreeHost());
     EXPECT_EQ(0, replicaChild->layerTreeHost());
 
     // Test over, cleanup time.
     layerTreeHost->setRootLayer(0);
 }
 
 TEST(LayerLayerTreeHostTest, destroyHostWithNonNullRootLayer)
 {
-    WebCompositorInitializer compositorInitializer(0);
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     root->addChild(child);
     scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
     layerTreeHost->setRootLayer(root);
 }
 
 static bool addTestAnimation(Layer* layer)
 {
     scoped_ptr<KeyframedFloatAnimationCurve> curve(KeyframedFloatAnimationCurve::create());
     curve->addKeyframe(FloatKeyframe::create(0, 0.3f, scoped_ptr<TimingFunction>()));
     curve->addKeyframe(FloatKeyframe::create(1, 0.7f, scoped_ptr<TimingFunction>()));
     scoped_ptr<ActiveAnimation> animation(ActiveAnimation::create(curve.PassAs<AnimationCurve>(), 0, 0, ActiveAnimation::Opacity));
 
     return layer->addAnimation(animation.Pass());
 }
 
 TEST(LayerLayerTreeHostTest, shouldNotAddAnimationWithoutLayerTreeHost)
 {
     // Currently, WebCore assumes that animations will be started immediately / very soon
     // if a composited layer's addAnimation() returns true. However, without a layerTreeHost,
     // layers cannot actually animate yet. So, to prevent violating this WebCore assumption,
     // the animation should not be accepted if the layer doesn't already have a layerTreeHost.
 
     ScopedSettings scopedSettings;
     Settings::setAcceleratedAnimationEnabled(true);
 
-    WebCompositorInitializer compositorInitializer(0);
     scoped_refptr<Layer> layer = Layer::create();
 
     // Case 1: without a layerTreeHost, the animation should not be accepted.
     EXPECT_FALSE(addTestAnimation(layer.get()));
 
     scoped_ptr<FakeLayerImplTreeHost> layerTreeHost(FakeLayerImplTreeHost::create());
     layerTreeHost->setRootLayer(layer.get());
     layer->setLayerTreeHost(layerTreeHost.get());
     assertLayerTreeHostMatchesForSubtree(layer.get(), layerTreeHost.get());
 
@@ skipping 16 matching lines @@
     scoped_refptr<MockLayer> layer(new MockLayer);
     EXPECT_FALSE(layer->needsDisplay());
     layer->setBounds(IntSize(0, 10));
     EXPECT_FALSE(layer->needsDisplay());
     layer->setBounds(IntSize(10, 10));
     EXPECT_TRUE(layer->needsDisplay());
 }
 
 
 } // namespace