cc: Split out calcDrawEtc from drawLayers

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 102 matching lines @@
 
         myHostImpl->initializeRenderer(graphicsContext.Pass());
         myHostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
         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);
+        root->setLayerTreeHostImpl(myHostImpl.get());
         myHostImpl->setRootLayer(root.Pass());
         return myHostImpl.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]);
     }
@@ skipping 28 matching lines @@
     void setupScrollAndContentsLayers(const gfx::Size& contentSize)
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(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));
+        root->setLayerTreeHostImpl(m_hostImpl.get());
 
         scoped_ptr<LayerImpl> contents = LayerImpl::create(2);
         contents->setDrawsContent(true);
         contents->setBounds(contentSize);
         contents->setContentBounds(contentSize);
         contents->setPosition(gfx::PointF(0, 0));
         contents->setAnchorPoint(gfx::PointF(0, 0));
+        contents->setLayerTreeHostImpl(m_hostImpl.get());
         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);
         layer->setScrollable(true);
         layer->setDrawsContent(true);
         layer->setBounds(size);
         layer->setContentBounds(size);
         layer->setMaxScrollOffset(gfx::Vector2d(size.width() * 2, size.height() * 2));
+        layer->setLayerTreeHostImpl(m_hostImpl.get());
         return layer.Pass();
     }
 
     void initializeRendererAndDrawFrame()
     {
         m_hostImpl->initializeRenderer(createContext());
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
@@ skipping 722 matching lines @@
     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));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->setMasksToBounds(true);
+    root->setLayerTreeHostImpl(m_hostImpl.get());
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* layer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
+    layer->setLayerTreeHostImpl(m_hostImpl.get());
+
     // 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 22 matching lines @@
     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));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
+    root->setLayerTreeHostImpl(m_hostImpl.get());
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
+    occludedLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     root->addChild(DidDrawCheckLayer::create(3));
     DidDrawCheckLayer* topLayer = static_cast<DidDrawCheckLayer*>(root->children()[1]);
+    topLayer->setLayerTreeHostImpl(m_hostImpl.get());
     // 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));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
+    root->setLayerTreeHostImpl(m_hostImpl.get());
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* layer1 = static_cast<DidDrawCheckLayer*>(root->children()[0]);
+    layer1->setLayerTreeHostImpl(m_hostImpl.get());
 
     layer1->addChild(DidDrawCheckLayer::create(3));
     DidDrawCheckLayer* layer2 = static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
+    layer2->setLayerTreeHostImpl(m_hostImpl.get());
 
     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));
@@ skipping 31 matching lines @@
             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));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(2, false, false, true, m_hostImpl->resourceProvider()));
+    root->setLayerTreeHostImpl(m_hostImpl.get());
+    root->children()[0]->setLayerTreeHostImpl(m_hostImpl.get());
 
     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));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(2, true, false, false, m_hostImpl->resourceProvider()));
+    root->setLayerTreeHostImpl(m_hostImpl.get());
+    root->children()[0]->setLayerTreeHostImpl(m_hostImpl.get());
 
     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));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(2, true, false, true, m_hostImpl->resourceProvider()));
+    root->setLayerTreeHostImpl(m_hostImpl.get());
+    root->children()[0]->setLayerTreeHostImpl(m_hostImpl.get());
 
     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));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(2, false, true, true, m_hostImpl->resourceProvider()));
+    root->setLayerTreeHostImpl(m_hostImpl.get());
+    root->children()[0]->setLayerTreeHostImpl(m_hostImpl.get());
 
     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);
     root->setScrollable(false);
@@ skipping 13 matching lines @@
     gfx::Size surfaceSize(10, 10);
 
     scoped_ptr<LayerImpl> contentLayer = LayerImpl::create(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);
+    contentLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     scoped_ptr<LayerImpl> scrollLayer = LayerImpl::create(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());
+    scrollLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     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);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
+    root->setLayerTreeHostImpl(m_hostImpl.get());
     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);
+    root->setLayerTreeHostImpl(m_hostImpl.get());
     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);
