Revert 171403

cc/layer_tree_host_impl_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 64 matching lines @@
         media::InitializeMediaLibraryForTesting();
     }
 
     virtual void SetUp()
     {
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
         settings.pageScalePinchZoomEnabled = GetParam();
 
         m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
-        m_hostImpl->initializeRenderer(createOutputSurface());
+        m_hostImpl->initializeRenderer(createContext());
         m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     }
 
     virtual void TearDown()
     {
     }
 
-    virtual void didLoseOutputSurfaceOnImplThread() OVERRIDE { }
+    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 setNeedsManageTilesOnImplThread() OVERRIDE { }
     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<OutputSurface> outputSurface, scoped_ptr<LayerImpl> root)
+    scoped_ptr<LayerTreeHostImpl> createLayerTreeHost(bool partialSwap, scoped_ptr<GraphicsContext> graphicsContext, scoped_ptr<LayerImpl> root)
     {
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
         settings.partialSwapEnabled = partialSwap;
 
         scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
-        myHostImpl->initializeRenderer(outputSurface.Pass());
+        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->setDrawsContent(true);
         root->drawProperties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
         myHostImpl->setRootLayer(root.Pass());
         return myHostImpl.Pass();
@@ skipping 60 matching lines @@
         layer->setScrollable(true);
         layer->setDrawsContent(true);
         layer->setBounds(size);
         layer->setContentBounds(size);
         layer->setMaxScrollOffset(gfx::Vector2d(size.width() * 2, size.height() * 2));
         return layer.Pass();
     }
 
     void initializeRendererAndDrawFrame()
     {
-        m_hostImpl->initializeRenderer(createOutputSurface());
+        m_hostImpl->initializeRenderer(createContext());
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
     }
 
     void pinchZoomPanViewportForcesCommitRedraw(const float deviceScaleFactor);
     void pinchZoomPanViewportTest(const float deviceScaleFactor);
     void pinchZoomPanViewportAndScrollTest(const float deviceScaleFactor);
     void pinchZoomPanViewportAndScrollBoundaryTest(const float deviceScaleFactor);
 
 protected:
-    scoped_ptr<OutputSurface> createOutputSurface()
+    scoped_ptr<GraphicsContext> createContext()
     {
-        return FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3D)).PassAs<OutputSurface>();
+        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;
@@ skipping 148 matching lines @@
     // 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_proxy);
 
     // Initialization will fail here.
-    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFails)).PassAs<OutputSurface>());
+    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);
 }
 
 TEST_P(LayerTreeHostImplTest, replaceTreeWhileScrolling)
 {
@@ skipping 1488 matching lines @@
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
 }
 
 TEST_P(LayerTreeHostImplTest, viewportCovered)
 {
-    m_hostImpl->initializeRenderer(createOutputSurface());
+    m_hostImpl->initializeRenderer(createContext());
     m_hostImpl->setBackgroundColor(SK_ColorGRAY);
 
     gfx::Size viewportSize(1000, 1000);
     m_hostImpl->setViewportSize(viewportSize, viewportSize);
 
     m_hostImpl->setRootLayer(LayerImpl::create(1));
     m_hostImpl->rootLayer()->addChild(BlendStateCheckLayer::create(2, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* child = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer()->children()[0]);
     child->setExpectation(false, false);
     child->setContentsOpaque(true);
@@ skipping 91 matching lines @@
     static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new FakeDrawableLayerImpl(id)); }
 protected:
     explicit FakeDrawableLayerImpl(int id) : LayerImpl(id) { }
 };
 
 // Only reshape when we know we are going to draw. Otherwise, the reshape
 // can leave the window at the wrong size if we never draw and the proper
 // viewport size is never set.
 TEST_P(LayerTreeHostImplTest, reshapeNotCalledUntilDraw)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new ReshapeTrackerContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new ReshapeTrackerContext)).PassAs<GraphicsContext>();
     ReshapeTrackerContext* reshapeTracker = static_cast<ReshapeTrackerContext*>(outputSurface->context3D());
     m_hostImpl->initializeRenderer(outputSurface.Pass());
 
     scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::create(1);
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setBounds(gfx::Size(10, 10));
     root->setDrawsContent(true);
     m_hostImpl->setRootLayer(root.Pass());
     EXPECT_FALSE(reshapeTracker->reshapeCalled());
 
@@ skipping 22 matching lines @@
     gfx::Rect partialSwapRect() const { return m_partialSwapRect; }
 
 private:
     gfx::Rect m_partialSwapRect;
 };
 
 // Make sure damage tracking propagates all the way to the graphics context,
 // where it should request to swap only the subBuffer that is damaged.
 TEST_P(LayerTreeHostImplTest, partialSwapReceivesDamageRect)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapTrackerContext)).PassAs<OutputSurface>();
+    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.partialSwapEnabled = true;
     scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
     layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
     layerTreeHostImpl->setViewportSize(gfx::Size(500, 500), gfx::Size(500, 500));
 
@@ skipping 194 matching lines @@
         EXPECT_CALL(*m_context, enable(GL_SCISSOR_TEST))
             .Times(0);
 
         EXPECT_CALL(*m_context, scissor(_, _, _, _))
             .Times(0);
     }
 };
 
 TEST_P(LayerTreeHostImplTest, noPartialSwap)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebGraphicsContext3D>(new MockContext)).PassAs<OutputSurface>();
-    MockContext* mockContext = static_cast<MockContext*>(outputSurface->context3D());
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebGraphicsContext3D>(new MockContext)).PassAs<GraphicsContext>();
+    MockContext* mockContext = static_cast<MockContext*>(context->context3D());
     MockContextHarness harness(mockContext);
 
     // Run test case
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, outputSurface.Pass(), FakeLayerWithQuads::create(1));
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.Pass(), FakeLayerWithQuads::create(1));
 
     // without partial swap, and no clipping, no scissor is set.
     harness.mustDrawSolidQuad();
     harness.mustSetNoScissor();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 
     // without partial swap, but a layer does clip its subtree, one scissor is set.
     myHostImpl->rootLayer()->setMasksToBounds(true);
     harness.mustDrawSolidQuad();
     harness.mustSetScissor(0, 0, 10, 10);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 TEST_P(LayerTreeHostImplTest, partialSwap)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockContext)).PassAs<OutputSurface>();
-    MockContext* mockContext = static_cast<MockContext*>(outputSurface->context3D());
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockContext)).PassAs<GraphicsContext>();
+    MockContext* mockContext = static_cast<MockContext*>(context->context3D());
     MockContextHarness harness(mockContext);
 
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(true, outputSurface.Pass(), FakeLayerWithQuads::create(1));
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(true, context.Pass(), FakeLayerWithQuads::create(1));
 
     // The first frame is not a partially-swapped one.
     harness.mustSetScissor(0, 0, 10, 10);
     harness.mustDrawSolidQuad();
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
@@ skipping 31 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, Proxy* proxy)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     LayerTreeSettings settings;
     settings.partialSwapEnabled = partialSwap;
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, client, proxy);
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
          |  +-----------+     |
          |  |         2 |     |
          |  | +-------------------+
@@ skipping 80 matching lines @@
         ASSERT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         ASSERT_EQ(1U, frame.renderPasses[1]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-// Make sure that output surface lost notifications are propagated through the tree.
-class OutputSurfaceLostNotificationCheckLayer : public LayerImpl {
+// Make sure that context lost notifications are propagated through the tree.
+class ContextLostNotificationCheckLayer : public LayerImpl {
 public:
-    static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new OutputSurfaceLostNotificationCheckLayer(id)); }
+    static scoped_ptr<LayerImpl> create(int id) { return scoped_ptr<LayerImpl>(new ContextLostNotificationCheckLayer(id)); }
 
-    virtual void didLoseOutputSurface() OVERRIDE
+    virtual void didLoseContext() OVERRIDE
     {
-        m_didLoseOutputSurfaceCalled = true;
+        m_didLoseContextCalled = true;
     }
 
-    bool didLoseOutputSurfaceCalled() const { return m_didLoseOutputSurfaceCalled; }
+    bool didLoseContextCalled() const { return m_didLoseContextCalled; }
 
 private:
-    explicit OutputSurfaceLostNotificationCheckLayer(int id)
+    explicit ContextLostNotificationCheckLayer(int id)
         : LayerImpl(id)
-        , m_didLoseOutputSurfaceCalled(false)
+        , m_didLoseContextCalled(false)
     {
     }
 
-    bool m_didLoseOutputSurfaceCalled;
+    bool m_didLoseContextCalled;
 };
 
-TEST_P(LayerTreeHostImplTest, outputSurfaceLostAndRestoredNotificationSentToAllLayers)
+TEST_P(LayerTreeHostImplTest, contextLostAndRestoredNotificationSentToAllLayers)
 {
-    m_hostImpl->setRootLayer(OutputSurfaceLostNotificationCheckLayer::create(1));
-    OutputSurfaceLostNotificationCheckLayer* root = static_cast<OutputSurfaceLostNotificationCheckLayer*>(m_hostImpl->rootLayer());
+    m_hostImpl->setRootLayer(ContextLostNotificationCheckLayer::create(1));
+    ContextLostNotificationCheckLayer* root = static_cast<ContextLostNotificationCheckLayer*>(m_hostImpl->rootLayer());
 
-    root->addChild(OutputSurfaceLostNotificationCheckLayer::create(1));
-    OutputSurfaceLostNotificationCheckLayer* layer1 = static_cast<OutputSurfaceLostNotificationCheckLayer*>(root->children()[0]);
+    root->addChild(ContextLostNotificationCheckLayer::create(1));
+    ContextLostNotificationCheckLayer* layer1 = static_cast<ContextLostNotificationCheckLayer*>(root->children()[0]);
 
-    layer1->addChild(OutputSurfaceLostNotificationCheckLayer::create(2));
-    OutputSurfaceLostNotificationCheckLayer* layer2 = static_cast<OutputSurfaceLostNotificationCheckLayer*>(layer1->children()[0]);
+    layer1->addChild(ContextLostNotificationCheckLayer::create(2));
+    ContextLostNotificationCheckLayer* layer2 = static_cast<ContextLostNotificationCheckLayer*>(layer1->children()[0]);
 
-    EXPECT_FALSE(root->didLoseOutputSurfaceCalled());
-    EXPECT_FALSE(layer1->didLoseOutputSurfaceCalled());
-    EXPECT_FALSE(layer2->didLoseOutputSurfaceCalled());
+    EXPECT_FALSE(root->didLoseContextCalled());
+    EXPECT_FALSE(layer1->didLoseContextCalled());
+    EXPECT_FALSE(layer2->didLoseContextCalled());
 
-    m_hostImpl->initializeRenderer(createOutputSurface());
+    m_hostImpl->initializeRenderer(createContext());
 
-    EXPECT_TRUE(root->didLoseOutputSurfaceCalled());
-    EXPECT_TRUE(layer1->didLoseOutputSurfaceCalled());
-    EXPECT_TRUE(layer2->didLoseOutputSurfaceCalled());
+    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_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<OutputSurface>());
+    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, context3DLostDuringInitialize)
+TEST_P(LayerTreeHostImplTest, contextLostDuringInitialize)
 {
     LayerTreeSettings settings;
     m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     // Initialize into a known successful state.
-    EXPECT_TRUE(m_hostImpl->initializeRenderer(createOutputSurface()));
-    EXPECT_TRUE(m_hostImpl->outputSurface());
+    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
     // tests pass after some refactoring).
     const unsigned kMakeCurrentSuccessesNeededForSuccessfulInitialization = 3;
 
     for (unsigned i = 0; i < kMakeCurrentSuccessesNeededForSuccessfulInitialization; ++i) {
         // The context will get lost during initialization, we shouldn't crash. We
         // should also be in a consistent state.
-        EXPECT_FALSE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(i))).PassAs<OutputSurface>()));
-        EXPECT_EQ(0, m_hostImpl->outputSurface());
+        EXPECT_FALSE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(i))).PassAs<GraphicsContext>()));
+        EXPECT_EQ(0, m_hostImpl->context());
         EXPECT_EQ(0, m_hostImpl->renderer());
         EXPECT_EQ(0, m_hostImpl->resourceProvider());
-        EXPECT_TRUE(m_hostImpl->initializeRenderer(createOutputSurface()));
+        EXPECT_TRUE(m_hostImpl->initializeRenderer(createContext()));
     }
 
-    EXPECT_TRUE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(kMakeCurrentSuccessesNeededForSuccessfulInitialization))).PassAs<OutputSurface>()));
-    EXPECT_TRUE(m_hostImpl->outputSurface());
+    EXPECT_TRUE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(kMakeCurrentSuccessesNeededForSuccessfulInitialization))).PassAs<GraphicsContext>()));
+    EXPECT_TRUE(m_hostImpl->context());
     EXPECT_TRUE(m_hostImpl->renderer());
     EXPECT_TRUE(m_hostImpl->resourceProvider());
 }
 
 // Fake WebGraphicsContext3D that will cause a failure if trying to use a
 // resource that wasn't created by it (resources created by
 // FakeWebGraphicsContext3D have an id of 1).
 class StrictWebGraphicsContext3D : public FakeWebGraphicsContext3D {
 public:
     StrictWebGraphicsContext3D()
@@ skipping 216 matching lines @@
     sharedState->SetAll(gfx::Transform(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), false, 1);
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
 
     pass->AppendSharedQuadState(sharedState.Pass());
     pass->AppendQuad(quad.PassAs<DrawQuad>());
 
     return pass.PassAs<RenderPass>();
 }
 
-TEST_P(LayerTreeHostImplTest, dontUseOldResourcesAfterLostOutputSurface)
+TEST_P(LayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 {
     int layerId = 1;
 
     scoped_ptr<LayerImpl> rootLayer(LayerImpl::create(layerId++));
     rootLayer->setBounds(gfx::Size(10, 10));
     rootLayer->setAnchorPoint(gfx::PointF(0, 0));
 
     scoped_ptr<TiledLayerImpl> tileLayer = TiledLayerImpl::create(layerId++);
     tileLayer->setBounds(gfx::Size(10, 10));
     tileLayer->setAnchorPoint(gfx::PointF(0, 0));
@@ skipping 95 matching lines @@
     delegatedRendererLayer->setContentBounds(gfx::Size(10, 10));
     delegatedRendererLayer->setDrawsContent(true);
     delegatedRendererLayer->setLayerTreeHostImpl(m_hostImpl.get());
     ScopedPtrVector<RenderPass> passList;
     passList.append(createRenderPassWithResource(m_hostImpl->resourceProvider()));
     delegatedRendererLayer->setRenderPasses(passList);
     EXPECT_TRUE(passList.isEmpty());
     rootLayer->addChild(delegatedRendererLayer.PassAs<LayerImpl>());
 
     // Use a context that supports IOSurfaces
-    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DWithIOSurface)).PassAs<OutputSurface>());
+    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DWithIOSurface)).PassAs<GraphicsContext>());
 
     FakeVideoFrame hwVideoFrame(
         VideoFrame::WrapNativeTexture(
             m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture(),
             GL_TEXTURE_2D,
             gfx::Size(4, 4), gfx::Rect(0, 0, 4, 4), gfx::Size(4, 4), base::TimeDelta(),
             VideoFrame::ReadPixelsCB(), base::Closure()));
     hwProvider.setFrame(&hwVideoFrame);
 
     FakeVideoFrame videoFrameScaled(
         VideoFrame::WrapNativeTexture(
             m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture(),
             GL_TEXTURE_2D,
             gfx::Size(4, 4), gfx::Rect(0, 0, 3, 2), gfx::Size(4, 4), base::TimeDelta(),
             VideoFrame::ReadPixelsCB(), base::Closure()));
     providerScaled.setFrame(&videoFrameScaled);
 
     m_hostImpl->setRootLayer(rootLayer.Pass());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
     unsigned numResources = m_hostImpl->resourceProvider()->numResources();
 
-    // Lose the WebGraphicsContext3D, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
+    // Lose the context, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
     // that will warn if any resource from the previous context gets used.
-    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new StrictWebGraphicsContext3DWithIOSurface)).PassAs<OutputSurface>());
+    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new StrictWebGraphicsContext3DWithIOSurface)).PassAs<GraphicsContext>());
 
     // Create dummy resources so that looking up an old resource will get an
     // invalid texture id mapping.
     for (unsigned i = 0; i < numResources; ++i)
         m_hostImpl->resourceProvider()->createResourceFromExternalTexture(StrictWebGraphicsContext3D::kExternalTextureId);
 
     // The WebVideoFrameProvider is expected to recreate its textures after a
-    // lost output surface (or not serve a frame).
+    // lost context (or not serve a frame).
     hwProvider.setFrame(0);
     providerScaled.setFrame(0);
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
     FakeVideoFrame hwVideoFrame2(
         VideoFrame::WrapNativeTexture(
@@ skipping 89 matching lines @@
 
     scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(5);
     ioSurfaceLayer->setBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setAnchorPoint(gfx::PointF(0, 0));
     ioSurfaceLayer->setContentBounds(gfx::Size(10, 10));
     ioSurfaceLayer->setDrawsContent(true);
     ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
     ioSurfaceLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(ioSurfaceLayer.PassAs<LayerImpl>());
 
-    // Lose the WebGraphicsContext3D, replacing it with a TrackingWebGraphicsContext3D (which the LayerTreeHostImpl takes ownership of).
-    scoped_ptr<OutputSurface> outputSurface(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new TrackingWebGraphicsContext3D)));
-    TrackingWebGraphicsContext3D* trackingWebGraphicsContext3D = static_cast<TrackingWebGraphicsContext3D*>(outputSurface->context3D());
+    // Lose the context, replacing it with a TrackingWebGraphicsContext3D (which the LayerTreeHostImpl takes ownership of).
+    scoped_ptr<GraphicsContext> outputSurface(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new TrackingWebGraphicsContext3D)));
+    TrackingWebGraphicsContext3D* trackingWebGraphicsContext = static_cast<TrackingWebGraphicsContext3D*>(outputSurface->context3D());
     m_hostImpl->initializeRenderer(outputSurface.Pass());
 
     m_hostImpl->setRootLayer(rootLayer.Pass());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
-    EXPECT_GT(trackingWebGraphicsContext3D->numTextures(), 0u);
+    EXPECT_GT(trackingWebGraphicsContext->numTextures(), 0u);
 
     // Kill the layer tree.
     m_hostImpl->setRootLayer(LayerImpl::create(100));
     // There should be no textures left in use after.
-    EXPECT_EQ(0u, trackingWebGraphicsContext3D->numTextures());
+    EXPECT_EQ(0u, trackingWebGraphicsContext->numTextures());
 }
 
 class MockDrawQuadsToFillScreenContext : public FakeWebGraphicsContext3D {
 public:
     MOCK_METHOD1(useProgram, void(WebGLId program));
     MOCK_METHOD4(drawElements, void(WGC3Denum mode, WGC3Dsizei count, WGC3Denum type, WGC3Dintptr offset));
 };
 
 TEST_P(LayerTreeHostImplTest, hasTransparentBackground)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockDrawQuadsToFillScreenContext)).PassAs<OutputSurface>();
-    MockDrawQuadsToFillScreenContext* mockContext = static_cast<MockDrawQuadsToFillScreenContext*>(outputSurface->context3D());
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new MockDrawQuadsToFillScreenContext)).PassAs<GraphicsContext>();
+    MockDrawQuadsToFillScreenContext* mockContext = static_cast<MockDrawQuadsToFillScreenContext*>(context->context3D());
 
     // Run test case
-    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, outputSurface.Pass(), LayerImpl::create(1));
+    scoped_ptr<LayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.Pass(), LayerImpl::create(1));
     myHostImpl->setBackgroundColor(SK_ColorWHITE);
 
     // Verify one quad is drawn when transparent background set is not set.
     myHostImpl->setHasTransparentBackground(false);
     EXPECT_CALL(*mockContext, useProgram(_))
         .Times(1);
     EXPECT_CALL(*mockContext, drawElements(_, _, _, _))
         .Times(1);
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
@@ skipping 19 matching lines @@
     layerPtr->setContentBounds(layerRect.size());
     layerPtr->setDrawsContent(true); // only children draw content
     layerPtr->setContentsOpaque(true);
     parent->addChild(layer.Pass());
     if (result)
         *result = layerPtr;
 }
 
 static void setupLayersForTextureCaching(LayerTreeHostImpl* layerTreeHostImpl, LayerImpl*& rootPtr, LayerImpl*& intermediateLayerPtr, LayerImpl*& surfaceLayerPtr, LayerImpl*& childPtr, const gfx::Size& rootSize)
 {
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
-    layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
+    layerTreeHostImpl->initializeRenderer(context.Pass());
     layerTreeHostImpl->setViewportSize(rootSize, rootSize);
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
@@ skipping 21 matching lines @@
 TEST_P(LayerTreeHostImplTest, textureCachingWithClipping)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
     settings.partialSwapEnabled = true;
     scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
 
     LayerImpl* rootPtr;
     LayerImpl* surfaceLayerPtr;
 
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     gfx::Size rootSize(100, 100);
 
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
@@ skipping 86 matching lines @@
     //
     // Occlusion:
     // L12 occludes L11 (internal)
     // L20 occludes L10 (external)
     // L21 occludes L20 (internal)
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     gfx::Size rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
@@ skipping 86 matching lines @@
     //    |      +- L13 (corner, unoccluded)
     //    |      +- L14 (corner, entirely occluded)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
     //
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     gfx::Size rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
@@ skipping 87 matching lines @@
     //    |      +- L11 (corner, occluded by L12)
     //    |      +- L12 (opposite corner)
     //    |
     //    +-- S2 +- L20 (owning, drawing)
     //
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     gfx::Size rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
@@ skipping 56 matching lines @@
     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<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     gfx::Size rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
@@ skipping 59 matching lines @@
     //
     // Occlusion:
     // L12 occludes L11 (internal)
     // L20 occludes L10 (external)
     // L21 occludes L20 (internal)
 
     LayerImpl* rootPtr;
     LayerImpl* layerS1Ptr;
     LayerImpl* layerS2Ptr;
 
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
 
     gfx::Size rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
 
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     rootPtr = root.get();
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(0, 0));
     root->setBounds(rootSize);
     root->setContentBounds(rootSize);
     root->setDrawsContent(true);
@@ skipping 94 matching lines @@
          Layers 1, 2 have render surfaces
      */
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     scoped_ptr<TiledLayerImpl> child = TiledLayerImpl::create(2);
     scoped_ptr<LayerImpl> grandChild = LayerImpl::create(3);
 
     gfx::Rect rootRect(0, 0, 100, 100);
     gfx::Rect childRect(10, 10, 50, 50);
     gfx::Rect grandChildRect(5, 5, 150, 150);
 
-    scoped_ptr<OutputSurface> outputSurface = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
-    myHostImpl->initializeRenderer(outputSurface.Pass());
+    scoped_ptr<GraphicsContext> context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<GraphicsContext>();
+    myHostImpl->initializeRenderer(context.Pass());
 
     root->setAnchorPoint(gfx::PointF(0, 0));
     root->setPosition(gfx::PointF(rootRect.x(), rootRect.y()));
     root->setBounds(gfx::Size(rootRect.width(), rootRect.height()));
     root->setContentBounds(root->bounds());
     root->setDrawsContent(true);
     root->setMasksToBounds(true);
 
     child->setAnchorPoint(gfx::PointF(0, 0));
     child->setPosition(gfx::PointF(childRect.x(), childRect.y()));
@@ skipping 424 matching lines @@
     }
 
     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 didLoseOutputSurface() OVERRIDE { }
+    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, Proxy* proxy) : GLRenderer(this, resourceProvider) { }
 
 private:
@@ skipping 274 matching lines @@
 
 static void verifyRenderPassTestData(TestCase& testCase, RenderPassRemovalTestData& testData)
 {
     char actualResult[1024];
     dumpRenderPassTestData(testData, actualResult);
     EXPECT_STREQ(testCase.expectedResult, actualResult) << "In test case: " << testCase.name;
 }
 
 TEST_P(LayerTreeHostImplTest, testRemoveRenderPasses)
 {
-    scoped_ptr<OutputSurface> outputSurface(createOutputSurface());
-    ASSERT_TRUE(outputSurface->context3D());
-    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
+    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(), &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++;
@@ skipping 356 matching lines @@
 {
     pinchZoomPanViewportAndScrollBoundaryTest(2);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc