[cc] Move root layer pointer to LayerTreeImpl

cc/layer_tree_host_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.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/layer_tree_host_impl.h"
@@ skipping 145 matching lines @@
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         m_numDraws++;
-        if (!impl->sourceFrameNumber())
+        if (!impl->activeTree()->source_frame_number())
             endTest();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         m_numCommits++;
     }
 
     virtual void afterTest() OVERRIDE
     {
@@ skipping 21 matching lines @@
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
-        if (!impl->sourceFrameNumber())
+        if (impl->activeTree()->source_frame_number() == 0)
             postSetNeedsCommitToMainThread();
-        else if (impl->sourceFrameNumber() == 1)
+        else if (impl->activeTree()->source_frame_number() == 1)
             endTest();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         m_numCommits++;
     }
 
     virtual void afterTest() OVERRIDE
     {
@@ skipping 21 matching lines @@
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
-        EXPECT_EQ(0, impl->sourceFrameNumber());
+        EXPECT_EQ(0, impl->activeTree()->source_frame_number());
         if (!m_numDraws)
             postSetNeedsRedrawToMainThread(); // Redraw again to verify that the second redraw doesn't commit.
         else
             endTest();
         m_numDraws++;
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         EXPECT_EQ(0, m_numDraws);
@@ skipping 26 matching lines @@
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         // Only the initial draw should bring us here.
         EXPECT_TRUE(impl->canDraw());
-        EXPECT_EQ(0, impl->sourceFrameNumber());
+        EXPECT_EQ(0, impl->activeTree()->source_frame_number());
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         if (m_numCommits >= 1) {
             // After the first commit, we should not be able to draw.
             EXPECT_FALSE(impl->canDraw());
         }
     }
 
@@ skipping 554 matching lines @@
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         LayerImpl* root = impl->rootLayer();
         EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
 
         root->setScrollable(true);
         root->setMaxScrollOffset(gfx::Vector2d(100, 100));
         root->scrollBy(m_scrollAmount);
 
-        if (!impl->sourceFrameNumber()) {
+        if (!impl->activeTree()->source_frame_number()) {
             EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
             EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount);
             postSetNeedsCommitToMainThread();
-        } else if (impl->sourceFrameNumber() == 1) {
+        } else if (impl->activeTree()->source_frame_number() == 1) {
             EXPECT_VECTOR_EQ(root->scrollOffset(), m_secondScroll);
             EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount);
             endTest();
         }
     }
 
     virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
         gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
         m_layerTreeHost->rootLayer()->setScrollOffset(offset + scrollDelta);
@@ skipping 42 matching lines @@
         else if (m_layerTreeHost->commitNumber() == 2)
             EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll + m_scrollAmount + m_scrollAmount);
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         LayerImpl* root = impl->rootLayer();
         root->setScrollable(true);
         root->setMaxScrollOffset(gfx::Vector2d(100, 100));
 
-        if (!impl->sourceFrameNumber() && impl->sourceAnimationFrameNumber() == 1) {
+        if (!impl->activeTree()->source_frame_number() && impl->sourceAnimationFrameNumber() == 1) {
             // First draw after first commit.
             EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
             root->scrollBy(m_scrollAmount);
             EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount);
 
             EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
             postSetNeedsRedrawToMainThread();
-        } else if (!impl->sourceFrameNumber() && impl->sourceAnimationFrameNumber() == 2) {
+        } else if (!impl->activeTree()->source_frame_number() && impl->sourceAnimationFrameNumber() == 2) {
             // Second draw after first commit.
             EXPECT_EQ(root->scrollDelta(), m_scrollAmount);
             root->scrollBy(m_scrollAmount);
             EXPECT_VECTOR_EQ(root->scrollDelta(), m_scrollAmount + m_scrollAmount);
 
             EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll);
             postSetNeedsCommitToMainThread();
-        } else if (impl->sourceFrameNumber() == 1) {
+        } else if (impl->activeTree()->source_frame_number() == 1) {
             // Third or later draw after second commit.
             EXPECT_GE(impl->sourceAnimationFrameNumber(), 3);
             EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
             EXPECT_VECTOR_EQ(root->scrollOffset(), m_initialScroll + m_scrollAmount + m_scrollAmount);
             endTest();
         }
     }
 
     virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
@@ skipping 89 matching lines @@
     {
         gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
         m_layerTreeHost->rootLayer()->setScrollOffset(offset + scrollDelta);
         m_layerTreeHost->setPageScaleFactorAndLimits(scale, 0.5, 2);
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         impl->processScrollDeltas();
         // We get one commit before the first draw, and the animation doesn't happen until the second draw.
-        if (impl->sourceFrameNumber() == 1) {
+        if (impl->activeTree()->source_frame_number() == 1) {
             EXPECT_EQ(1.25, impl->pageScaleFactor());
             endTest();
         } else
             postSetNeedsRedrawToMainThread();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
@@ skipping 223 matching lines @@
         m_layerTreeHost->setRootLayer(m_rootLayer);
         postSetNeedsCommitToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         // Get access to protected methods.
         MockLayerTreeHostImpl* mockImpl = static_cast<MockLayerTreeHostImpl*>(impl);
 
         // Should only do one commit.
-        EXPECT_EQ(0, impl->sourceFrameNumber());
+        EXPECT_EQ(0, impl->activeTree()->source_frame_number());
         // Device scale factor should come over to impl.
         EXPECT_NEAR(impl->deviceScaleFactor(), 1.5, 0.00001);
 
         // Both layers are on impl.
         ASSERT_EQ(1u, impl->rootLayer()->children().size());
 
         // Device viewport is scaled.
         EXPECT_EQ(gfx::Size(40, 40), impl->layoutViewportSize());
         EXPECT_EQ(gfx::Size(60, 60), impl->deviceViewportSize());
 
@@ skipping 74 matching lines @@
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
         postSetNeedsCommitToMainThread();
         postSetNeedsRedrawToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->context3D());
 
-        switch (impl->sourceFrameNumber()) {
+        switch (impl->activeTree()->source_frame_number()) {
         case 0:
             // Number of textures should be one.
             ASSERT_EQ(1, context->numTextures());
             // Number of textures used for commit should be one.
             EXPECT_EQ(1, context->numUsedTextures());
             // Verify that used texture is correct.
             EXPECT_TRUE(context->usedTexture(context->texture(0)));
 
             context->resetUsedTextures();
             break;
@@ skipping 16 matching lines @@
         }
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->context3D());
 
         // Number of textures used for draw should always be one.
         EXPECT_EQ(1, context->numUsedTextures());
 
-        if (impl->sourceFrameNumber() < 1) {
+        if (impl->activeTree()->source_frame_number() < 1) {
             context->resetUsedTextures();
             postSetNeedsCommitToMainThread();
             postSetNeedsRedrawToMainThread();
         } else
             endTest();
     }
 
     virtual void layout() OVERRIDE
     {
         m_layer->setNeedsDisplay();
@@ skipping 46 matching lines @@
         setLayerPropertiesForTesting(m_child.get(), m_parent.get(), identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 10), gfx::Size(10, 10), false);
 
         postSetNeedsCommitToMainThread();
         postSetNeedsRedrawToMainThread();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->context3D());
 
