Remove static thread pointers from CC

cc/tiled_layer_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 "config.h"
 
 #include "cc/tiled_layer.h"
 
 #include "cc/bitmap_content_layer_updater.h"
 #include "cc/layer_painter.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/rendering_stats.h"
 #include "cc/resource_update_controller.h"
 #include "cc/single_thread_proxy.h" // For DebugScopedSetImplThread
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_graphics_context.h"
 #include "cc/test/fake_layer_tree_host_client.h"
+#include "cc/test/fake_proxy.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include <public/WebTransformationMatrix.h>
 
 using namespace cc;
 using namespace WebKitTests;
 using WebKit::WebTransformationMatrix;
 
@@ skipping 14 matching lines @@
 protected:
     virtual gfx::Rect layerClipRectInTarget(const Layer* layer) const OVERRIDE { return m_layerClipRectInTarget; }
 
 private:
     gfx::Rect m_layerClipRectInTarget;
 };
 
 class TiledLayerTest : public testing::Test {
 public:
     TiledLayerTest()
-        : m_context(WebKit::createFakeGraphicsContext())
+        : m_proxy(NULL)
+        , m_context(WebKit::createFakeGraphicsContext())
         , m_queue(make_scoped_ptr(new ResourceUpdateQueue))
-        , m_resourceManager(PrioritizedResourceManager::create(60*1024*1024, 1024, Renderer::ContentPool))
         , m_occlusion(0)
     {
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+    }
+
+    virtual void SetUp()
+    {
+        m_layerTreeHost = LayerTreeHost::create(&m_fakeLayerImplTreeHostClient, m_settings, scoped_ptr<Thread>(NULL));
+        m_proxy = m_layerTreeHost->proxy();
+        m_resourceManager = PrioritizedResourceManager::create(60*1024*1024, 1024, Renderer::ContentPool, m_proxy);
+        m_layerTreeHost->initializeRendererIfNeeded();
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         m_resourceProvider = ResourceProvider::create(m_context.get());
     }
 
     virtual ~TiledLayerTest()
     {
         resourceManagerClearAllMemory(m_resourceManager.get(), m_resourceProvider.get());
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         m_resourceProvider.reset();
     }
 
-    // Helper classes and functions that set the current thread to be the impl thread
-    // before doing the action that they wrap.
     class ScopedFakeTiledLayerImpl {
     public:
         ScopedFakeTiledLayerImpl(int id)
         {
-            DebugScopedSetImplThread implThread;
             m_layerImpl = new FakeTiledLayerImpl(id);
         }
         ~ScopedFakeTiledLayerImpl()
         {
-            DebugScopedSetImplThread implThread;
             delete m_layerImpl;
         }
         FakeTiledLayerImpl* get()
         {
             return m_layerImpl;
         }
         FakeTiledLayerImpl* operator->()
         {
             return m_layerImpl;
         }
     private:
         FakeTiledLayerImpl* m_layerImpl;
     };
     void resourceManagerClearAllMemory(PrioritizedResourceManager* resourceManager, ResourceProvider* resourceProvider)
     {
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         resourceManager->clearAllMemory(resourceProvider);
         resourceManager->reduceMemory(resourceProvider);
     }
     void updateTextures()
     {
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         DCHECK(m_queue);
         scoped_ptr<ResourceUpdateController> updateController =
             ResourceUpdateController::create(
                 NULL,
-                Proxy::implThread(),
+                m_proxy->implThread(),
                 m_queue.Pass(),
-                m_resourceProvider.get());
+                m_resourceProvider.get(),
+                m_proxy->hasImplThread());
         updateController->finalize();
         m_queue = make_scoped_ptr(new ResourceUpdateQueue);
     }
     void layerPushPropertiesTo(FakeTiledLayer* layer, FakeTiledLayerImpl* layerImpl)
     {
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         layer->pushPropertiesTo(layerImpl);
     }
     void layerUpdate(FakeTiledLayer* layer, TestOcclusionTracker* occluded)
     {
-        DebugScopedSetMainThread mainThread;
+        DebugScopedSetMainThread mainThread(m_proxy);
         layer->update(*m_queue.get(), occluded, m_stats);
     }
 
     bool updateAndPush(FakeTiledLayer* layer1,
                        FakeTiledLayerImpl* layerImpl1,
                        FakeTiledLayer* layer2 = 0,
                        FakeTiledLayerImpl* layerImpl2 = 0)
     {
         // Get textures
         m_resourceManager->clearPriorities();
@@ skipping 19 matching lines @@
         updateTextures();
         if (layer1)
             layerPushPropertiesTo(layer1, layerImpl1);
         if (layer2)
             layerPushPropertiesTo(layer2, layerImpl2);
 
         return needsUpdate;
     }
 
 public:
+    Proxy* m_proxy;
+    LayerTreeSettings m_settings;
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     scoped_ptr<ResourceUpdateQueue> m_queue;
     RenderingStats m_stats;
     PriorityCalculator m_priorityCalculator;
+    FakeLayerImplTreeHostClient m_fakeLayerImplTreeHostClient;
+    scoped_ptr<LayerTreeHost> m_layerTreeHost;
     scoped_ptr<PrioritizedResourceManager> m_resourceManager;
     TestOcclusionTracker* m_occlusion;
 };
 
 TEST_F(TiledLayerTest, pushDirtyTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     ScopedFakeTiledLayerImpl layerImpl(1);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
@@ skipping 331 matching lines @@
     EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 1));
     EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, paintSmallAnimatedLayersImmediately)
 {
     // Create a LayerTreeHost that has the right viewportsize,
     // so the layer is considered small enough.
     FakeLayerImplTreeHostClient fakeLayerImplTreeHostClient;
-    scoped_ptr<LayerTreeHost> layerTreeHost = LayerTreeHost::create(&fakeLayerImplTreeHostClient, LayerTreeSettings());
+    scoped_ptr<LayerTreeHost> layerTreeHost = LayerTreeHost::create(&fakeLayerImplTreeHostClient, LayerTreeSettings(), scoped_ptr<Thread>(NULL));
 
     bool runOutOfMemory[2] = {false, true};
     for (int i = 0; i < 2; i++) {
         // Create a layer with 4x4 tiles.
         int layerWidth  = 4 * FakeTiledLayer::tileSize().width();
         int layerHeight = 4 * FakeTiledLayer::tileSize().height();
         int memoryForLayer = layerWidth * layerHeight * 4;
         gfx::Size viewportSize = gfx::Size(layerWidth, layerHeight);
         layerTreeHost->setViewportSize(viewportSize, viewportSize);
 
@@ skipping 245 matching lines @@
 
     layerPushPropertiesTo(layer.get(), layerImpl.get());
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 0));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 1));
 }
 
 TEST_F(TiledLayerTest, skipsDrawGetsReset)
 {
-    FakeLayerImplTreeHostClient fakeLayerImplTreeHostClient;
-    scoped_ptr<LayerTreeHost> layerTreeHost = LayerTreeHost::create(&fakeLayerImplTreeHostClient, LayerTreeSettings());
-    ASSERT_TRUE(layerTreeHost->initializeRendererIfNeeded());
-
     // Create two 300 x 300 tiled layers.
     gfx::Size contentBounds(300, 300);
     gfx::Rect contentRect(gfx::Point(), contentBounds);
 
     // We have enough memory for only one of the two layers.
     int memoryLimit = 4 * 300 * 300; // 4 bytes per pixel.
 
-    scoped_refptr<FakeTiledLayer> rootLayer = make_scoped_refptr(new FakeTiledLayer(layerTreeHost->contentsTextureManager()));
-    scoped_refptr<FakeTiledLayer> childLayer = make_scoped_refptr(new FakeTiledLayer(layerTreeHost->contentsTextureManager()));
+    scoped_refptr<FakeTiledLayer> rootLayer = make_scoped_refptr(new FakeTiledLayer(m_layerTreeHost->contentsTextureManager()));
+    scoped_refptr<FakeTiledLayer> childLayer = make_scoped_refptr(new FakeTiledLayer(m_layerTreeHost->contentsTextureManager()));
     rootLayer->addChild(childLayer);
 
     rootLayer->setBounds(contentBounds);
     rootLayer->setVisibleContentRect(contentRect);
     rootLayer->setPosition(gfx::PointF(0, 0));
     childLayer->setBounds(contentBounds);
     childLayer->setVisibleContentRect(contentRect);
     childLayer->setPosition(gfx::PointF(0, 0));
     rootLayer->invalidateContentRect(contentRect);
     childLayer->invalidateContentRect(contentRect);
 
-    layerTreeHost->setRootLayer(rootLayer);
-    layerTreeHost->setViewportSize(gfx::Size(300, 300), gfx::Size(300, 300));
+    m_layerTreeHost->setRootLayer(rootLayer);
+    m_layerTreeHost->setViewportSize(gfx::Size(300, 300), gfx::Size(300, 300));
 
-    layerTreeHost->updateLayers(*m_queue.get(), memoryLimit);
+    m_layerTreeHost->updateLayers(*m_queue.get(), memoryLimit);
 
     // We'll skip the root layer.
     EXPECT_TRUE(rootLayer->skipsDraw());
     EXPECT_FALSE(childLayer->skipsDraw());
 
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // Remove the child layer.
     rootLayer->removeAllChildren();
 
-    layerTreeHost->updateLayers(*m_queue.get(), memoryLimit);
+    m_layerTreeHost->updateLayers(*m_queue.get(), memoryLimit);
     EXPECT_FALSE(rootLayer->skipsDraw());
 
-    resourceManagerClearAllMemory(layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
-    layerTreeHost->setRootLayer(0);
+    resourceManagerClearAllMemory(m_layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
+    m_layerTreeHost->setRootLayer(0);
 }
 
 TEST_F(TiledLayerTest, resizeToSmaller)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
 
     layer->setBounds(gfx::Size(700, 700));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 700, 700));
     layer->invalidateContentRect(gfx::Rect(0, 0, 700, 700));
 
@@ skipping 13 matching lines @@
     layer->setBounds(gfx::Size(size, size));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 700, 700));
     layer->invalidateContentRect(gfx::Rect(0, 0, size, size));
 
     // Ensure no crash for bounds where size * size would overflow an int.
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), 0, m_stats);
 }
 
-TEST_F(TiledLayerTest, partialUpdates)
+class TiledLayerPartialUpdateTest : public TiledLayerTest {
+public:
+    TiledLayerPartialUpdateTest()
+    {
+        m_settings.maxPartialTextureUpdates = 4;
+    }
+};
+
+TEST_F(TiledLayerPartialUpdateTest, partialUpdates)
 {
-    LayerTreeSettings settings;
-    settings.maxPartialTextureUpdates = 4;
-
-    FakeLayerImplTreeHostClient fakeLayerImplTreeHostClient;
-    scoped_ptr<LayerTreeHost> layerTreeHost = LayerTreeHost::create(&fakeLayerImplTreeHostClient, settings);
-    ASSERT_TRUE(layerTreeHost->initializeRendererIfNeeded());
-
     // Create one 300 x 200 tiled layer with 3 x 2 tiles.
     gfx::Size contentBounds(300, 200);
     gfx::Rect contentRect(gfx::Point(), contentBounds);
 
-    scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(layerTreeHost->contentsTextureManager()));
+    scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_layerTreeHost->contentsTextureManager()));
     layer->setBounds(contentBounds);
     layer->setPosition(gfx::PointF(0, 0));
     layer->setVisibleContentRect(contentRect);
     layer->invalidateContentRect(contentRect);
 
-    layerTreeHost->setRootLayer(layer);
-    layerTreeHost->setViewportSize(gfx::Size(300, 200), gfx::Size(300, 200));
+    m_layerTreeHost->setRootLayer(layer);
+    m_layerTreeHost->setViewportSize(gfx::Size(300, 200), gfx::Size(300, 200));
 
     // Full update of all 6 tiles.
-    layerTreeHost->updateLayers(
+    m_layerTreeHost->updateLayers(
         *m_queue.get(), std::numeric_limits<size_t>::max());
     {
         ScopedFakeTiledLayerImpl layerImpl(1);
         EXPECT_EQ(6, m_queue->fullUploadSize());
         EXPECT_EQ(0, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // Full update of 3 tiles and partial update of 3 tiles.
     layer->invalidateContentRect(gfx::Rect(0, 0, 300, 150));
-    layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
+    m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
     {
         ScopedFakeTiledLayerImpl layerImpl(1);
         EXPECT_EQ(3, m_queue->fullUploadSize());
         EXPECT_EQ(3, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // Partial update of 6 tiles.
     layer->invalidateContentRect(gfx::Rect(50, 50, 200, 100));
     {
         ScopedFakeTiledLayerImpl layerImpl(1);
-        layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
+        m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
         EXPECT_EQ(2, m_queue->fullUploadSize());
         EXPECT_EQ(4, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // Checkerboard all tiles.
     layer->invalidateContentRect(gfx::Rect(0, 0, 300, 200));
     {
         ScopedFakeTiledLayerImpl layerImpl(1);
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // Partial update of 6 checkerboard tiles.
     layer->invalidateContentRect(gfx::Rect(50, 50, 200, 100));
     {
         ScopedFakeTiledLayerImpl layerImpl(1);
-        layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
+        m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
         EXPECT_EQ(6, m_queue->fullUploadSize());
         EXPECT_EQ(0, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // Partial update of 4 tiles.
     layer->invalidateContentRect(gfx::Rect(50, 50, 100, 100));
     {
         ScopedFakeTiledLayerImpl layerImpl(1);
-        layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
+        m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
         EXPECT_EQ(0, m_queue->fullUploadSize());
         EXPECT_EQ(4, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(4, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
-    resourceManagerClearAllMemory(layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
-    layerTreeHost->setRootLayer(0);
+    resourceManagerClearAllMemory(m_layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
+    m_layerTreeHost->setRootLayer(0);
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithoutOcclusion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(gfx::Size(100, 200));
     layer->setDrawableContentRect(gfx::Rect(0, 0, 100, 200));
     layer->setVisibleContentRect(gfx::Rect(0, 0, 100, 200));
@@ skipping 400 matching lines @@
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, dontAllocateContentsWhenTargetSurfaceCantBeAllocated)
 {
     // Tile size is 100x100.
     gfx::Rect rootRect(0, 0, 300, 200);
     gfx::Rect childRect(0, 0, 300, 100);
     gfx::Rect child2Rect(0, 100, 300, 100);
 
-    LayerTreeSettings settings;
-    FakeLayerImplTreeHostClient fakeLayerImplTreeHostClient;
-    scoped_ptr<LayerTreeHost> layerTreeHost = LayerTreeHost::create(&fakeLayerImplTreeHostClient, settings);
-    ASSERT_TRUE(layerTreeHost->initializeRendererIfNeeded());
-
-    scoped_refptr<FakeTiledLayer> root = make_scoped_refptr(new FakeTiledLayer(layerTreeHost->contentsTextureManager()));
+    scoped_refptr<FakeTiledLayer> root = make_scoped_refptr(new FakeTiledLayer(m_layerTreeHost->contentsTextureManager()));
     scoped_refptr<Layer> surface = Layer::create();
-    scoped_refptr<FakeTiledLayer> child = make_scoped_refptr(new FakeTiledLayer(layerTreeHost->contentsTextureManager()));
-    scoped_refptr<FakeTiledLayer> child2 = make_scoped_refptr(new FakeTiledLayer(layerTreeHost->contentsTextureManager()));
+    scoped_refptr<FakeTiledLayer> child = make_scoped_refptr(new FakeTiledLayer(m_layerTreeHost->contentsTextureManager()));
+    scoped_refptr<FakeTiledLayer> child2 = make_scoped_refptr(new FakeTiledLayer(m_layerTreeHost->contentsTextureManager()));
 
     root->setBounds(rootRect.size());
     root->setAnchorPoint(gfx::PointF());
     root->setDrawableContentRect(rootRect);
     root->setVisibleContentRect(rootRect);
     root->addChild(surface);
 
     surface->setForceRenderSurface(true);
     surface->setAnchorPoint(gfx::PointF());
     surface->setOpacity(0.5);
     surface->addChild(child);
     surface->addChild(child2);
 
     child->setBounds(childRect.size());
     child->setAnchorPoint(gfx::PointF());
     child->setPosition(childRect.origin());
     child->setVisibleContentRect(childRect);
     child->setDrawableContentRect(rootRect);
 
     child2->setBounds(child2Rect.size());
     child2->setAnchorPoint(gfx::PointF());
     child2->setPosition(child2Rect.origin());
     child2->setVisibleContentRect(child2Rect);
     child2->setDrawableContentRect(rootRect);
 
-    layerTreeHost->setRootLayer(root);
-    layerTreeHost->setViewportSize(rootRect.size(), rootRect.size());
+    m_layerTreeHost->setRootLayer(root);
+    m_layerTreeHost->setViewportSize(rootRect.size(), rootRect.size());
 
     // With a huge memory limit, all layers should update and push their textures.
     root->invalidateContentRect(rootRect);
     child->invalidateContentRect(childRect);
     child2->invalidateContentRect(child2Rect);
-    layerTreeHost->updateLayers(
+    m_layerTreeHost->updateLayers(
         *m_queue.get(), std::numeric_limits<size_t>::max());
     {
         updateTextures();
         EXPECT_EQ(6, root->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(3, child->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(3, child2->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
 
         root->fakeLayerUpdater()->clearUpdateCount();
         child->fakeLayerUpdater()->clearUpdateCount();
         child2->fakeLayerUpdater()->clearUpdateCount();
 
         ScopedFakeTiledLayerImpl rootImpl(root->id());
         ScopedFakeTiledLayerImpl childImpl(child->id());
         ScopedFakeTiledLayerImpl child2Impl(child2->id());
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
                 EXPECT_TRUE(rootImpl->hasResourceIdForTileAt(i, j));
             EXPECT_TRUE(childImpl->hasResourceIdForTileAt(i, 0));
             EXPECT_TRUE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // With a memory limit that includes only the root layer (3x2 tiles) and half the surface that
     // the child layers draw into, the child layers will not be allocated. If the surface isn't
     // accounted for, then one of the children would fit within the memory limit.
     root->invalidateContentRect(rootRect);
     child->invalidateContentRect(childRect);
     child2->invalidateContentRect(child2Rect);
-    layerTreeHost->updateLayers(
+    m_layerTreeHost->updateLayers(
         *m_queue.get(), (3 * 2 + 3 * 1) * (100 * 100) * 4);
     {
         updateTextures();
         EXPECT_EQ(6, root->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child2->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
 
         root->fakeLayerUpdater()->clearUpdateCount();
         child->fakeLayerUpdater()->clearUpdateCount();
         child2->fakeLayerUpdater()->clearUpdateCount();
 
         ScopedFakeTiledLayerImpl rootImpl(root->id());
         ScopedFakeTiledLayerImpl childImpl(child->id());
         ScopedFakeTiledLayerImpl child2Impl(child2->id());
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
                 EXPECT_TRUE(rootImpl->hasResourceIdForTileAt(i, j));
             EXPECT_FALSE(childImpl->hasResourceIdForTileAt(i, 0));
             EXPECT_FALSE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
     // With a memory limit that includes only half the root layer, no contents will be
     // allocated. If render surface memory wasn't accounted for, there is enough space
     // for one of the children layers, but they draw into a surface that can't be
     // allocated.
     root->invalidateContentRect(rootRect);
     child->invalidateContentRect(childRect);
     child2->invalidateContentRect(child2Rect);
-    layerTreeHost->updateLayers(
+    m_layerTreeHost->updateLayers(
         *m_queue.get(), (3 * 1) * (100 * 100) * 4);
     {
         updateTextures();
         EXPECT_EQ(0, root->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child2->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
 
         root->fakeLayerUpdater()->clearUpdateCount();
         child->fakeLayerUpdater()->clearUpdateCount();
         child2->fakeLayerUpdater()->clearUpdateCount();
 
         ScopedFakeTiledLayerImpl rootImpl(root->id());
         ScopedFakeTiledLayerImpl childImpl(child->id());
         ScopedFakeTiledLayerImpl child2Impl(child2->id());
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
                 EXPECT_FALSE(rootImpl->hasResourceIdForTileAt(i, j));
             EXPECT_FALSE(childImpl->hasResourceIdForTileAt(i, 0));
             EXPECT_FALSE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
     }
-    layerTreeHost->commitComplete();
+    m_layerTreeHost->commitComplete();
 
-    resourceManagerClearAllMemory(layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
-    layerTreeHost->setRootLayer(0);
+    resourceManagerClearAllMemory(m_layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
+    m_layerTreeHost->setRootLayer(0);
 }
 
 class TrackingLayerPainter : public LayerPainter {
 public:
     static scoped_ptr<TrackingLayerPainter> create() { return make_scoped_ptr(new TrackingLayerPainter()); }
 
     virtual void paint(SkCanvas*, const gfx::Rect& contentRect, gfx::RectF&) OVERRIDE
     {
         m_paintedRect = contentRect;
     }
@@ skipping 84 matching lines @@
     updateTextures();
 
     // Invalidate the entire layer in layer space. When painting, the rect given to webkit should match the layer's bounds.
     layer->setNeedsDisplayRect(layerRect);
     layer->update(*m_queue.get(), 0, m_stats);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 }  // anonymous namespace