cc: Move more functionality from host to LayerTreeImpl

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 105 matching lines @@
     }
 
     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);
-        m_hostImpl->setRootLayer(root.Pass());
+        m_hostImpl->activeTree()->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 34 matching lines @@
         root->setPosition(gfx::PointF(0, 0));
         root->setAnchorPoint(gfx::PointF(0, 0));
 
         scoped_ptr<LayerImpl> contents = LayerImpl::create(m_hostImpl->activeTree(), 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());
+        m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     }
 
     scoped_ptr<LayerImpl> createScrollableLayer(int id, const gfx::Size& size)
     {
         scoped_ptr<LayerImpl> layer = LayerImpl::create(m_hostImpl->activeTree(), id);
         layer->setScrollable(true);
         layer->setDrawsContent(true);
         layer->setBounds(size);
         layer->setContentBounds(size);
         layer->setMaxScrollOffset(gfx::Vector2d(size.width() * 2, size.height() * 2));
@@ skipping 47 matching lines @@
     // that canDraw changed.
     EXPECT_FALSE(m_hostImpl->canDraw());
     m_onCanDrawStateChangedCalled = false;
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
     // Toggle the root layer to make sure it toggles canDraw
-    m_hostImpl->setRootLayer(scoped_ptr<LayerImpl>());
+    m_hostImpl->activeTree()->SetRootLayer(scoped_ptr<LayerImpl>());
     EXPECT_FALSE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
     // Toggle the device viewport size to make sure it toggles canDraw.
@@ skipping 40 matching lines @@
 
 TEST_P(LayerTreeHostImplTest, scrollDeltaTreeButNoChanges)
 {
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl->activeTree(), 1);
         root->addChild(LayerImpl::create(m_hostImpl->activeTree(), 2));
         root->addChild(LayerImpl::create(m_hostImpl->activeTree(), 3));
         root->children()[1]->addChild(LayerImpl::create(m_hostImpl->activeTree(), 4));
         root->children()[1]->addChild(LayerImpl::create(m_hostImpl->activeTree(), 5));
         root->children()[1]->children()[0]->addChild(LayerImpl::create(m_hostImpl->activeTree(), 6));
-        m_hostImpl->setRootLayer(root.Pass());
+        m_hostImpl->activeTree()->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(m_hostImpl->activeTree(), 1);
         root->setScrollOffset(scrollOffset);
         root->setScrollable(true);
         root->setMaxScrollOffset(gfx::Vector2d(100, 100));
         root->scrollBy(scrollDelta);
-        m_hostImpl->setRootLayer(root.Pass());
+        m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
     scoped_ptr<ScrollAndScaleSet> scrollInfo;
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
     EXPECT_VECTOR_EQ(root->sentScrollDelta(), scrollDelta);
     expectContains(*scrollInfo, root->id(), scrollDelta);
 
@@ skipping 46 matching lines @@
 TEST_P(LayerTreeHostImplTest, replaceTreeWhileScrolling)
 {
     const int scrollLayerId = 1;
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     // We should not crash if the tree is replaced while we are scrolling.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->detachLayerTree();
+    m_hostImpl->activeTree()->DetachLayerTree();
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // We should still be scrolling, because the scrolled layer also exists in the new tree.
     gfx::Vector2d scrollDelta(0, 10);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo, scrollLayerId, scrollDelta);
 }
@@ skipping 512 matching lines @@
 
 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(m_hostImpl->activeTree(), 1));
+    m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->setMasksToBounds(true);
 
     root->addChild(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 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));
 
@@ skipping 25 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(m_hostImpl->activeTree(), 1));
+    m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 2));
     DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
     root->addChild(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 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);
@@ skipping 11 matching lines @@
     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(m_hostImpl->activeTree(), 1));
+    m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 2));
     DidDrawCheckLayer* layer1 = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
     layer1->addChild(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 3));
     DidDrawCheckLayer* layer2 = static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
 
     layer1->setOpacity(0.3f);
     layer1->setPreserves3D(false);
@@ skipping 35 matching lines @@
             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(m_hostImpl->activeTree(), 1));
+    m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl->activeTree(), 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(m_hostImpl->activeTree(), 3));
+    m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 3));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl->activeTree(), 4, 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(m_hostImpl->activeTree(), 5));
+    m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 5));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl->activeTree(), 6, 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(m_hostImpl->activeTree(), 7));
+    m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::create(m_hostImpl->activeTree(), 7));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(m_hostImpl->activeTree(), 8, 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(m_hostImpl->activeTree(), 1);
     root->setScrollable(false);
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->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)
 {
@@ skipping 11 matching lines @@
 
     scoped_ptr<LayerImpl> scrollLayer = LayerImpl::create(m_hostImpl->activeTree(), 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->activeTree()->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(m_hostImpl->activeTree(), 1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     root->addChild(createScrollableLayer(2, surfaceSize));
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->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(m_hostImpl->activeTree(), 1);
     root->addChild(createScrollableLayer(2, surfaceSize));
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->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(m_hostImpl->activeTree(), 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());
+    m_hostImpl->activeTree()->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);
 
     scoped_ptr<LayerImpl> scrollLayer = createScrollableLayer(2, surfaceSize);
     scrollLayer->addChild(contentLayer.Pass());
 
-    m_hostImpl->setRootLayer(scrollLayer.Pass());
+    m_hostImpl->activeTree()->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);
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->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 31 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);
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->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);
     m_hostImpl->scrollEnd();
@@ skipping 65 matching lines @@
 TEST_P(LayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
 {
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl->activeTree(), 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->activeTree()->SetRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
 
     gfx::Vector2d scrollDelta(0, 10);
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(child->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
@@ skipping 28 matching lines @@
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
 
     scoped_ptr<LayerImpl> grandChild = createScrollableLayer(3, surfaceSize);
     grandChild->setScrollOffset(gfx::Vector2d(0, 5));
 
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
     child->setScrollOffset(gfx::Vector2d(3, 0));
     child->addChild(grandChild.Pass());
 
     root->addChild(child.Pass());
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
         gfx::Vector2d scrollDelta(-8, -7);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
@@ skipping 11 matching lines @@
 {
     // When we try to scroll a non-scrollable child layer, the scroll delta
     // should be applied to one of its ancestors if possible.
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
     scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
 
     child->setScrollable(false);
     root->addChild(child.Pass());
 
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
         gfx::Vector2d scrollDelta(0, 4);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // Only the root should have scrolled.
         ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, scrollBeforeRedraw)
 {
     gfx::Size surfaceSize(10, 10);
-    m_hostImpl->setRootLayer(createScrollableLayer(1, surfaceSize));
+    m_hostImpl->activeTree()->SetRootLayer(createScrollableLayer(1, surfaceSize));
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
 
     // Draw one frame and then immediately rebuild the layer tree to mimic a tree synchronization.
     initializeRendererAndDrawFrame();
-    m_hostImpl->detachLayerTree();
-    m_hostImpl->setRootLayer(createScrollableLayer(2, surfaceSize));
+    m_hostImpl->activeTree()->DetachLayerTree();
+    m_hostImpl->activeTree()->SetRootLayer(createScrollableLayer(2, surfaceSize));
 
     // Scrolling should still work even though we did not draw yet.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollAxisAlignedRotatedLayer)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // Rotate the root layer 90 degrees counter-clockwise about its center.
@@ skipping 208 matching lines @@
 };
 
 TEST_P(LayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
 {
     {
         scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl->activeTree(), 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());
+        m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     }
     LayerImpl* root = m_hostImpl->rootLayer();
 
     root->addChild(BlendStateCheckLayer::create(m_hostImpl->activeTree(), 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.
@@ skipping 166 matching lines @@
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
 }
 
 TEST_P(LayerTreeHostImplTest, viewportCovered)
 {
     m_hostImpl->initializeRenderer(createOutputSurface());
-    m_hostImpl->setBackgroundColor(SK_ColorGRAY);
+    m_hostImpl->activeTree()->set_background_color(SK_ColorGRAY);
 
     gfx::Size viewportSize(1000, 1000);
     m_hostImpl->setViewportSize(viewportSize, viewportSize);
 
-    m_hostImpl->setRootLayer(LayerImpl::create(m_hostImpl->activeTree(), 1));
+    m_hostImpl->activeTree()->SetRootLayer(LayerImpl::create(m_hostImpl->activeTree(), 1));
     m_hostImpl->rootLayer()->addChild(BlendStateCheckLayer::create(m_hostImpl->activeTree(), 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());
@@ skipping 92 matching lines @@
 TEST_P(LayerTreeHostImplTest, reshapeNotCalledUntilDraw)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(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(m_hostImpl->activeTree(), 1);
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setBounds(gfx::Size(10, 10));
     root->setDrawsContent(true);
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     EXPECT_FALSE(reshapeTracker->reshapeCalled());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(reshapeTracker->reshapeCalled());
     m_hostImpl->didDrawAllLayers(frame);
 }
 
 class PartialSwapTrackerContext : public FakeWebGraphicsContext3D {
@@ skipping 37 matching lines @@
     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());
-    layerTreeHostImpl->setRootLayer(root.Pass());
+    layerTreeHostImpl->activeTree()->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();
     gfx::Rect expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(500, 500));
@@ skipping 43 matching lines @@
     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());
+    m_hostImpl->activeTree()->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);
 }
 
 class FakeLayerWithQuads : public LayerImpl {
@@ skipping 256 matching lines @@
     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);
 
     child->addChild(grandChild.Pass());
     root->addChild(child.Pass());
 
-    myHostImpl->setRootLayer(root.Pass());
+    myHostImpl->activeTree()->SetRootLayer(root.Pass());
     return myHostImpl.Pass();
 }
 
 TEST_P(LayerTreeHostImplTest, contributingLayerEmptyScissorPartialSwap)
 {
     scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(true, this, &m_proxy);
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
@@ skipping 47 matching lines @@
         : LayerImpl(treeImpl, id)
         , m_didLoseOutputSurfaceCalled(false)
     {
     }
 
     bool m_didLoseOutputSurfaceCalled;
 };
 
 TEST_P(LayerTreeHostImplTest, outputSurfaceLostAndRestoredNotificationSentToAllLayers)
 {
-    m_hostImpl->setRootLayer(OutputSurfaceLostNotificationCheckLayer::create(m_hostImpl->activeTree(), 1));
+    m_hostImpl->activeTree()->SetRootLayer(OutputSurfaceLostNotificationCheckLayer::create(m_hostImpl->activeTree(), 1));
     OutputSurfaceLostNotificationCheckLayer* root = static_cast<OutputSurfaceLostNotificationCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(OutputSurfaceLostNotificationCheckLayer::create(m_hostImpl->activeTree(), 2));
     OutputSurfaceLostNotificationCheckLayer* layer1 = static_cast<OutputSurfaceLostNotificationCheckLayer*>(root->children()[0]);
 
     layer1->addChild(OutputSurfaceLostNotificationCheckLayer::create(m_hostImpl->activeTree(), 3));
     OutputSurfaceLostNotificationCheckLayer* layer2 = static_cast<OutputSurfaceLostNotificationCheckLayer*>(layer1->children()[0]);
 
     EXPECT_FALSE(root->didLoseOutputSurfaceCalled());
     EXPECT_FALSE(layer1->didLoseOutputSurfaceCalled());
@@ skipping 415 matching lines @@
     hwProvider.setFrame(&hwVideoFrame);
 
     FakeVideoFrame videoFrameScaled(
         VideoFrame::WrapNativeTexture(
             m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture(),
             GL_TEXTURE_2D,
             gfx::Size(4, 4), gfx::Rect(0, 0, 3, 2), gfx::Size(4, 4), base::TimeDelta(),
             VideoFrame::ReadPixelsCB(), base::Closure()));
     providerScaled.setFrame(&videoFrameScaled);
 
-    m_hostImpl->setRootLayer(rootLayer.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(rootLayer.Pass());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
     unsigned numResources = m_hostImpl->resourceProvider()->numResources();
 
     // Lose the WebKit::WebGraphicsContext3D, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
@@ skipping 112 matching lines @@
     ioSurfaceLayer->setContentBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setDrawsContent(true);
     ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
     rootLayer->addChild(ioSurfaceLayer.PassAs<LayerImpl>());
 
     // Lose the WebGraphicsContext3D, replacing it with a TrackingWebGraphicsContext3D (which the LayerTreeHostImpl takes ownership of).
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TrackingWebGraphicsContext3D)));
     TrackingWebGraphicsContext3D* trackingWebGraphicsContext3D = static_cast<TrackingWebGraphicsContext3D*>(outputSurface->Context3D());
     m_hostImpl->initializeRenderer(outputSurface.Pass());
 
-    m_hostImpl->setRootLayer(rootLayer.Pass());
+    m_hostImpl->activeTree()->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(m_hostImpl->activeTree(), 100));
+    m_hostImpl->activeTree()->SetRootLayer(LayerImpl::create(m_hostImpl->activeTree(), 100));
     // There should be no textures left in use after.
     EXPECT_EQ(0u, trackingWebGraphicsContext3D->numTextures());
 }
 
 class MockDrawQuadsToFillScreenContext : public FakeWebGraphicsContext3D {
 public:
     MOCK_METHOD1(useProgram, void(WebKit::WebGLId program));
     MOCK_METHOD4(drawElements, void(WebKit::WGC3Denum mode, WebKit::WGC3Dsizei count, WebKit::WGC3Denum type, WebKit::WGC3Dintptr offset));
 };
 
 TEST_P(LayerTreeHostImplTest, hasTransparentBackground)
 {
     scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockDrawQuadsToFillScreenContext)).PassAs<OutputSurface>();
     MockDrawQuadsToFillScreenContext* mockContext = static_cast<MockDrawQuadsToFillScreenContext*>(outputSurface->Context3D());
 
     // Run test case
     createLayerTreeHost(false, outputSurface.Pass());
     setupRootLayerImpl(LayerImpl::create(m_hostImpl->activeTree(), 1));
-    m_hostImpl->setBackgroundColor(SK_ColorWHITE);
+    m_hostImpl->activeTree()->set_background_color(SK_ColorWHITE);
 
     // Verify one quad is drawn when transparent background set is not set.
-    m_hostImpl->setHasTransparentBackground(false);
+    m_hostImpl->activeTree()->set_has_transparent_background(false);
     EXPECT_CALL(*mockContext, useProgram(_))
         .Times(1);
     EXPECT_CALL(*mockContext, drawElements(_, _, _, _))
         .Times(1);
     LayerTreeHostImpl::FrameData 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.
-    m_hostImpl->setHasTransparentBackground(true);
+    m_hostImpl->activeTree()->set_has_transparent_background(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(parent->layerTreeImpl(), id);
     LayerImpl* layerPtr = layer.get();
@@ skipping 77 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl->activeTree(), 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());
+    myHostImpl->activeTree()->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 90 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl->activeTree(), 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());
+    myHostImpl->activeTree()->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
     addDrawingLayerTo(layerS1Ptr, 9, gfx::Rect(500, 500, 300, 300), 0); // L14
@@ skipping 91 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl->activeTree(), 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());
+    myHostImpl->activeTree()->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 60 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl->activeTree(), 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());
+    myHostImpl->activeTree()->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);
 
     addDrawingLayerTo(layerS1Ptr, 3, gfx::Rect(200, 0, 200, 400), 0); // L11
@@ skipping 63 matching lines @@
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(myHostImpl->activeTree(), 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());
+    myHostImpl->activeTree()->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 116 matching lines @@
     grandChild->setPosition(gfx::Point(grandChildRect.x(), grandChildRect.y()));
     grandChild->setBounds(gfx::Size(grandChildRect.width(), grandChildRect.height()));
     grandChild->setContentBounds(grandChild->bounds());
     grandChild->setDrawsContent(true);
 
     TiledLayerImpl* childPtr = child.get();
     RenderPass::Id childPassId(childPtr->id(), 0);
 
     child->addChild(grandChild.Pass());
     root->addChild(child.PassAs<LayerImpl>());
-    myHostImpl->setRootLayer(root.Pass());
+    myHostImpl->activeTree()->SetRootLayer(root.Pass());
     myHostImpl->setViewportSize(rootRect.size(), rootRect.size());
 
     EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(childPassId));
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
@@ skipping 718 matching lines @@
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
     // For this test we want to force scrolls to only pan the pinchZoomViewport
     // and not the document, we can verify commit/redraw are requested.
     root->setMaxScrollOffset(gfx::Vector2d());
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
@@ skipping 51 matching lines @@
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
     // For this test we want to force scrolls to move the pinchZoomViewport so
     // we can see the scroll component on the implTransform.
     root->setMaxScrollOffset(gfx::Vector2d());
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
@@ skipping 63 matching lines @@
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
     // For this test we want to scrolls to move both the document and the
     // pinchZoomViewport so we can see some scroll component on the implTransform.
     root->setMaxScrollOffset(gfx::Vector2d(3, 4));
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
@@ skipping 102 matching lines @@
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
     // For this test we want to scrolls to move both the document and the
     // pinchZoomViewport so we can see some scroll component on the implTransform.
     root->setMaxScrollOffset(gfx::Vector2d(3, 4));
-    m_hostImpl->setRootLayer(root.Pass());
+    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
@@ skipping 98 matching lines @@
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc