Remove static thread pointers from CC

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 "config.h"
 
 #include "cc/layer_tree_host_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/geometry.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/io_surface_layer_impl.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/scrollbar_geometry_fixed_thumb.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/test/animation_test_common.h"
+#include "cc/test/fake_proxy.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/fake_web_scrollbar_theme_geometry.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/test_common.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/texture_layer_impl.h"
 #include "cc/tile_draw_quad.h"
@@ skipping 21 matching lines @@
 using ::testing::_;
 
 namespace {
 
 // This test is parametrized to run all tests with the
 // Settings::pageScalePinchZoomEnabled field enabled and disabled.
 class LayerTreeHostImplTest : public testing::TestWithParam<bool>,
                                 public LayerTreeHostImplClient {
 public:
     LayerTreeHostImplTest()
-        : m_onCanDrawStateChangedCalled(false)
+        : m_proxy(scoped_ptr<Thread>(NULL))
+        , m_alwaysImplThread(&m_proxy)
+        , m_alwaysMainThreadBlocked(&m_proxy)
+        , m_onCanDrawStateChangedCalled(false)
         , m_didRequestCommit(false)
         , m_didRequestRedraw(false)
         , m_reduceMemoryResult(true)
     {
         media::InitializeMediaLibraryForTesting();
     }
 
     virtual void SetUp()
     {
         Settings::setPageScalePinchZoomEnabled(GetParam());
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
 
-        m_hostImpl = LayerTreeHostImpl::create(settings, this);
+        m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
         m_hostImpl->initializeRenderer(createContext());
         m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     }
 
     virtual void TearDown()
     {
     }
 
     virtual void didLoseContextOnImplThread() OVERRIDE { }
     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
     virtual void onVSyncParametersChanged(base::TimeTicks, base::TimeDelta) OVERRIDE { }
     virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
     virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
     virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
     virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE { }
     virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE { return m_reduceMemoryResult; }
     virtual void sendManagedMemoryStats() OVERRIDE { }
 
     void setReduceMemoryResult(bool reduceMemoryResult) { m_reduceMemoryResult = reduceMemoryResult; }
 
     scoped_ptr<LayerTreeHostImpl> createLayerTreeHost(bool partialSwap, scoped_ptr<GraphicsContext> graphicsContext, scoped_ptr<LayerImpl> root)
     {
         Settings::setPartialSwapEnabled(partialSwap);
 
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
 
-        scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+        scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
         myHostImpl->initializeRenderer(graphicsContext.Pass());
         myHostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
         root->setAnchorPoint(gfx::PointF(0, 0));
         root->setPosition(gfx::PointF(0, 0));
         root->setBounds(gfx::Size(10, 10));
         root->setContentBounds(gfx::Size(10, 10));
         root->setVisibleContentRect(gfx::Rect(0, 0, 10, 10));
         root->setDrawsContent(true);
@@ skipping 62 matching lines @@
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
     }
 
 protected:
     scoped_ptr<GraphicsContext> createContext()
     {
         return FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3D)).PassAs<GraphicsContext>();
     }
 
+    FakeProxy m_proxy;
     DebugScopedSetImplThread m_alwaysImplThread;
     DebugScopedSetMainThreadBlocked m_alwaysMainThreadBlocked;
 
     scoped_ptr<LayerTreeHostImpl> m_hostImpl;
     bool m_onCanDrawStateChangedCalled;
     bool m_didRequestCommit;
     bool m_didRequestRedraw;
     bool m_reduceMemoryResult;
     ScopedSettings m_scopedSettings;
 };
@@ skipping 143 matching lines @@
 
 TEST_P(LayerTreeHostImplTest, scrollWithoutRootLayer)
 {
     // We should not crash when trying to scroll an empty layer tree.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollWithoutRenderer)
 {
     LayerTreeSettings settings;
-    m_hostImpl = LayerTreeHostImpl::create(settings, this);
+    m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Initialization will fail here.
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFails)).PassAs<GraphicsContext>());
     m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // We should not crash when trying to scroll after the renderer initialization fails.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
@@ skipping 1579 matching lines @@
 // where it should request to swap only the subBuffer that is damaged.
 TEST_P(LayerTreeHostImplTest, partialSwapReceivesDamageRect)
 {
     scoped_ptr<GraphicsContext> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapTrackerContext)).PassAs<GraphicsContext>();
     PartialSwapTrackerContext* partialSwapTracker = static_cast<PartialSwapTrackerContext*>(outputSurface->context3D());
 
     // This test creates its own LayerTreeHostImpl, so
     // that we can force partial swap enabled.
     LayerTreeSettings settings;
     Settings::setPartialSwapEnabled(true);
-    scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
     layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
     layerTreeHostImpl->setViewportSize(gfx::Size(500, 500), gfx::Size(500, 500));
 
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
     scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::create(2);
     child->setPosition(gfx::PointF(12, 13));
     child->setAnchorPoint(gfx::PointF(0, 0));
     child->setBounds(gfx::Size(14, 15));
     child->setContentBounds(gfx::Size(14, 15));
     child->setDrawsContent(true);
@@ skipping 259 matching lines @@
     }
 
     // Unlimited texture size.
     virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value)
     {
         if (pname == GL_MAX_TEXTURE_SIZE)
             *value = 8192;
     }
 };
 
-static scoped_ptr<LayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, LayerTreeHostImplClient* client)
+static scoped_ptr<LayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, LayerTreeHostImplClient* client, Proxy* proxy)
 {
     Settings::setPartialSwapEnabled(partialSwap);
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     LayerTreeSettings settings;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, client);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, client, proxy);
     myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
          |  +-----------+     |
          |  |         2 |     |
@@ skipping 42 matching lines @@
 
     child->addChild(grandChild.Pass());
     root->addChild(child.Pass());
 
     myHostImpl->setRootLayer(root.Pass());
     return myHostImpl.Pass();
 }
 
 TEST_P(LayerTreeHostImplTest, contributingLayerEmptyScissorPartialSwap)
 {
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(true, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(true, this, &m_proxy);
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Just for consistency, the most interesting stuff already happened
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
 
         // Verify all quads have been computed
         ASSERT_EQ(2U, frame.renderPasses.size());
         ASSERT_EQ(1U, frame.renderPasses[0]->quadList().size());
         ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
         EXPECT_EQ(DrawQuad::SolidColor, frame.renderPasses[0]->quadList()[0]->material());
         EXPECT_EQ(DrawQuad::RenderPass, frame.renderPasses[1]->quadList()[0]->material());
     }
 }
 
 TEST_P(LayerTreeHostImplTest, contributingLayerEmptyScissorNoPartialSwap)
 {
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(false, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = setupLayersForOpacity(false, this, &m_proxy);
 
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Just for consistency, the most interesting stuff already happened
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
 
         // Verify all quads have been computed
@@ skipping 45 matching lines @@
     m_hostImpl->initializeRenderer(createContext());
 
     EXPECT_TRUE(root->didLoseContextCalled());
     EXPECT_TRUE(layer1->didLoseContextCalled());
     EXPECT_TRUE(layer2->didLoseContextCalled());
 }
 
 TEST_P(LayerTreeHostImplTest, finishAllRenderingAfterContextLost)
 {
     LayerTreeSettings settings;
-    m_hostImpl = LayerTreeHostImpl::create(settings, this);
+    m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // The context initialization will fail, but we should still be able to call finishAllRendering() without any ill effects.
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFails)).PassAs<GraphicsContext>());
     m_hostImpl->finishAllRendering();
 }
 
 class FakeWebGraphicsContext3DMakeCurrentFailsEventually : public FakeWebGraphicsContext3D {
 public:
     explicit FakeWebGraphicsContext3DMakeCurrentFailsEventually(unsigned succeedCount) : m_succeedCount(succeedCount) { }
     virtual bool makeContextCurrent() {
         if (!m_succeedCount)
             return false;
         --m_succeedCount;
         return true;
     }
 
 private:
     unsigned m_succeedCount;
 };
 
 TEST_P(LayerTreeHostImplTest, contextLostDuringInitialize)
 {
     LayerTreeSettings settings;
-    m_hostImpl = LayerTreeHostImpl::create(settings, this);
+    m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Initialize into a known successful state.
     EXPECT_TRUE(m_hostImpl->initializeRenderer(createContext()));
     EXPECT_TRUE(m_hostImpl->context());
     EXPECT_TRUE(m_hostImpl->renderer());
     EXPECT_TRUE(m_hostImpl->resourceProvider());
 
     // We will make the context get lost after a numer of makeContextCurrent
     // calls. The exact number of calls to make it succeed is dependent on the
     // implementation and doesn't really matter (i.e. can be changed to make the
@@ skipping 590 matching lines @@
 public:
     using GLRenderer::releaseRenderPassTextures;
 };
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithClipping)
 {
     Settings::setPartialSwapEnabled(true);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     LayerImpl* rootPtr;
     LayerImpl* surfaceLayerPtr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     gfx::Size rootSize(100, 100);
 
     myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
@@ skipping 76 matching lines @@
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusion)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
     //    |
     //    +-- S2 +- L20 (owning)
     //           +- L21
     //
@@ skipping 95 matching lines @@
     }
 
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning, non drawing)
     //    |      +- L11 (corner, unoccluded)
     //    |      +- L12 (corner, unoccluded)
     //    |      +- L13 (corner, unoccluded)
     //    |      +- L14 (corner, entirely occluded)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
@@ skipping 95 matching lines @@
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (owning, drawing)
     //    |      +- L11 (corner, occluded by L12)
     //    |      +- L12 (opposite corner)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
     //
 
@@ skipping 67 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (rotated, drawing)
     //           +- L11 (occupies half surface)
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
 
     scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
@@ skipping 54 matching lines @@
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
 {
     Settings::setPartialSwapEnabled(true);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
     //    |
     //    +-- S2 +- L20 (owning)
     //           +- L21
     //
@@ skipping 92 matching lines @@
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, textureCachingWithScissor)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
          |  +-----------+     |
          |  |         2 |     |
          |  | +-------------------+
          |  | |   3               |
@@ skipping 86 matching lines @@
     // We should have a cached texture for surface 2 again even though it was damaged.
     EXPECT_TRUE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(childPassId));
 }
 
 TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
 {
     Settings::setPartialSwapEnabled(true);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     LayerImpl* rootPtr;
     LayerImpl* intermediateLayerPtr;
     LayerImpl* surfaceLayerPtr;
     LayerImpl* childPtr;
 
     setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, gfx::Size(100, 100));
 
     {
         LayerTreeHostImpl::FrameData frame;
@@ skipping 140 matching lines @@
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 {
     Settings::setPartialSwapEnabled(false);
 
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this);
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     LayerImpl* rootPtr;
     LayerImpl* intermediateLayerPtr;
     LayerImpl* surfaceLayerPtr;
     LayerImpl* childPtr;
 
     setupLayersForTextureCaching(myHostImpl.get(), rootPtr, intermediateLayerPtr, surfaceLayerPtr, childPtr, gfx::Size(100, 100));
 
     {
         LayerTreeHostImpl::FrameData frame;
@@ skipping 171 matching lines @@
     EXPECT_FALSE(m_didRequestCommit);
 }
 
 struct RenderPassRemovalTestData : public LayerTreeHostImpl::FrameData {
     ScopedPtrHashMap<RenderPass::Id, TestRenderPass> renderPassCache;
     scoped_ptr<SharedQuadState> sharedQuadState;
 };
 
 class TestRenderer : public GLRenderer, public RendererClient {
 public:
-    static scoped_ptr<TestRenderer> create(ResourceProvider* resourceProvider)
+    static scoped_ptr<TestRenderer> create(ResourceProvider* resourceProvider, Proxy* proxy)
     {
-        scoped_ptr<TestRenderer> renderer(new TestRenderer(resourceProvider));
+        scoped_ptr<TestRenderer> renderer(new TestRenderer(resourceProvider, proxy));
         if (!renderer->initialize())
             return scoped_ptr<TestRenderer>();
 
         return renderer.Pass();
     }
 
     void clearCachedTextures() { m_textures.clear(); }
     void setHaveCachedResourcesForRenderPassId(RenderPass::Id id) { m_textures.insert(id); }
 
     virtual bool haveCachedResourcesForRenderPassId(RenderPass::Id id) const OVERRIDE { return m_textures.count(id); }
 
     // RendererClient implementation.
     virtual const gfx::Size& deviceViewportSize() const OVERRIDE { return m_viewportSize; }
     virtual const LayerTreeSettings& settings() const OVERRIDE { return m_settings; }
     virtual void didLoseContext() OVERRIDE { }
     virtual void onSwapBuffersComplete() OVERRIDE { }
     virtual void setFullRootLayerDamage() OVERRIDE { }
     virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { }
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { }
+    virtual bool hasImplThread() const OVERRIDE { return false; }
 
 protected:
-    TestRenderer(ResourceProvider* resourceProvider) : GLRenderer(this, resourceProvider) { }
+    TestRenderer(ResourceProvider* resourceProvider, Proxy* proxy) : GLRenderer(this, resourceProvider) { }
 
 private:
     LayerTreeSettings m_settings;
     gfx::Size m_viewportSize;
     base::hash_set<RenderPass::Id> m_textures;
 };
 
 static void configureRenderPassTestData(const char* testScript, RenderPassRemovalTestData& testData, TestRenderer* renderer)
 {
     renderer->clearCachedTextures();
@@ skipping 263 matching lines @@
     dumpRenderPassTestData(testData, actualResult);
     EXPECT_STREQ(testCase.expectedResult, actualResult) << "In test case: " << testCase.name;
 }
 
 TEST_P(LayerTreeHostImplTest, testRemoveRenderPasses)
 {
     scoped_ptr<GraphicsContext> context(createContext());
     ASSERT_TRUE(context->context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(context.get()));
 
-    scoped_ptr<TestRenderer> renderer(TestRenderer::create(resourceProvider.get()));
+    scoped_ptr<TestRenderer> renderer(TestRenderer::create(resourceProvider.get(), &m_proxy));
 
     int testCaseIndex = 0;
     while (removeRenderPassesCases[testCaseIndex].name) {
         RenderPassRemovalTestData testData;
         configureRenderPassTestData(removeRenderPassesCases[testCaseIndex].initScript, testData, renderer.get());
         LayerTreeHostImpl::removeRenderPasses(LayerTreeHostImpl::CullRenderPassesWithCachedTextures(*renderer), testData);
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // anonymous namespace