-        switch (impl->sourceFrameNumber()) {
+        switch (impl->activeTree()->source_frame_number()) {
         case 0:
             // Number of textures should be two.
             ASSERT_EQ(2, context->numTextures());
             // Number of textures used for commit should be two.
             EXPECT_EQ(2, context->numUsedTextures());
             // Verify that used textures are correct.
             EXPECT_TRUE(context->usedTexture(context->texture(0)));
             EXPECT_TRUE(context->usedTexture(context->texture(1)));
 
             context->resetUsedTextures();
@@ skipping 33 matching lines @@
             break;
         }
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         CompositorFakeWebGraphicsContext3DWithTextureTracking* context = static_cast<CompositorFakeWebGraphicsContext3DWithTextureTracking*>(impl->outputSurface()->context3D());
 
         // Number of textures used for drawing should two except for frame 4
         // where the viewport only contains one layer.
-        if (impl->sourceFrameNumber() == 3)
+        if (impl->activeTree()->source_frame_number() == 3)
             EXPECT_EQ(1, context->numUsedTextures());
         else
             EXPECT_EQ(2, context->numUsedTextures());
 
-        if (impl->sourceFrameNumber() < 4) {
+        if (impl->activeTree()->source_frame_number() < 4) {
             context->resetUsedTextures();
             postSetNeedsCommitToMainThread();
             postSetNeedsRedrawToMainThread();
         } else
             endTest();
     }
 
     virtual void layout() OVERRIDE
     {
         switch (m_numCommits++) {
@@ skipping 458 matching lines @@
         m_layerTreeHost->rootLayer()->setScrollable(true);
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         LayerImpl* root = impl->rootLayer();
         root->setMaxScrollOffset(gfx::Vector2d(100, 100));
 
         // Check that a fractional scroll delta is correctly accumulated over multiple commits.
-        if (!impl->sourceFrameNumber()) {
+        if (!impl->activeTree()->source_frame_number()) {
             EXPECT_VECTOR_EQ(root->scrollOffset(), gfx::Vector2d(0, 0));
             EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d(0, 0));
             postSetNeedsCommitToMainThread();
-        } else if (impl->sourceFrameNumber() == 1) {
+        } else if (impl->activeTree()->source_frame_number() == 1) {
             EXPECT_VECTOR_EQ(root->scrollOffset(), gfx::ToFlooredVector2d(m_scrollAmount));
             EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2dF(fmod(m_scrollAmount.x(), 1), 0));
             postSetNeedsCommitToMainThread();
-        } else if (impl->sourceFrameNumber() == 2) {
+        } else if (impl->activeTree()->source_frame_number() == 2) {
             EXPECT_VECTOR_EQ(root->scrollOffset(), gfx::ToFlooredVector2d(m_scrollAmount + m_scrollAmount));
             EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2dF(fmod(2 * m_scrollAmount.x(), 1), 0));
             endTest();
         }
         root->scrollBy(m_scrollAmount);
     }
 
     virtual void applyScrollAndScale(gfx::Vector2d scrollDelta, float scale) OVERRIDE
     {
         gfx::Vector2d offset = m_layerTreeHost->rootLayer()->scrollOffset();
@@ skipping 191 matching lines @@
         LayerImpl* rootScrollLayer = root->children()[0];
         LayerImpl* childLayer = rootScrollLayer->children()[0];
 
         EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
         EXPECT_VECTOR_EQ(rootScrollLayer->scrollDelta(), gfx::Vector2d());
         EXPECT_EQ(rootScrollLayer->bounds().width() * m_deviceScaleFactor, rootScrollLayer->contentBounds().width());
         EXPECT_EQ(rootScrollLayer->bounds().height() * m_deviceScaleFactor, rootScrollLayer->contentBounds().height());
         EXPECT_EQ(childLayer->bounds().width() * m_deviceScaleFactor, childLayer->contentBounds().width());
         EXPECT_EQ(childLayer->bounds().height() * m_deviceScaleFactor, childLayer->contentBounds().height());
 
-        switch (impl->sourceFrameNumber()) {
+        switch (impl->activeTree()->source_frame_number()) {
         case 0:
             // Gesture scroll on impl thread.
             EXPECT_EQ(impl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
             impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
             EXPECT_VECTOR_EQ(m_initialScroll, childLayer->scrollOffset());
             EXPECT_VECTOR_EQ(m_scrollAmount, childLayer->scrollDelta());
             break;
         case 1:
@@ skipping 114 matching lines @@
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         LayerImpl* root = impl->rootLayer();
         LayerImpl* rootScrollLayer = root->children()[0];
 
         EXPECT_VECTOR_EQ(root->scrollDelta(), gfx::Vector2d());
         EXPECT_EQ(rootScrollLayer->bounds().width() * m_deviceScaleFactor, rootScrollLayer->contentBounds().width());
         EXPECT_EQ(rootScrollLayer->bounds().height() * m_deviceScaleFactor, rootScrollLayer->contentBounds().height());
 
-        switch (impl->sourceFrameNumber()) {
+        switch (impl->activeTree()->source_frame_number()) {
         case 0:
             // Gesture scroll on impl thread.
             EXPECT_EQ(impl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
             impl->scrollBy(gfx::Point(), m_scrollAmount);
             impl->scrollEnd();
 
             EXPECT_VECTOR_EQ(m_initialScroll, rootScrollLayer->scrollOffset());
             EXPECT_VECTOR_EQ(m_scrollAmount, rootScrollLayer->scrollDelta());
             break;
         case 1:
@@ skipping 145 matching lines @@
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* hostImpl) OVERRIDE
     {
         Renderer* renderer = hostImpl->renderer();
         RenderPass::Id surface1RenderPassId = hostImpl->rootLayer()->children()[0]->renderSurface()->renderPassId();
         RenderPass::Id surface2RenderPassId = hostImpl->rootLayer()->children()[0]->children()[0]->renderSurface()->renderPassId();
 
-        switch (hostImpl->sourceFrameNumber()) {
+        switch (hostImpl->activeTree()->source_frame_number()) {
         case 0:
             EXPECT_TRUE(renderer->haveCachedResourcesForRenderPassId(surface1RenderPassId));
             EXPECT_TRUE(renderer->haveCachedResourcesForRenderPassId(surface2RenderPassId));
 
             // Reduce the memory limit to only fit the root layer and one render surface. This
             // prevents any contents drawing into surfaces from being allocated.
             hostImpl->setManagedMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
             break;
         case 1:
             EXPECT_FALSE(renderer->haveCachedResourcesForRenderPassId(surface1RenderPassId));
@@ skipping 771 matching lines @@
     LayerTreeSettings settings;
     settings.maxPartialTextureUpdates = 4;
 
     scoped_ptr<LayerTreeHost> host = LayerTreeHost::create(&client, settings, scoped_ptr<Thread>());
     EXPECT_TRUE(host->initializeRendererIfNeeded());
     EXPECT_EQ(4u, host->settings().maxPartialTextureUpdates);
 }
 
 }  // namespace
 }  // namespace cc