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_canvas_layer_updater.h"
 #include "cc/layer_painter.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/rendering_stats.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 "cc/test/web_compositor_initializer.h"
 #include "cc/texture_update_controller.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebTransformationMatrix.h>
 
 using namespace cc;
 using namespace WebKitTests;
 using WebKit::WebTransformationMatrix;
@@ skipping 15 matching lines @@
 protected:
     virtual IntRect layerClipRectInTarget(const Layer* layer) const OVERRIDE { return m_layerClipRectInTarget; }
 
 private:
     IntRect m_layerClipRectInTarget;
 };
 
 class TiledLayerTest : public testing::Test {
 public:
     TiledLayerTest()
-        : m_compositorInitializer(0)
+        : m_proxy(0)
+        , m_compositorInitializer(0)
         , m_context(WebKit::createFakeGraphicsContext())
         , m_queue(make_scoped_ptr(new TextureUpdateQueue))
-        , m_textureManager(PrioritizedTextureManager::create(60*1024*1024, 1024, Renderer::ContentPool))
         , m_occlusion(0)
     {
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        LayerTreeSettings settings;
+        settings.maxPartialTextureUpdates = 4;
+        m_layerTreeHost = LayerTreeHost::create(&m_fakeLayerImplTreeHostClient, settings, NULL);
+        m_proxy = m_layerTreeHost->proxy();
+        m_textureManager = PrioritizedTextureManager::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()
     {
         textureManagerClearAllMemory(m_textureManager.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 textureManagerClearAllMemory(PrioritizedTextureManager* textureManager, ResourceProvider* resourceProvider)
     {
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         textureManager->clearAllMemory(resourceProvider);
         textureManager->reduceMemory(resourceProvider);
     }
     void updateTextures()
     {
-        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         DCHECK(m_queue);
         scoped_ptr<TextureUpdateController> updateController =
             TextureUpdateController::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 TextureUpdateQueue);
     }
     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_textureManager->clearPriorities();
@@ skipping 19 matching lines @@
         updateTextures();
         if (layer1)
             layerPushPropertiesTo(layer1, layerImpl1);
         if (layer2)
             layerPushPropertiesTo(layer2, layerImpl2);
 
         return needsUpdate;
     }
 
 public:
+    Proxy* m_proxy;
     WebKitTests::WebCompositorInitializer m_compositorInitializer;
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     scoped_ptr<TextureUpdateQueue> m_queue;
     RenderingStats m_stats;
     PriorityCalculator m_priorityCalculator;
+    FakeLayerImplTreeHostClient m_fakeLayerImplTreeHostClient;
+    scoped_ptr<LayerTreeHost> m_layerTreeHost;
     scoped_ptr<PrioritizedTextureManager> m_textureManager;
     TestOcclusionTracker* m_occlusion;
 };
 
 TEST_F(TiledLayerTest, pushDirtyTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_textureManager.get()));
     ScopedFakeTiledLayerImpl layerImpl(1);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
@@ skipping 330 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(), 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;
         IntSize viewportSize = IntSize(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.
     IntSize contentBounds(300, 300);
     IntRect contentRect(IntPoint::zero(), 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(FloatPoint(0, 0));
     childLayer->setBounds(contentBounds);
     childLayer->setVisibleContentRect(contentRect);
     childLayer->setPosition(FloatPoint(0, 0));
     rootLayer->invalidateContentRect(contentRect);
     childLayer->invalidateContentRect(contentRect);
 
-    layerTreeHost->setRootLayer(rootLayer);
-    layerTreeHost->setViewportSize(IntSize(300, 300), IntSize(300, 300));
+    m_layerTreeHost->setRootLayer(rootLayer);
+    m_layerTreeHost->setViewportSize(IntSize(300, 300), IntSize(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());
 
-    textureManagerClearAllMemory(layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
-    layerTreeHost->setRootLayer(0);
+    textureManagerClearAllMemory(m_layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
+    m_layerTreeHost->setRootLayer(0);
 }
 
 TEST_F(TiledLayerTest, resizeToSmaller)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_textureManager.get()));
 
     layer->setBounds(IntSize(700, 700));
     layer->setVisibleContentRect(IntRect(0, 0, 700, 700));
     layer->invalidateContentRect(IntRect(0, 0, 700, 700));
 
@@ skipping 15 matching lines @@
     layer->invalidateContentRect(IntRect(0, 0, size, size));
 
     // Ensure no crash for bounds where size * size would overflow an int.
     layer->setTexturePriorities(m_priorityCalculator);
     m_textureManager->prioritizeTextures();
     layer->update(*m_queue.get(), 0, m_stats);
 }
 
 TEST_F(TiledLayerTest, partialUpdates)
 {
-    LayerTreeSettings settings;
-    settings.maxPartialTextureUpdates = 4;

[danakj, 2012/10/25 05:06:06]

Don't really like this being set for the whole test suite instead of inside this
test.. it makes it super less clear what this test is testing for.

Can you make this test use a subclass of TiledLayerTest that sets this partial
texture update limit?

-
-    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.
     IntSize contentBounds(300, 200);
     IntRect contentRect(IntPoint::zero(), 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(FloatPoint(0, 0));
     layer->setVisibleContentRect(contentRect);
     layer->invalidateContentRect(contentRect);
 
-    layerTreeHost->setRootLayer(layer);
-    layerTreeHost->setViewportSize(IntSize(300, 200), IntSize(300, 200));
+    m_layerTreeHost->setRootLayer(layer);
+    m_layerTreeHost->setViewportSize(IntSize(300, 200), IntSize(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(IntRect(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(IntRect(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(IntRect(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(IntRect(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(IntRect(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();
 
-    textureManagerClearAllMemory(layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
-    layerTreeHost->setRootLayer(0);
+    textureManagerClearAllMemory(m_layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
+    m_layerTreeHost->setRootLayer(0);
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithoutOcclusion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_textureManager.get()));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(IntSize(100, 200));
     layer->setDrawableContentRect(IntRect(0, 0, 100, 200));
     layer->setVisibleContentRect(IntRect(0, 0, 100, 200));
@@ skipping 397 matching lines @@
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, dontAllocateContentsWhenTargetSurfaceCantBeAllocated)
 {
     // Tile size is 100x100.
     IntRect rootRect(0, 0, 300, 200);
     IntRect childRect(0, 0, 300, 100);
     IntRect 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(FloatPoint());
     root->setDrawableContentRect(rootRect);
     root->setVisibleContentRect(rootRect);
     root->addChild(surface);
 
     surface->setForceRenderSurface(true);
     surface->setAnchorPoint(FloatPoint());
     surface->setOpacity(0.5);
     surface->addChild(child);
     surface->addChild(child2);
 
     child->setBounds(childRect.size());
     child->setAnchorPoint(FloatPoint());
     child->setPosition(childRect.location());
     child->setVisibleContentRect(childRect);
     child->setDrawableContentRect(rootRect);
 
     child2->setBounds(child2Rect.size());
     child2->setAnchorPoint(FloatPoint());
     child2->setPosition(child2Rect.location());
     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();
 
-    textureManagerClearAllMemory(layerTreeHost->contentsTextureManager(), m_resourceProvider.get());
-    layerTreeHost->setRootLayer(0);
+    textureManagerClearAllMemory(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 IntRect& contentRect, FloatRect&) 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());
 }
 
 } // namespace