+    root->setLayerTreeHostImpl(m_hostImpl.get());
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
+    child->setLayerTreeHostImpl(m_hostImpl.get());
     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());
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because the scrollable layer is not facing the viewer and there is
     // nothing scrollable behind it.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollBlockedByContentLayer)
 {
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> contentLayer = createScrollableLayer(1, surfaceSize);
     contentLayer->setShouldScrollOnMainThread(true);
     contentLayer->setScrollable(false);
+    contentLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     scoped_ptr<LayerImpl> scrollLayer = createScrollableLayer(2, surfaceSize);
     scrollLayer->addChild(contentLayer.Pass());
+    scrollLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     m_hostImpl->setRootLayer(scrollLayer.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scrolling fails because the content layer is asking to be scrolled on the main thread.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
 {
     gfx::Size surfaceSize(10, 10);
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
+    root->setLayerTreeHostImpl(m_hostImpl.get());
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     gfx::Vector2d scrollDelta(0, 10);
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
@@ skipping 32 matching lines @@
     EXPECT_EQ(0.0, m_hostImpl->rootLayer()->implTransform().matrix().getDouble(3, 1));
     EXPECT_EQ(0.0, m_hostImpl->rootLayer()->implTransform().matrix().getDouble(3, 2));
     EXPECT_EQ(1.0, m_hostImpl->rootLayer()->implTransform().matrix().getDouble(3, 3));
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
 {
     gfx::Size surfaceSize(10, 10);
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
+    root->setLayerTreeHostImpl(m_hostImpl.get());
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     gfx::Vector2d scrollDelta(0, 10);
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
@@ skipping 402 matching lines @@
 };
 
 TEST_P(LayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
 {
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(1);
         root->setAnchorPoint(gfx::PointF(0, 0));
         root->setBounds(gfx::Size(10, 10));
         root->setContentBounds(root->bounds());
         root->setDrawsContent(false);
+        root->setLayerTreeHostImpl(m_hostImpl.get());
         m_hostImpl->setRootLayer(root.Pass());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->addChild(BlendStateCheckLayer::create(2, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* layer1 = static_cast<BlendStateCheckLayer*>(root->children()[0]);
     layer1->setPosition(gfx::PointF(2, 2));
+    layer1->setLayerTreeHostImpl(m_hostImpl.get());
 
     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);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
@@ skipping 20 matching lines @@
     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()));
     BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
     layer2->setPosition(gfx::PointF(4, 4));
+    layer2->setLayerTreeHostImpl(m_hostImpl.get());
 
     // 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);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
@@ skipping 127 matching lines @@
 TEST_P(LayerTreeHostImplTest, viewportCovered)
 {
     m_hostImpl->initializeRenderer(createContext());
     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->rootLayer()->setLayerTreeHostImpl(m_hostImpl.get());
     BlendStateCheckLayer* child = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer()->children()[0]);
     child->setExpectation(false, false);
     child->setContentsOpaque(true);
+    child->setLayerTreeHostImpl(m_hostImpl.get());
 
     // No gutter rects
     {
         gfx::Rect layerRect(0, 0, 1000, 1000);
         child->setPosition(layerRect.origin());
         child->setBounds(layerRect.size());
         child->setContentBounds(layerRect.size());
         child->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
         child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
+        EXPECT_TRUE(m_hostImpl->needsUpdateLayers());
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
         EXPECT_EQ(0u, numGutterQuads);
         EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
 
         verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     // Empty visible content area (fullscreen gutter rect)
     {
         gfx::Rect layerRect(0, 0, 0, 0);
         child->setPosition(layerRect.origin());
         child->setBounds(layerRect.size());
         child->setContentBounds(layerRect.size());
         child->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
         child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
+        EXPECT_TRUE(m_hostImpl->needsUpdateLayers());
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
-        m_hostImpl->didDrawAllLayers(frame);
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
         EXPECT_EQ(1u, numGutterQuads);
         EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
 
         verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     // Content area in middle of clip rect (four surrounding gutter rects)
     {
         gfx::Rect layerRect(500, 500, 200, 200);
         child->setPosition(layerRect.origin());
         child->setBounds(layerRect.size());
         child->setContentBounds(layerRect.size());
         child->setQuadRect(gfx::Rect(gfx::Point(), layerRect.size()));
         child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
 
         LayerTreeHostImpl::FrameData frame;
+        EXPECT_TRUE(m_hostImpl->needsUpdateLayers());
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         size_t numGutterQuads = 0;
         for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
             numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
         EXPECT_EQ(4u, numGutterQuads);
         EXPECT_EQ(5u, frame.renderPasses[0]->quad_list.size());
 
         verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
@@ skipping 84 matching lines @@
     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);
     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);
+    child->setLayerTreeHostImpl(layerTreeHostImpl.get());
     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());
+    root->setLayerTreeHostImpl(layerTreeHostImpl.get());
     layerTreeHostImpl->setRootLayer(root.Pass());
 
     LayerTreeHostImpl::FrameData frame;
 
     // First frame, the entire screen should get swapped.
     EXPECT_TRUE(layerTreeHostImpl->prepareToDraw(frame));
     layerTreeHostImpl->drawLayers(frame);
     layerTreeHostImpl->didDrawAllLayers(frame);
     layerTreeHostImpl->swapBuffers();
     gfx::Rect actualSwapRect = partialSwapTracker->partialSwapRect();
@@ skipping 37 matching lines @@
 }
 
 TEST_P(LayerTreeHostImplTest, rootLayerDoesntCreateExtraSurface)
 {
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
     scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(2);
     child->setAnchorPoint(gfx::PointF(0, 0));
     child->setBounds(gfx::Size(10, 10));
     child->setContentBounds(gfx::Size(10, 10));
     child->setDrawsContent(true);
+    child->setLayerTreeHostImpl(m_hostImpl.get());
     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());
+    root->setLayerTreeHostImpl(m_hostImpl.get());
 
     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);
 }
@@ skipping 240 matching lines @@
     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());
     root->drawProperties().visible_content_rect = rootRect;
     root->setDrawsContent(false);
     root->renderSurface()->setContentRect(gfx::Rect(gfx::Point(), gfx::Size(rootRect.width(), rootRect.height())));
+    root->setLayerTreeHostImpl(myHostImpl.get());
 
     child->setAnchorPoint(gfx::PointF(0, 0));
     child->setPosition(gfx::PointF(childRect.x(), childRect.y()));
     child->setOpacity(0.5f);
     child->setBounds(gfx::Size(childRect.width(), childRect.height()));
     child->setContentBounds(child->bounds());
     child->drawProperties().visible_content_rect = childRect;
     child->setDrawsContent(false);
     child->setForceRenderSurface(true);
+    child->setLayerTreeHostImpl(myHostImpl.get());
 
     grandChild->setAnchorPoint(gfx::PointF(0, 0));
     grandChild->setPosition(gfx::Point(grandChildRect.x(), grandChildRect.y()));
     grandChild->setBounds(gfx::Size(grandChildRect.width(), grandChildRect.height()));
     grandChild->setContentBounds(grandChild->bounds());
     grandChild->drawProperties().visible_content_rect = grandChildRect;
     grandChild->setDrawsContent(true);
+    grandChild->setLayerTreeHostImpl(myHostImpl.get());
 
     child->addChild(grandChild.Pass());
     root->addChild(child.Pass());
 
     myHostImpl->setRootLayer(root.Pass());
     return myHostImpl.Pass();
 }
 
 TEST_P(LayerTreeHostImplTest, contributingLayerEmptyScissorPartialSwap)
 {
@@ skipping 368 matching lines @@
     return pass.PassAs<RenderPass>();
 }
 
 TEST_P(LayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 {
     int layerId = 1;
 
     scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(layerId++));
     rootLayer->setBounds(gfx::Size(10, 10));
     rootLayer->setAnchorPoint(gfx::PointF(0, 0));
+    rootLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(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);
+    tileLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(tileLayer.PassAs<LayerImpl>());
 
     scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(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);
+    textureLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(textureLayer.PassAs<LayerImpl>());
 
     scoped_ptr<TiledLayerImpl> maskLayer = TiledLayerImpl::create(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);
+    maskLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     scoped_ptr<TextureLayerImpl> textureLayerWithMask = TextureLayerImpl::create(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>());
+    textureLayerWithMask->setLayerTreeHostImpl(m_hostImpl.get());
     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);
@@ skipping 159 matching lines @@
 private:
     base::hash_map<WebGLId, bool> m_textures;
     unsigned m_numTextures;
 };
 
 TEST_P(LayerTreeHostImplTest, layersFreeTextures)
 {
     scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(1));
     rootLayer->setBounds(gfx::Size(10, 10));
     rootLayer->setAnchorPoint(gfx::PointF(0, 0));
+    rootLayer->setLayerTreeHostImpl(m_hostImpl.get());
 
     scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(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);
+    tileLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(tileLayer.PassAs<LayerImpl>());
 
     scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(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);
+    textureLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(textureLayer.PassAs<LayerImpl>());
 
     VideoLayerImpl::FrameUnwrapper unwrapper =
         base::Bind(FakeVideoFrame::toVideoFrame);
     FakeVideoFrameProvider provider;
     scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(4, &provider, unwrapper);
     videoLayer->setBounds(gfx::Size(10, 10));
     videoLayer->setAnchorPoint(gfx::PointF(0, 0));
     videoLayer->setContentBounds(gfx::Size(10, 10));
     videoLayer->setDrawsContent(true);
@@ skipping 68 matching lines @@
 static void addDrawingLayerTo(LayerImpl* parent, int id, const gfx::Rect& layerRect, LayerImpl** result)
 {
     scoped_ptr<LayerImpl> layer = FakeLayerWithQuads::create(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);
+    layerPtr->setLayerTreeHostImpl(parent ? parent->layerTreeHostImpl() : 0);
     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<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     layerTreeHostImpl->initializeRenderer(context.Pass());
     layerTreeHostImpl->setViewportSize(rootSize, rootSize);
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(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->setLayerTreeHostImpl(layerTreeHostImpl);
     layerTreeHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 2, gfx::Rect(10, 10, rootSize.width(), rootSize.height()), &intermediateLayerPtr);
     intermediateLayerPtr->setDrawsContent(false); // only children draw content
 
     // Surface layer is the layer that changes its opacity
     // It will contain other layers that draw content.
     addDrawingLayerTo(intermediateLayerPtr, 3, gfx::Rect(10, 10, rootSize.width(), rootSize.height()), &surfaceLayerPtr);
     surfaceLayerPtr->setDrawsContent(false); // only children draw content
     surfaceLayerPtr->setOpacity(0.5f);
@@ skipping 27 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(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);
+    root->setLayerTreeHostImpl(myHostImpl.get());
     myHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 3, gfx::Rect(0, 0, rootSize.width(), rootSize.height()), &surfaceLayerPtr);
     surfaceLayerPtr->setDrawsContent(false);
 
     // Surface layer is the layer that changes its opacity
     // It will contain other layers that draw content.
     surfaceLayerPtr->setOpacity(0.5f);
     surfaceLayerPtr->setForceRenderSurface(true); // This will cause it to have a surface
 
@@ skipping 91 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(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);
+    root->setLayerTreeHostImpl(myHostImpl.get());
+    root->setLayerTreeHostImpl(myHostImpl.get());
     myHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 2, gfx::Rect(300, 300, 300, 300), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
+    layerS1Ptr->setLayerTreeHostImpl(myHostImpl.get());
 
     addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(10, 10, 10, 10), 0); // L11
     addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(0, 0, 30, 30), 0); // L12
 
     addDrawingLayerTo(rootPtr, 5, gfx::Rect(550, 250, 300, 400), &layerS2Ptr);
     layerS2Ptr->setForceRenderSurface(true);
+    layerS2Ptr->setLayerTreeHostImpl(myHostImpl.get());
 
     addDrawingLayerTo(layerS2Ptr, 6, gfx::Rect(20, 20, 5, 5), 0); // L21
 
     // Initial draw - must receive all quads
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive 3 render passes.
         // For Root, there are 2 quads; for S1, there are 2 quads (1 is occluded); for S2, there is 2 quads.
@@ skipping 29 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // "Re-occlude" surface S1 and repeat draw.
     // Must remove S1's render pass since it is now available in full.
     // S2 has no change so must also be removed.
     transform = layerS2Ptr->transform();
     transform.Translate(-15, -15);
     layerS2Ptr->setTransform(transform);
+    EXPECT_TRUE(myHostImpl->needsUpdateLayers());
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive 1 render pass - for the root.
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
 
         myHostImpl->drawLayers(frame);
@@ skipping 32 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(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);
+    root->setLayerTreeHostImpl(myHostImpl.get());
     myHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 800, 800), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
     layerS1Ptr->setDrawsContent(false);
 
     addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(0, 0, 300, 300), 0); // L11
     addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(0, 500, 300, 300), 0); // L12
     addDrawingLayerTo(layerS1Ptr, 5, gfx::Rect(500, 0, 300, 300), 0); // L13
     addDrawingLayerTo(layerS1Ptr, 6, gfx::Rect(500, 500, 300, 300), 0); // L14
@@ skipping 92 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(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);
+    root->setLayerTreeHostImpl(myHostImpl.get());
     myHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 400, 400), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
 
     addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(0, 0, 300, 300), 0); // L11
     addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(100, 0, 300, 300), 0); // L12
 
     addDrawingLayerTo(rootPtr, 7, gfx::Rect(200, 0, 300, 300), &layerS2Ptr);
     layerS2Ptr->setForceRenderSurface(true);
@@ skipping 61 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(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);
+    root->setLayerTreeHostImpl(myHostImpl.get());
     myHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 400, 400), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
     gfx::Transform transform = layerS1Ptr->transform();
     transform.Translate(200, 200);
     transform.Rotate(45);
     transform.Translate(-200, -200);
     layerS1Ptr->setTransform(transform);
 
@@ skipping 64 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(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);
+    root->setLayerTreeHostImpl(myHostImpl.get());
     myHostImpl->setRootLayer(root.Pass());
 
     addDrawingLayerTo(rootPtr, 2, gfx::Rect(300, 300, 300, 300), &layerS1Ptr);
     layerS1Ptr->setForceRenderSurface(true);
 
     addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(10, 10, 10, 10), 0); // L11
     addDrawingLayerTo(layerS1Ptr, 4, gfx::Rect(0, 0, 30, 30), 0); // L12
 
     addDrawingLayerTo(rootPtr, 5, gfx::Rect(550, 250, 300, 400), &layerS2Ptr);
     layerS2Ptr->setForceRenderSurface(true);
@@ skipping 92 matching lines @@
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
     myHostImpl->initializeRenderer(context.Pass());
 
     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());
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
+    root->setLayerTreeHostImpl(myHostImpl.get());
 
     child->setAnchorPoint(gfx::PointF(0, 0));
     child->setPosition(gfx::PointF(childRect.x(), childRect.y()));
     child->setOpacity(0.5);
     child->setBounds(gfx::Size(childRect.width(), childRect.height()));
     child->setContentBounds(child->bounds());
     child->setDrawsContent(true);
     child->setSkipsDraw(false);
+    child->setLayerTreeHostImpl(myHostImpl.get());
 
     // child layer has 10x10 tiles.
     scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::HasBorderTexels);
     tiler->setBounds(child->contentBounds());
     child->setTilingData(*tiler.get());
 
     grandChild->setAnchorPoint(gfx::PointF(0, 0));
     grandChild->setPosition(gfx::Point(grandChildRect.x(), grandChildRect.y()));
     grandChild->setBounds(gfx::Size(grandChildRect.width(), grandChildRect.height()));
     grandChild->setContentBounds(grandChild->bounds());
     grandChild->setDrawsContent(true);
+    grandChild->setLayerTreeHostImpl(myHostImpl.get());
 
     TiledLayerImpl* childPtr = child.get();
     RenderPass::Id childPassId(childPtr->id(), 0);
 
     child->addChild(grandChild.Pass());
     root->addChild(child.PassAs<LayerImpl>());
     myHostImpl->setRootLayer(root.Pass());
     myHostImpl->setViewportSize(rootRect.size(), rootRect.size());
 
     EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(childPassId));
@@ skipping 1072 matching lines @@
 {
     pinchZoomPanViewportAndScrollBoundaryTest(2);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc