cc: Pass LayerTreeHostImpl to LayerImpl constructor

cc/layer_tree_host_impl_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_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 85 matching lines @@
     virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
     virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
     virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
     virtual void setNeedsManageTilesOnImplThread() OVERRIDE { }
     virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE { }
     virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE { return m_reduceMemoryResult; }
     virtual void sendManagedMemoryStats() OVERRIDE { }
 
     void setReduceMemoryResult(bool reduceMemoryResult) { m_reduceMemoryResult = reduceMemoryResult; }
 
-    scoped_ptr<LayerTreeHostImpl> createLayerTreeHost(bool partialSwap, scoped_ptr<OutputSurface> outputSurface, scoped_ptr<LayerImpl> root)
+    void createLayerTreeHost(bool partialSwap, scoped_ptr<OutputSurface> outputSurface)
     {
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
         settings.partialSwapEnabled = partialSwap;
 
-        scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+        m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
-        myHostImpl->initializeRenderer(outputSurface.Pass());
-        myHostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+        m_hostImpl->initializeRenderer(outputSurface.Pass());
+        m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+    }
 
+    void setupRootLayerImpl(scoped_ptr<LayerImpl> root)
+    {
         root->setAnchorPoint(gfx::PointF(0, 0));
         root->setPosition(gfx::PointF(0, 0));
         root->setBounds(gfx::Size(10, 10));
         root->setContentBounds(gfx::Size(10, 10));
         root->setDrawsContent(true);
         root->drawProperties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
-        myHostImpl->setRootLayer(root.Pass());
-        return myHostImpl.Pass();
+        m_hostImpl->setRootLayer(root.Pass());
     }
 
     static void expectClearedScrollDeltasRecursive(LayerImpl* layer)
     {
         ASSERT_EQ(layer->scrollDelta(), gfx::Vector2d());
         for (size_t i = 0; i < layer->children().size(); ++i)
             expectClearedScrollDeltasRecursive(layer->children()[i]);
     }
 
     static void expectContains(const ScrollAndScaleSet& scrollInfo, int id, const gfx::Vector2d& scrollDelta)
@@ skipping 18 matching lines @@
             if (scrollInfo.scrolls[i].layerId != id)
                 continue;
             timesEncountered++;
         }
 
         ASSERT_EQ(0, timesEncountered);
     }
 
     void setupScrollAndContentsLayers(const gfx::Size& contentSize)
     {
-        scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+        scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
         root->setScrollable(true);
         root->setScrollOffset(gfx::Vector2d(0, 0));
         root->setMaxScrollOffset(gfx::Vector2d(contentSize.width(), contentSize.height()));
         root->setBounds(contentSize);
         root->setContentBounds(contentSize);
         root->setPosition(gfx::PointF(0, 0));
         root->setAnchorPoint(gfx::PointF(0, 0));
 
-        scoped_ptr<LayerImpl> contents = LayerImpl::create(2);
+        scoped_ptr<LayerImpl> contents = LayerImpl::create(m_hostImpl.get(), 2);
         contents->setDrawsContent(true);
         contents->setBounds(contentSize);
         contents->setContentBounds(contentSize);
         contents->setPosition(gfx::PointF(0, 0));
         contents->setAnchorPoint(gfx::PointF(0, 0));
         root->addChild(contents.Pass());
         m_hostImpl->setRootLayer(root.Pass());
     }
 
-    static scoped_ptr<LayerImpl> createScrollableLayer(int id, const gfx::Size& size)
+    scoped_ptr<LayerImpl> createScrollableLayer(int id, const gfx::Size& size)
     {
-        scoped_ptr<LayerImpl> layer = LayerImpl::create(id);
+        scoped_ptr<LayerImpl> layer = LayerImpl::create(m_hostImpl.get(), id);
         layer->setScrollable(true);
         layer->setDrawsContent(true);
         layer->setBounds(size);
         layer->setContentBounds(size);
         layer->setMaxScrollOffset(gfx::Vector2d(size.width() * 2, size.height() * 2));
         return layer.Pass();
     }
 
     void initializeRendererAndDrawFrame()
     {
@@ skipping 93 matching lines @@
 {
     ASSERT_FALSE(m_hostImpl->rootLayer());
 
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollDeltaTreeButNoChanges)
 {
     {
-        scoped_ptr<LayerImpl> root = LayerImpl::create(1);
-        root->addChild(LayerImpl::create(2));
-        root->addChild(LayerImpl::create(3));
-        root->children()[1]->addChild(LayerImpl::create(4));
-        root->children()[1]->addChild(LayerImpl::create(5));
-        root->children()[1]->children()[0]->addChild(LayerImpl::create(6));
+        scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
+        root->addChild(LayerImpl::create(m_hostImpl.get(), 2));
+        root->addChild(LayerImpl::create(m_hostImpl.get(), 3));
+        root->children()[1]->addChild(LayerImpl::create(m_hostImpl.get(), 4));
+        root->children()[1]->addChild(LayerImpl::create(m_hostImpl.get(), 5));
+        root->children()[1]->children()[0]->addChild(LayerImpl::create(m_hostImpl.get(), 6));
         m_hostImpl->setRootLayer(root.Pass());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
     expectClearedScrollDeltasRecursive(root);
 
     scoped_ptr<ScrollAndScaleSet> scrollInfo;
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollDeltaRepeatedScrolls)
 {
     gfx::Vector2d scrollOffset(20, 30);
     gfx::Vector2d scrollDelta(11, -15);
     {
-        scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+        scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
         root->setScrollOffset(scrollOffset);
         root->setScrollable(true);
         root->setMaxScrollOffset(gfx::Vector2d(100, 100));
         root->scrollBy(scrollDelta);
         m_hostImpl->setRootLayer(root.Pass());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
     scoped_ptr<ScrollAndScaleSet> scrollInfo;
 
@@ skipping 534 matching lines @@
     // The final page scale and scroll deltas should match what we got
     // earlier.
     m_hostImpl->animate(endTime, base::Time());
     scrollInfo = m_hostImpl->processScrollDeltas();
     EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
     expectContains(*scrollInfo, scrollLayer->id(), scaledTarget);
 }
 
 class DidDrawCheckLayer : public TiledLayerImpl {
 public:
-    static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new DidDrawCheckLayer(id)); }
+    static scoped_ptr<LayerImpl> create(LayerTreeHostImpl* hostImpl, int id) { return scoped_ptr<LayerImpl>(new DidDrawCheckLayer(hostImpl, id)); }
 
     virtual void didDraw(ResourceProvider*) OVERRIDE
     {
         m_didDrawCalled = true;
     }
 
     virtual void willDraw(ResourceProvider*) OVERRIDE
     {
         m_willDrawCalled = true;
     }
 
     bool didDrawCalled() const { return m_didDrawCalled; }
     bool willDrawCalled() const { return m_willDrawCalled; }
 
     void clearDidDrawCheck()
     {
         m_didDrawCalled = false;
         m_willDrawCalled = false;
     }
 
 protected:
-    explicit DidDrawCheckLayer(int id)
-        : TiledLayerImpl(id)
+    DidDrawCheckLayer(LayerTreeHostImpl* hostImpl, int id)
+        : TiledLayerImpl(hostImpl, id)
         , m_didDrawCalled(false)
         , m_willDrawCalled(false)
     {
         setAnchorPoint(gfx::PointF(0, 0));
         setBounds(gfx::Size(10, 10));
         setContentBounds(gfx::Size(10, 10));
         setDrawsContent(true);
         setSkipsDraw(false);
         drawProperties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
 
         scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(gfx::Size(100, 100), LayerTilingData::HasBorderTexels);
         tiler->setBounds(contentBounds());
         setTilingData(*tiler.get());
     }
 
 private:
     bool m_didDrawCalled;
     bool m_willDrawCalled;
 };
 
 TEST_P(LayerTreeHostImplTest, didDrawNotCalledOnHiddenLayer)
 {
     // The root layer is always drawn, so run this test on a child layer that
     // will be masked out by the root layer's bounds.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(m_hostImpl.get(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->setMasksToBounds(true);
 
-    root->addChild(DidDrawCheckLayer::create(2));
+    root->addChild(DidDrawCheckLayer::create(m_hostImpl.get(), 2));
     DidDrawCheckLayer* layer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
     // Ensure visibleContentRect for layer is empty
     layer->setPosition(gfx::PointF(100, 100));
     layer->setBounds(gfx::Size(10, 10));
     layer->setContentBounds(gfx::Size(10, 10));
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_FALSE(layer->willDrawCalled());
     EXPECT_FALSE(layer->didDrawCalled());
@@ skipping 21 matching lines @@
     EXPECT_TRUE(layer->didDrawCalled());
 
     EXPECT_FALSE(layer->visibleContentRect().IsEmpty());
 }
 
 TEST_P(LayerTreeHostImplTest, willDrawNotCalledOnOccludedLayer)
 {
     gfx::Size bigSize(1000, 1000);
     m_hostImpl->setViewportSize(bigSize, bigSize);
 
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(m_hostImpl.get(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
-    root->addChild(DidDrawCheckLayer::create(2));
+    root->addChild(DidDrawCheckLayer::create(m_hostImpl.get(), 2));
     DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
-    root->addChild(DidDrawCheckLayer::create(3));
+    root->addChild(DidDrawCheckLayer::create(m_hostImpl.get(), 3));
     DidDrawCheckLayer* topLayer = static_cast<DidDrawCheckLayer*>(root->children()[1]);
     // This layer covers the occludedLayer above. Make this layer large so it can occlude.
     topLayer->setBounds(bigSize);
     topLayer->setContentBounds(bigSize);
     topLayer->setContentsOpaque(true);
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_FALSE(occludedLayer->willDrawCalled());
     EXPECT_FALSE(occludedLayer->didDrawCalled());
     EXPECT_FALSE(topLayer->willDrawCalled());
     EXPECT_FALSE(topLayer->didDrawCalled());
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     EXPECT_FALSE(occludedLayer->willDrawCalled());
     EXPECT_FALSE(occludedLayer->didDrawCalled());
     EXPECT_TRUE(topLayer->willDrawCalled());
     EXPECT_TRUE(topLayer->didDrawCalled());
 }
 
 TEST_P(LayerTreeHostImplTest, didDrawCalledOnAllLayers)
 {
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(m_hostImpl.get(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
-    root->addChild(DidDrawCheckLayer::create(2));
+    root->addChild(DidDrawCheckLayer::create(m_hostImpl.get(), 2));
     DidDrawCheckLayer* layer1 = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
-    layer1->addChild(DidDrawCheckLayer::create(3));
+    layer1->addChild(DidDrawCheckLayer::create(m_hostImpl.get(), 3));
     DidDrawCheckLayer* layer2 = static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
 
     layer1->setOpacity(0.3f);
     layer1->setPreserves3D(false);
 
     EXPECT_FALSE(root->didDrawCalled());
     EXPECT_FALSE(layer1->didDrawCalled());
     EXPECT_FALSE(layer2->didDrawCalled());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     EXPECT_TRUE(root->didDrawCalled());
     EXPECT_TRUE(layer1->didDrawCalled());
     EXPECT_TRUE(layer2->didDrawCalled());
 
     EXPECT_NE(root->renderSurface(), layer1->renderSurface());
     EXPECT_TRUE(!!layer1->renderSurface());
 }
 
 class MissingTextureAnimatingLayer : public DidDrawCheckLayer {
 public:
-    static scoped_ptr<LayerImpl> create(int id, bool tileMissing, bool skipsDraw, bool animating, ResourceProvider* resourceProvider)
+    static scoped_ptr<LayerImpl> create(LayerTreeHostImpl* hostImpl, int id, bool tileMissing, bool skipsDraw, bool animating, ResourceProvider* resourceProvider)
     {
-        return scoped_ptr<LayerImpl>(new MissingTextureAnimatingLayer(id, tileMissing, skipsDraw, animating, resourceProvider));
+        return scoped_ptr<LayerImpl>(new MissingTextureAnimatingLayer(hostImpl, id, tileMissing, skipsDraw, animating, resourceProvider));
     }
 
 private:
-    explicit MissingTextureAnimatingLayer(int id, bool tileMissing, bool skipsDraw, bool animating, ResourceProvider* resourceProvider)
-        : DidDrawCheckLayer(id)
+    MissingTextureAnimatingLayer(LayerTreeHostImpl* hostImpl, int id, bool tileMissing, bool skipsDraw, bool animating, ResourceProvider* resourceProvider)
+        : DidDrawCheckLayer(hostImpl, id)
     {
         scoped_ptr<LayerTilingData> tilingData = LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::NoBorderTexels);
         tilingData->setBounds(bounds());
         setTilingData(*tilingData.get());
         setSkipsDraw(skipsDraw);
         if (!tileMissing) {
             ResourceProvider::ResourceId resource = resourceProvider->createResource(Renderer::ContentPool, gfx::Size(), GL_RGBA, ResourceProvider::TextureUsageAny);
             pushTileProperties(0, 0, resource, gfx::Rect(), false);
         }
         if (animating)
             addAnimatedTransformToLayer(*this, 10, 3, 0);
     }
 };
 
 TEST_P(LayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
 {
     // When the texture is not missing, we draw as usual.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(m_hostImpl.get(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(2, false, false, true, m_hostImpl->resourceProvider()));
+    root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl.get(), 2, false, false, true, m_hostImpl->resourceProvider()));
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     // When a texture is missing and we're not animating, we draw as usual with checkerboarding.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(m_hostImpl.get(), 1));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(2, true, false, false, m_hostImpl->resourceProvider()));
+    root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl.get(), 2, true, false, false, m_hostImpl->resourceProvider()));
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     // When a texture is missing and we're animating, we don't want to draw anything.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(m_hostImpl.get(), 1));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(2, true, false, true, m_hostImpl->resourceProvider()));
+    root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl.get(), 2, true, false, true, m_hostImpl->resourceProvider()));
 
     EXPECT_FALSE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     // When the layer skips draw and we're animating, we still draw the frame.
-    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
+    m_hostImpl->setRootLayer(DidDrawCheckLayer::create(m_hostImpl.get(), 1));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
-    root->addChild(MissingTextureAnimatingLayer::create(2, false, true, true, m_hostImpl->resourceProvider()));
+    root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl.get(), 2, false, true, true, m_hostImpl->resourceProvider()));
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootIgnored)
 {
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
     root->setScrollable(false);
     m_hostImpl->setRootLayer(root.Pass());
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because layer is not scrollable.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollNonCompositedRoot)
 {
     // Test the configuration where a non-composited root layer is embedded in a
     // scrollable outer layer.
     gfx::Size surfaceSize(10, 10);
 
-    scoped_ptr<LayerImpl> contentLayer = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> contentLayer = LayerImpl::create(m_hostImpl.get(), 1);
     contentLayer->setUseLCDText(true);
     contentLayer->setDrawsContent(true);
     contentLayer->setPosition(gfx::PointF(0, 0));
     contentLayer->setAnchorPoint(gfx::PointF(0, 0));
     contentLayer->setBounds(surfaceSize);
     contentLayer->setContentBounds(gfx::Size(surfaceSize.width() * 2, surfaceSize.height() * 2));
     contentLayer->setContentsScale(2, 2);
 
-    scoped_ptr<LayerImpl> scrollLayer = LayerImpl::create(2);
+    scoped_ptr<LayerImpl> scrollLayer = LayerImpl::create(m_hostImpl.get(), 2);
     scrollLayer->setScrollable(true);
     scrollLayer->setMaxScrollOffset(gfx::Vector2d(surfaceSize.width(), surfaceSize.height()));
     scrollLayer->setBounds(surfaceSize);
     scrollLayer->setContentBounds(surfaceSize);
     scrollLayer->setPosition(gfx::PointF(0, 0));
     scrollLayer->setAnchorPoint(gfx::PointF(0, 0));
     scrollLayer->addChild(contentLayer.Pass());
 
     m_hostImpl->setRootLayer(scrollLayer.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
 {
     gfx::Size surfaceSize(10, 10);
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     root->addChild(createScrollableLayer(2, surfaceSize));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollMissesChild)
 {
     gfx::Size surfaceSize(10, 10);
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
     root->addChild(createScrollableLayer(2, surfaceSize));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because the input coordinate is outside the layer boundaries.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(15, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollMissesBackfacingChild)
 {
     gfx::Size surfaceSize(10, 10);
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
 
     gfx::Transform matrix;
     MathUtil::rotateEulerAngles(&matrix, 180, 0, 0);
     child->setTransform(matrix);
     child->setDoubleSided(false);
 
     root->addChild(child.Pass());
     m_hostImpl->setRootLayer(root.Pass());
@@ skipping 153 matching lines @@
     EXPECT_EQ(root->drawTransform().matrix().getDouble(1, 1), newPageScale);
     EXPECT_EQ(child->drawTransform().matrix().getDouble(0, 0), newPageScale);
     EXPECT_EQ(child->drawTransform().matrix().getDouble(1, 1), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().matrix().getDouble(0, 0), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().matrix().getDouble(1, 1), newPageScale);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
 {
     gfx::Size surfaceSize(10, 10);
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     // Also mark the root scrollable so it becomes the root scroll layer.
     root->setScrollable(true);
     int scrollLayerId = 2;
     root->addChild(createScrollableLayer(scrollLayerId, surfaceSize));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
@@ skipping 255 matching lines @@
     }
 
     bool blend() const { return m_blend; }
 
 private:
     bool m_blend;
 };
 
 class BlendStateCheckLayer : public LayerImpl {
 public:
-    static scoped_ptr<LayerImpl> create(int id, ResourceProvider* resourceProvider) { return scoped_ptr<LayerImpl>(new BlendStateCheckLayer(id, resourceProvider)); }
+    static scoped_ptr<LayerImpl> create(LayerTreeHostImpl* hostImpl, int id, ResourceProvider* resourceProvider) { return scoped_ptr<LayerImpl>(new BlendStateCheckLayer(hostImpl, id, resourceProvider)); }
 
     virtual void appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData) OVERRIDE
     {
         m_quadsAppended = true;
 
         gfx::Rect opaqueRect;
         if (contentsOpaque())
             opaqueRect = m_quadRect;
         else
             opaqueRect = m_opaqueContentRect;
@@ skipping 14 matching lines @@
         m_quadsAppended = false;
     }
 
     bool quadsAppended() const { return m_quadsAppended; }
 
     void setQuadRect(const gfx::Rect& rect) { m_quadRect = rect; }
     void setQuadVisibleRect(const gfx::Rect& rect) { m_quadVisibleRect = rect; }
     void setOpaqueContentRect(const gfx::Rect& rect) { m_opaqueContentRect = rect; }
 
 private:
-    explicit BlendStateCheckLayer(int id, ResourceProvider* resourceProvider)
-        : LayerImpl(id)
+    BlendStateCheckLayer(LayerTreeHostImpl* hostImpl, int id, ResourceProvider* resourceProvider)
+        : LayerImpl(hostImpl, id)
         , m_blend(false)
         , m_hasRenderSurface(false)
         , m_quadsAppended(false)
         , m_quadRect(5, 5, 5, 5)
         , m_quadVisibleRect(5, 5, 5, 5)
         , m_resourceId(resourceProvider->createResource(Renderer::ContentPool, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny))
     {
         setAnchorPoint(gfx::PointF(0, 0));
         setBounds(gfx::Size(10, 10));
         setContentBounds(gfx::Size(10, 10));
         setDrawsContent(true);
     }
 
     bool m_blend;
     bool m_hasRenderSurface;
     bool m_quadsAppended;
     gfx::Rect m_quadRect;
     gfx::Rect m_opaqueContentRect;
     gfx::Rect m_quadVisibleRect;
     ResourceProvider::ResourceId m_resourceId;
 };
 
 TEST_P(LayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
 {
     {
-        scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+        scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.get(), 1);
         root->setAnchorPoint(gfx::PointF(0, 0));
         root->setBounds(gfx::Size(10, 10));
         root->setContentBounds(root->bounds());
         root->setDrawsContent(false);
         m_hostImpl->setRootLayer(root.Pass());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
-    root->addChild(BlendStateCheckLayer::create(2, m_hostImpl->resourceProvider()));
+    root->addChild(BlendStateCheckLayer::create(m_hostImpl.get(), 2, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* layer1 = static_cast<BlendStateCheckLayer*>(root->children()[0]);
     layer1->setPosition(gfx::PointF(2, 2));
 
     LayerTreeHostImpl::FrameData frame;
 
     // Opaque layer, drawn without blending.
     layer1->setContentsOpaque(true);
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
@@ skipping 19 matching lines @@
 
     // Layer with translucent opacity and painting, drawn with blending.
     layer1->setContentsOpaque(true);
     layer1->setOpacity(0.5);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
-    layer1->addChild(BlendStateCheckLayer::create(3, m_hostImpl->resourceProvider()));
+    layer1->addChild(BlendStateCheckLayer::create(m_hostImpl.get(), 3, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
     layer2->setPosition(gfx::PointF(4, 4));
 
     // 2 opaque layers, drawn without blending.
     layer1->setContentsOpaque(true);
     layer1->setOpacity(1);
     layer1->setExpectation(false, false);
     layer2->setContentsOpaque(true);
     layer2->setOpacity(1);
     layer2->setExpectation(false, false);
@@ skipping 127 matching lines @@
 }
 
 TEST_P(LayerTreeHostImplTest, viewportCovered)
 {
     m_hostImpl->initializeRenderer(createOutputSurface());
     m_hostImpl->setBackgroundColor(SK_ColorGRAY);
 
     gfx::Size viewportSize(1000, 1000);
     m_hostImpl->setViewportSize(viewportSize, viewportSize);
 
-    m_hostImpl->setRootLayer(LayerImpl::create(1));
-    m_hostImpl->rootLayer()->addChild(BlendStateCheckLayer::create(2, m_hostImpl->resourceProvider()));
+    m_hostImpl->setRootLayer(LayerImpl::create(m_hostImpl.get(), 1));
+    m_hostImpl->rootLayer()->addChild(BlendStateCheckLayer::create(m_hostImpl.get(), 2, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* child = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer()->children()[0]);
     child->setExpectation(false, false);
     child->setContentsOpaque(true);
 
     // No gutter rects
     {
         gfx::Rect layerRect(0, 0, 1000, 1000);
         child->setPosition(layerRect.origin());
         child->setBounds(layerRect.size());
         child->setContentBounds(layerRect.size());
@@ skipping 74 matching lines @@
     }
 
     bool reshapeCalled() const { return m_reshapeCalled; }
 
 private:
     bool m_reshapeCalled;
 };
 
 class FakeDrawableLayerImpl: public LayerImpl {
 public:
-    static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new FakeDrawableLayerImpl(id)); }
+    static scoped_ptr<LayerImpl> create(LayerTreeHostImpl* hostImpl, int id) { return scoped_ptr<LayerImpl>(new FakeDrawableLayerImpl(hostImpl, id)); }
 protected:
-    explicit FakeDrawableLayerImpl(int id) : LayerImpl(id) { }
+    FakeDrawableLayerImpl(LayerTreeHostImpl* hostImpl, int id) : LayerImpl(hostImpl, id) { }
 };
 
 // Only reshape when we know we are going to draw. Otherwise, the reshape
 // can leave the window at the wrong size if we never draw and the proper
 // viewport size is never set.
 TEST_P(LayerTreeHostImplTest, reshapeNotCalledUntilDraw)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new ReshapeTrackerContext)).PassAs<OutputSurface>();
     ReshapeTrackerContext* reshapeTracker = static_cast<ReshapeTrackerContext*>(outputSurface->context3D());
     m_hostImpl->initializeRenderer(outputSurface.Pass());
 
-    scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(m_hostImpl.get(), 1);
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setBounds(gfx::Size(10, 10));
     root->setDrawsContent(true);
     m_hostImpl->setRootLayer(root.Pass());
     EXPECT_FALSE(reshapeTracker->reshapeCalled());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(reshapeTracker->reshapeCalled());
@@ skipping 29 matching lines @@
     PartialSwapTrackerContext* partialSwapTracker = static_cast<PartialSwapTrackerContext*>(outputSurface->context3D());
 
     // This test creates its own LayerTreeHostImpl, so
     // that we can force partial swap enabled.
     LayerTreeSettings settings;
     settings.partialSwapEnabled = true;
     scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
     layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
     layerTreeHostImpl->setViewportSize(gfx::Size(500, 500), gfx::Size(500, 500));
 
-    scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
-    scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(2);
+    scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(m_hostImpl.get(), 1);
+    scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(m_hostImpl.get(), 2);
     child->setPosition(gfx::PointF(12, 13));
     child->setAnchorPoint(gfx::PointF(0, 0));
     child->setBounds(gfx::Size(14, 15));
     child->setContentBounds(gfx::Size(14, 15));
     child->setDrawsContent(true);
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setBounds(gfx::Size(500, 500));
     root->setContentBounds(gfx::Size(500, 500));
     root->setDrawsContent(true);
     root->addChild(child.Pass());
@@ skipping 41 matching lines @@
     actualSwapRect = partialSwapTracker->partialSwapRect();
     expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(10, 10));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 }
 
 TEST_P(LayerTreeHostImplTest, rootLayerDoesntCreateExtraSurface)
 {
-    scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
-    scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(2);
+    scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(m_hostImpl.get(), 1);
+    scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(m_hostImpl.get(), 2);
     child->setAnchorPoint(gfx::PointF(0, 0));
     child->setBounds(gfx::Size(10, 10));
     child->setContentBounds(gfx::Size(10, 10));
     child->setDrawsContent(true);
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setBounds(gfx::Size(10, 10));
     root->setContentBounds(gfx::Size(10, 10));
     root->setDrawsContent(true);
     root->setOpacity(0.7f);
     root->addChild(child.Pass());
 
     m_hostImpl->setRootLayer(root.Pass());
 
     LayerTreeHostImpl::FrameData frame;
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     EXPECT_EQ(1u, frame.renderSurfaceLayerList->size());
     EXPECT_EQ(1u, frame.renderPasses.size());
     m_hostImpl->didDrawAllLayers(frame);
 }
 
 } // namespace
 
 class FakeLayerWithQuads : public LayerImpl {
 public:
-    static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new FakeLayerWithQuads(id)); }
+    static scoped_ptr<LayerImpl> create(LayerTreeHostImpl* hostImpl, int id) { return scoped_ptr<LayerImpl>(new FakeLayerWithQuads(hostImpl, id)); }
 
     virtual void appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData) OVERRIDE
     {
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 
         SkColor gray = SkColorSetRGB(100, 100, 100);
         gfx::Rect quadRect(gfx::Point(0, 0), contentBounds());
         scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::Create();
         myQuad->SetNew(sharedQuadState, quadRect, gray);
         quadSink.append(myQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
 private:
-    FakeLayerWithQuads(int id)
-        : LayerImpl(id)
+    FakeLayerWithQuads(LayerTreeHostImpl* hostImpl, int id)
+        : LayerImpl(hostImpl, id)
     {
     }
 };
 
 namespace {
 
 class MockContext : public FakeWebGraphicsContext3D {
 public:
     MOCK_METHOD1(useProgram, void(WebGLId program));
     MOCK_METHOD5(uniform4f, void(WGC3Dint location, WGC3Dfloat x, WGC3Dfloat y, WGC3Dfloat z, WGC3Dfloat w));
@@ skipping 83 matching lines @@
     }
 };
 
 TEST_P(LayerTreeHostImplTest, noPartialSwap)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebGraphicsContext3D>(new MockContext)).PassAs<OutputSurface>();
     MockContext* mockContext = static_cast<MockContext*>(outputSurface->context3D());
     MockContextHarness harness(mockContext);
 
     // Run test case
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, outputSurface.Pass(), FakeLayerWithQuads::create(1));
+    createLayerTreeHost(false, outputSurface.Pass());
+    setupRootLayerImpl(FakeLayerWithQuads::create(m_hostImpl.get(), 1));
 
     // without partial swap, and no clipping, no scissor is set.
     harness.mustDrawSolidQuad();
     harness.mustSetNoScissor();
     {
         LayerTreeHostImpl::FrameData frame;
-        EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
-        myHostImpl->drawLayers(frame);
-        myHostImpl->didDrawAllLayers(frame);
+        EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+        m_hostImpl->drawLayers(frame);
+        m_hostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // without partial swap, but a layer does clip its subtree, one scissor is set.
-    myHostImpl->rootLayer()->setMasksToBounds(true);
+    m_hostImpl->rootLayer()->setMasksToBounds(true);
     harness.mustDrawSolidQuad();
     harness.mustSetScissor(0, 0, 10, 10);
     {
         LayerTreeHostImpl::FrameData frame;
-        EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
-        myHostImpl->drawLayers(frame);
-        myHostImpl->didDrawAllLayers(frame);
+        EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+        m_hostImpl->drawLayers(frame);
+        m_hostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 TEST_P(LayerTreeHostImplTest, partialSwap)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockContext)).PassAs<OutputSurface>();
     MockContext* mockContext = static_cast<MockContext*>(outputSurface->context3D());
     MockContextHarness harness(mockContext);
 
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(true, outputSurface.Pass(), FakeLayerWithQuads::create(1));
+    createLayerTreeHost(true, outputSurface.Pass());
+    setupRootLayerImpl(FakeLayerWithQuads::create(m_hostImpl.get(), 1));
 
     // The first frame is not a partially-swapped one.
     harness.mustSetScissor(0, 0, 10, 10);
     harness.mustDrawSolidQuad();
     {
         LayerTreeHostImpl::FrameData frame;
-        EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
-        myHostImpl->drawLayers(frame);
-        myHostImpl->didDrawAllLayers(frame);
+        EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+        m_hostImpl->drawLayers(frame);
+        m_hostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // Damage a portion of the frame.
-    myHostImpl->rootLayer()->setUpdateRect(gfx::Rect(0, 0, 2, 3));
+    m_hostImpl->rootLayer()->setUpdateRect(gfx::Rect(0, 0, 2, 3));
 
     // The second frame will be partially-swapped (the y coordinates are flipped).
     harness.mustSetScissor(0, 7, 2, 3);
     harness.mustDrawSolidQuad();
     {
         LayerTreeHostImpl::FrameData frame;
-        EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
-        myHostImpl->drawLayers(frame);
-        myHostImpl->didDrawAllLayers(frame);
+        EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+        m_hostImpl->drawLayers(frame);
+        m_hostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 class PartialSwapContext : public FakeWebGraphicsContext3D {
 public:
     WebString getString(WGC3Denum name)
     {
         if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_post_sub_buffer");
@@ skipping 34 matching lines @@
          |  | |   3               |
          |  | +-------------------+
          |  |           |     |
          |  +-----------+     |
          |                    |
          |                    |
          +--------------------+
 
          Layers 1, 2 have render surfaces
      */
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
-    scoped_ptr<LayerImpl> child = LayerImpl::create(2);
-    scoped_ptr<LayerImpl> grandChild = FakeLayerWithQuads::create(3);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
+    scoped_ptr<LayerImpl> child = LayerImpl::create(myHostImpl.get(), 2);
+    scoped_ptr<LayerImpl> grandChild = FakeLayerWithQuads::create(myHostImpl.get(), 3);
 
     gfx::Rect rootRect(0, 0, 100, 100);
     gfx::Rect childRect(10, 10, 50, 50);
     gfx::Rect grandChildRect(5, 5, 150, 150);
 
     root->createRenderSurface();
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(rootRect.x(), rootRect.y()));
     root->setBounds(gfx::Size(rootRect.width(), rootRect.height()));
     root->setContentBounds(root->bounds());
@@ skipping 60 matching lines @@
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 // Make sure that output surface lost notifications are propagated through the tree.
 class OutputSurfaceLostNotificationCheckLayer : public LayerImpl {
 public:
-    static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new OutputSurfaceLostNotificationCheckLayer(id)); }
+    static scoped_ptr<LayerImpl> create(LayerTreeHostImpl* hostImpl, int id) { return scoped_ptr<LayerImpl>(new OutputSurfaceLostNotificationCheckLayer(hostImpl, id)); }
 
     virtual void didLoseOutputSurface() OVERRIDE
     {
         m_didLoseOutputSurfaceCalled = true;
     }
 
     bool didLoseOutputSurfaceCalled() const { return m_didLoseOutputSurfaceCalled; }
 
 private:
-    explicit OutputSurfaceLostNotificationCheckLayer(int id)
-        : LayerImpl(id)
+    OutputSurfaceLostNotificationCheckLayer(LayerTreeHostImpl* hostImpl, int id)
+        : LayerImpl(hostImpl, id)
         , m_didLoseOutputSurfaceCalled(false)
     {
     }
 
     bool m_didLoseOutputSurfaceCalled;
 };
 
 TEST_P(LayerTreeHostImplTest, outputSurfaceLostAndRestoredNotificationSentToAllLayers)
 {
-    m_hostImpl->setRootLayer(OutputSurfaceLostNotificationCheckLayer::create(1));
+    m_hostImpl->setRootLayer(OutputSurfaceLostNotificationCheckLayer::create(m_hostImpl.get(), 1));
     OutputSurfaceLostNotificationCheckLayer* root = static_cast<OutputSurfaceLostNotificationCheckLayer*>(m_hostImpl->rootLayer());
 
-    root->addChild(OutputSurfaceLostNotificationCheckLayer::create(1));
+    root->addChild(OutputSurfaceLostNotificationCheckLayer::create(m_hostImpl.get(), 1));
     OutputSurfaceLostNotificationCheckLayer* layer1 = static_cast<OutputSurfaceLostNotificationCheckLayer*>(root->children()[0]);
 
-    layer1->addChild(OutputSurfaceLostNotificationCheckLayer::create(2));
+    layer1->addChild(OutputSurfaceLostNotificationCheckLayer::create(m_hostImpl.get(), 2));
     OutputSurfaceLostNotificationCheckLayer* layer2 = static_cast<OutputSurfaceLostNotificationCheckLayer*>(layer1->children()[0]);
 
     EXPECT_FALSE(root->didLoseOutputSurfaceCalled());
     EXPECT_FALSE(layer1->didLoseOutputSurfaceCalled());
     EXPECT_FALSE(layer2->didLoseOutputSurfaceCalled());
 
     m_hostImpl->initializeRenderer(createOutputSurface());
 
     EXPECT_TRUE(root->didLoseOutputSurfaceCalled());
     EXPECT_TRUE(layer1->didLoseOutputSurfaceCalled());
@@ skipping 239 matching lines @@
     virtual void splitTrack(WebScrollbar*, const WebRect& track, WebRect& startTrack, WebRect& thumb, WebRect& endTrack) OVERRIDE
     {
         thumb = WebRect(0, 5, 5, 2);
         startTrack = WebRect(0, 5, 0, 5);
         endTrack = WebRect(0, 0, 0, 5);
     }
 };
 
 class FakeScrollbarLayerImpl : public ScrollbarLayerImpl {
 public:
-    static scoped_ptr<FakeScrollbarLayerImpl> create(int id)
+    static scoped_ptr<FakeScrollbarLayerImpl> create(LayerTreeHostImpl* hostImpl, int id)
     {
-        return make_scoped_ptr(new FakeScrollbarLayerImpl(id));
+        return make_scoped_ptr(new FakeScrollbarLayerImpl(hostImpl, id));
     }
 
     void createResources(ResourceProvider* provider)
     {
         DCHECK(provider);
         int pool = 0;
         gfx::Size size(10, 10);
         GLenum format = GL_RGBA;
         ResourceProvider::TextureUsageHint hint = ResourceProvider::TextureUsageAny;
         setScrollbarGeometry(ScrollbarGeometryFixedThumb::create(FakeWebScrollbarThemeGeometryNonEmpty::create()));
 
         setBackTrackResourceId(provider->createResource(pool, size, format, hint));
         setForeTrackResourceId(provider->createResource(pool, size, format, hint));
         setThumbResourceId(provider->createResource(pool, size, format, hint));
     }
 
 protected:
-    explicit FakeScrollbarLayerImpl(int id)
-        : ScrollbarLayerImpl(id)
+    FakeScrollbarLayerImpl(LayerTreeHostImpl* hostImpl, int id)
+        : ScrollbarLayerImpl(hostImpl, id)
     {
     }
 };
 
 static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvider* provider)
 {
     ResourceProvider::ResourceId resourceId = provider->createResource(0, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
 
     scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
     pass->SetNew(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Transform());
     scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
     sharedState->SetAll(gfx::Transform(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), false, 1);
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
 
     pass->AppendSharedQuadState(sharedState.Pass());
     pass->AppendQuad(quad.PassAs<DrawQuad>());
 
     return pass.PassAs<RenderPass>();
 }
 
 TEST_P(LayerTreeHostImplTest, dontUseOldResourcesAfterLostOutputSurface)
 {
     int layerId = 1;
 
-    scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(layerId++));
+    scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(m_hostImpl.get(), layerId++));
     rootLayer->setBounds(gfx::Size(10, 10));
     rootLayer->setAnchorPoint(gfx::PointF(0, 0));
 
-    scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(layerId++);
+    scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(m_hostImpl.get(), layerId++);
     tileLayer->setBounds(gfx::Size(10, 10));
     tileLayer->setAnchorPoint(gfx::PointF(0, 0));
     tileLayer->setContentBounds(gfx::Size(10, 10));
     tileLayer->setDrawsContent(true);
     tileLayer->setSkipsDraw(false);
     scoped_ptr<LayerTilingData> tilingData(LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::NoBorderTexels));
     tilingData->setBounds(gfx::Size(10, 10));
     tileLayer->setTilingData(*tilingData);
     tileLayer->pushTileProperties(0, 0, 1, gfx::Rect(0, 0, 10, 10), false);
     rootLayer->addChild(tileLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(layerId++);
+    scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(m_hostImpl.get(), layerId++);
     textureLayer->setBounds(gfx::Size(10, 10));
     textureLayer->setAnchorPoint(gfx::PointF(0, 0));
     textureLayer->setContentBounds(gfx::Size(10, 10));
     textureLayer->setDrawsContent(true);
     textureLayer->setTextureId(StrictWebGraphicsContext3D::kExternalTextureId);
     rootLayer->addChild(textureLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<TiledLayerImpl> maskLayer = TiledLayerImpl::create(layerId++);
+    scoped_ptr<TiledLayerImpl> maskLayer = TiledLayerImpl::create(m_hostImpl.get(), layerId++);
     maskLayer->setBounds(gfx::Size(10, 10));
     maskLayer->setAnchorPoint(gfx::PointF(0, 0));
     maskLayer->setContentBounds(gfx::Size(10, 10));
     maskLayer->setDrawsContent(true);
     maskLayer->setSkipsDraw(false);
     maskLayer->setTilingData(*tilingData);
     maskLayer->pushTileProperties(0, 0, 1, gfx::Rect(0, 0, 10, 10), false);
 
-    scoped_ptr<TextureLayerImpl> textureLayerWithMask = TextureLayerImpl::create(layerId++);
+    scoped_ptr<TextureLayerImpl> textureLayerWithMask = TextureLayerImpl::create(m_hostImpl.get(), layerId++);
     textureLayerWithMask->setBounds(gfx::Size(10, 10));
     textureLayerWithMask->setAnchorPoint(gfx::PointF(0, 0));
     textureLayerWithMask->setContentBounds(gfx::Size(10, 10));
     textureLayerWithMask->setDrawsContent(true);
     textureLayerWithMask->setTextureId(StrictWebGraphicsContext3D::kExternalTextureId);
     textureLayerWithMask->setMaskLayer(maskLayer.PassAs<LayerImpl>());
     rootLayer->addChild(textureLayerWithMask.PassAs<LayerImpl>());
 
     FakeVideoFrame videoFrame(VideoFrame::CreateColorFrame(gfx::Size(4, 4),
                                                            0x80, 0x80, 0x80,
                                                            base::TimeDelta()));
     VideoLayerImpl::FrameUnwrapper unwrapper =
         base::Bind(FakeVideoFrame::toVideoFrame);
     FakeVideoFrameProvider provider;
     provider.setFrame(&videoFrame);
-    scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(layerId++, &provider, unwrapper);
+    scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(m_hostImpl.get(), layerId++, &provider, unwrapper);
     videoLayer->setBounds(gfx::Size(10, 10));
     videoLayer->setAnchorPoint(gfx::PointF(0, 0));
     videoLayer->setContentBounds(gfx::Size(10, 10));
     videoLayer->setDrawsContent(true);
-    videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(videoLayer.PassAs<LayerImpl>());
 
     FakeVideoFrameProvider providerScaled;
-    scoped_ptr<VideoLayerImpl> videoLayerScaled = VideoLayerImpl::create(layerId++, &providerScaled, unwrapper);
+    scoped_ptr<VideoLayerImpl> videoLayerScaled = VideoLayerImpl::create(m_hostImpl.get(), layerId++, &providerScaled, unwrapper);
     videoLayerScaled->setBounds(gfx::Size(10, 10));
     videoLayerScaled->setAnchorPoint(gfx::PointF(0, 0));
     videoLayerScaled->setContentBounds(gfx::Size(10, 10));
     videoLayerScaled->setDrawsContent(true);
-    videoLayerScaled->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(videoLayerScaled.PassAs<LayerImpl>());
 
     FakeVideoFrameProvider hwProvider;
-    scoped_ptr<VideoLayerImpl> hwVideoLayer = VideoLayerImpl::create(layerId++, &hwProvider, unwrapper);
+    scoped_ptr<VideoLayerImpl> hwVideoLayer = VideoLayerImpl::create(m_hostImpl.get(), layerId++, &hwProvider, unwrapper);
     hwVideoLayer->setBounds(gfx::Size(10, 10));
     hwVideoLayer->setAnchorPoint(gfx::PointF(0, 0));
     hwVideoLayer->setContentBounds(gfx::Size(10, 10));
     hwVideoLayer->setDrawsContent(true);
-    hwVideoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(hwVideoLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(layerId++);
+    scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(m_hostImpl.get(), layerId++);
     ioSurfaceLayer->setBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setAnchorPoint(gfx::PointF(0, 0));
     ioSurfaceLayer->setContentBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setDrawsContent(true);
     ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
-    ioSurfaceLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(ioSurfaceLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<HeadsUpDisplayLayerImpl> hudLayer = HeadsUpDisplayLayerImpl::create(layerId++);
+    scoped_ptr<HeadsUpDisplayLayerImpl> hudLayer = HeadsUpDisplayLayerImpl::create(m_hostImpl.get(), layerId++);
     hudLayer->setBounds(gfx::Size(10, 10));
     hudLayer->setAnchorPoint(gfx::PointF(0, 0));
     hudLayer->setContentBounds(gfx::Size(10, 10));
     hudLayer->setDrawsContent(true);
-    hudLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(hudLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<FakeScrollbarLayerImpl> scrollbarLayer(FakeScrollbarLayerImpl::create(layerId++));
+    scoped_ptr<FakeScrollbarLayerImpl> scrollbarLayer(FakeScrollbarLayerImpl::create(m_hostImpl.get(), layerId++));
     scrollbarLayer->setBounds(gfx::Size(10, 10));
     scrollbarLayer->setContentBounds(gfx::Size(10, 10));
     scrollbarLayer->setDrawsContent(true);
-    scrollbarLayer->setLayerTreeHostImpl(m_hostImpl.get());
     scrollbarLayer->createResources(m_hostImpl->resourceProvider());
     rootLayer->addChild(scrollbarLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<DelegatedRendererLayerImpl> delegatedRendererLayer(DelegatedRendererLayerImpl::create(layerId++));
+    scoped_ptr<DelegatedRendererLayerImpl> delegatedRendererLayer(DelegatedRendererLayerImpl::create(m_hostImpl.get(), layerId++));
     delegatedRendererLayer->setBounds(gfx::Size(10, 10));
     delegatedRendererLayer->setContentBounds(gfx::Size(10, 10));
     delegatedRendererLayer->setDrawsContent(true);
-    delegatedRendererLayer->setLayerTreeHostImpl(m_hostImpl.get());
     ScopedPtrVector<RenderPass> passList;
     passList.append(createRenderPassWithResource(m_hostImpl->resourceProvider()));
     delegatedRendererLayer->setRenderPasses(passList);
     EXPECT_TRUE(passList.isEmpty());
     rootLayer->addChild(delegatedRendererLayer.PassAs<LayerImpl>());
 
     // Use a context that supports IOSurfaces
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DWithIOSurface)).PassAs<OutputSurface>());
 
     FakeVideoFrame hwVideoFrame(
@@ skipping 91 matching lines @@
 
     unsigned numTextures() const { return m_numTextures; }
 
 private:
     base::hash_map<WebGLId, bool> m_textures;
     unsigned m_numTextures;
 };
 
 TEST_P(LayerTreeHostImplTest, layersFreeTextures)
 {
-    scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(1));
+    scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(m_hostImpl.get(), 1));
     rootLayer->setBounds(gfx::Size(10, 10));
     rootLayer->setAnchorPoint(gfx::PointF(0, 0));
 
-    scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(2);
+    scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(m_hostImpl.get(), 2);
     tileLayer->setBounds(gfx::Size(10, 10));
     tileLayer->setAnchorPoint(gfx::PointF(0, 0));
     tileLayer->setContentBounds(gfx::Size(10, 10));
     tileLayer->setDrawsContent(true);
     tileLayer->setSkipsDraw(false);
     scoped_ptr<LayerTilingData> tilingData(LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::NoBorderTexels));
     tilingData->setBounds(gfx::Size(10, 10));
     tileLayer->setTilingData(*tilingData);
     tileLayer->pushTileProperties(0, 0, 1, gfx::Rect(0, 0, 10, 10), false);
     rootLayer->addChild(tileLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(3);
+    scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(m_hostImpl.get(), 3);
     textureLayer->setBounds(gfx::Size(10, 10));
     textureLayer->setAnchorPoint(gfx::PointF(0, 0));
     textureLayer->setContentBounds(gfx::Size(10, 10));
     textureLayer->setDrawsContent(true);
     textureLayer->setTextureId(1);
     rootLayer->addChild(textureLayer.PassAs<LayerImpl>());
 
     VideoLayerImpl::FrameUnwrapper unwrapper =
         base::Bind(FakeVideoFrame::toVideoFrame);
     FakeVideoFrameProvider provider;
-    scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(4, &provider, unwrapper);
+    scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(m_hostImpl.get(), 4, &provider, unwrapper);
     videoLayer->setBounds(gfx::Size(10, 10));
     videoLayer->setAnchorPoint(gfx::PointF(0, 0));
     videoLayer->setContentBounds(gfx::Size(10, 10));
     videoLayer->setDrawsContent(true);
-    videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(videoLayer.PassAs<LayerImpl>());
 
-    scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(5);
+    scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(m_hostImpl.get(), 5);
     ioSurfaceLayer->setBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setAnchorPoint(gfx::PointF(0, 0));
     ioSurfaceLayer->setContentBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setDrawsContent(true);
     ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
-    ioSurfaceLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(ioSurfaceLayer.PassAs<LayerImpl>());
 
     // Lose the WebGraphicsContext3D, replacing it with a TrackingWebGraphicsContext3D (which the LayerTreeHostImpl takes ownership of).
     scoped_ptr<OutputSurface> outputSurface(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new TrackingWebGraphicsContext3D)));
     TrackingWebGraphicsContext3D* trackingWebGraphicsContext3D = static_cast<TrackingWebGraphicsContext3D*>(outputSurface->context3D());
     m_hostImpl->initializeRenderer(outputSurface.Pass());
 
     m_hostImpl->setRootLayer(rootLayer.Pass());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
     EXPECT_GT(trackingWebGraphicsContext3D->numTextures(), 0u);
 
     // Kill the layer tree.
-    m_hostImpl->setRootLayer(LayerImpl::create(100));
+    m_hostImpl->setRootLayer(LayerImpl::create(m_hostImpl.get(), 100));
     // There should be no textures left in use after.
     EXPECT_EQ(0u, trackingWebGraphicsContext3D->numTextures());
 }
 
 class MockDrawQuadsToFillScreenContext : public FakeWebGraphicsContext3D {
 public:
     MOCK_METHOD1(useProgram, void(WebGLId program));
     MOCK_METHOD4(drawElements, void(WGC3Denum mode, WGC3Dsizei count, WGC3Denum type, WGC3Dintptr offset));
 };
 
 TEST_P(LayerTreeHostImplTest, hasTransparentBackground)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockDrawQuadsToFillScreenContext)).PassAs<OutputSurface>();
     MockDrawQuadsToFillScreenContext* mockContext = static_cast<MockDrawQuadsToFillScreenContext*>(outputSurface->context3D());
 
     // Run test case
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, outputSurface.Pass(), LayerImpl::create(1));
-    myHostImpl->setBackgroundColor(SK_ColorWHITE);
+    createLayerTreeHost(false, outputSurface.Pass());
+    setupRootLayerImpl(LayerImpl::create(m_hostImpl.get(), 1));
+    m_hostImpl->setBackgroundColor(SK_ColorWHITE);
 
     // Verify one quad is drawn when transparent background set is not set.
-    myHostImpl->setHasTransparentBackground(false);
+    m_hostImpl->setHasTransparentBackground(false);
     EXPECT_CALL(*mockContext, useProgram(_))
         .Times(1);
     EXPECT_CALL(*mockContext, drawElements(_, _, _, _))
         .Times(1);
     LayerTreeHostImpl::FrameData frame;
-    EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
-    myHostImpl->drawLayers(frame);
-    myHostImpl->didDrawAllLayers(frame);
+    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+    m_hostImpl->drawLayers(frame);
+    m_hostImpl->didDrawAllLayers(frame);
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // Verify no quads are drawn when transparent background is set.
-    myHostImpl->setHasTransparentBackground(true);
-    EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
-    myHostImpl->drawLayers(frame);
-    myHostImpl->didDrawAllLayers(frame);
+    m_hostImpl->setHasTransparentBackground(true);
+    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+    m_hostImpl->drawLayers(frame);
+    m_hostImpl->didDrawAllLayers(frame);
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 static void addDrawingLayerTo(LayerImpl* parent, int id, const gfx::Rect& layerRect, LayerImpl** result)
 {
-    scoped_ptr<LayerImpl> layer = FakeLayerWithQuads::create(id);
+    scoped_ptr<LayerImpl> layer = FakeLayerWithQuads::create(parent->layerTreeHostImpl(), id);
     LayerImpl* layerPtr = layer.get();
     layerPtr->setAnchorPoint(gfx::PointF(0, 0));
     layerPtr->setPosition(gfx::PointF(layerRect.origin()));
     layerPtr->setBounds(layerRect.size());
     layerPtr->setContentBounds(layerRect.size());
     layerPtr->setDrawsContent(true); // only children draw content
     layerPtr->setContentsOpaque(true);
     parent->addChild(layer.Pass());
     if (result)
         *result = layerPtr;
 }
 
 static void setupLayersForTextureCaching(LayerTreeHostImpl* layerTreeHostImpl, LayerImpl*& rootPtr, LayerImpl*& intermediateLayerPtr, LayerImpl*& surfaceLayerPtr, LayerImpl*& childPtr, const gfx::Size& rootSize)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
     layerTreeHostImpl->setViewportSize(rootSize, rootSize);
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(layerTreeHostImpl, 1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     layerTreeHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 2, gfx::Rect(10, 10, rootSize.width(), rootSize.height()), &intermediateLayerPtr);
@@ skipping 25 matching lines @@
     LayerImpl* rootPtr;
     LayerImpl* surfaceLayerPtr;
 
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     gfx::Size rootSize(100, 100);
 
     myHostImpl->initializeRenderer(outputSurface.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
@@ skipping 90 matching lines @@
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(outputSurface.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
@@ skipping 90 matching lines @@
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(outputSurface.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
@@ skipping 91 matching lines @@
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(outputSurface.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
@@ skipping 60 matching lines @@
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
 
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(outputSurface.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
@@ skipping 63 matching lines @@
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
 
     gfx::Size rootSize(1000, 1000);
 
     myHostImpl->initializeRenderer(outputSurface.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
     myHostImpl->setRootLayer(root.Pass());
 
@@ skipping 83 matching lines @@
          |  | |   3               |
          |  | +-------------------+
          |  |           |     |
          |  +-----------+     |
          |                    |
          |                    |
          +--------------------+
 
          Layers 1, 2 have render surfaces
      */
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
-    scoped_ptr<TiledLayerImpl> child = TiledLayerImpl::create(2);
-    scoped_ptr<LayerImpl> grandChild = LayerImpl::create(3);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl.get(), 1);
+    scoped_ptr<TiledLayerImpl> child = TiledLayerImpl::create(myHostImpl.get(), 2);
+    scoped_ptr<LayerImpl> grandChild = LayerImpl::create(myHostImpl.get(), 3);
 
     gfx::Rect rootRect(0, 0, 100, 100);
     gfx::Rect childRect(10, 10, 50, 50);
     gfx::Rect grandChildRect(5, 5, 150, 150);
 
     scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
     myHostImpl->initializeRenderer(outputSurface.Pass());
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(rootRect.x(), rootRect.y()));
@@ skipping 1105 matching lines @@
 {
     pinchZoomPanViewportAndScrollBoundaryTest(2);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc