cc: Pass LayerTreeHostImpl to LayerImpl constructor

cc/tree_synchronizer_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/tree_synchronizer.h"
 
 #include <algorithm>
 
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
 #include "cc/proxy.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using namespace WebKitTests;
 
 namespace cc {
 namespace {
 
 class MockLayerImpl : public LayerImpl {
 public:
-    static scoped_ptr<MockLayerImpl> create(int layerId)
+    static scoped_ptr<MockLayerImpl> create(LayerTreeHostImpl* hostImpl, int layerId)
     {
-        return make_scoped_ptr(new MockLayerImpl(layerId));
+        return make_scoped_ptr(new MockLayerImpl(hostImpl, layerId));
     }
     virtual ~MockLayerImpl()
     {
         if (m_layerImplDestructionList)
             m_layerImplDestructionList->push_back(id());
     }
 
     void setLayerImplDestructionList(std::vector<int>* list) { m_layerImplDestructionList = list; }
 
 private:
-    MockLayerImpl(int layerId)
-        : LayerImpl(layerId)
+    MockLayerImpl(LayerTreeHostImpl* hostImpl, int layerId)
+        : LayerImpl(hostImpl, layerId)
         , m_layerImplDestructionList(0)
     {
     }
 
     std::vector<int>* m_layerImplDestructionList;
 };
 
 class MockLayer : public Layer {
 public:
     static scoped_refptr<MockLayer> create(std::vector<int>* layerImplDestructionList)
     {
         return make_scoped_refptr(new MockLayer(layerImplDestructionList));
     }
 
-    virtual scoped_ptr<LayerImpl> createLayerImpl() OVERRIDE
+    virtual scoped_ptr<LayerImpl> createLayerImpl(LayerTreeHostImpl* hostImpl) OVERRIDE
     {
-        return MockLayerImpl::create(m_layerId).PassAs<LayerImpl>();
+        return MockLayerImpl::create(hostImpl, m_layerId).PassAs<LayerImpl>();
     }
 
     virtual void pushPropertiesTo(LayerImpl* layerImpl) OVERRIDE
     {
         Layer::pushPropertiesTo(layerImpl);
 
         MockLayerImpl* mockLayerImpl = static_cast<MockLayerImpl*>(layerImpl);
         mockLayerImpl->setLayerImplDestructionList(m_layerImplDestructionList);
     }
 
@@ skipping 333 matching lines @@
     EXPECT_FALSE(static_cast<FakeLayerAnimationController*>(layerTreeRoot->layerAnimationController())->synchronizedAnimations());
 
     scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), hostImpl.get());
     layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), hostImpl.get());
 
     EXPECT_TRUE(static_cast<FakeLayerAnimationController*>(layerTreeRoot->layerAnimationController())->synchronizedAnimations());
 }
 
 }  // namespace
 }  // namespace cc