cc: Make OutputSurface::BindToClient pure virtual and not return bool

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 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/output/gl_renderer.h"
 
 #include <stdint.h>
 
 #include <set>
 #include <vector>
@@ skipping 322 matching lines @@
   // Changing visibility to public.
   using GLRenderer::DoDrawQuad;
   using GLRenderer::BeginDrawingFrame;
   using GLRenderer::FinishDrawingQuadList;
   using GLRenderer::stencil_enabled;
 };
 
 class GLRendererWithDefaultHarnessTest : public GLRendererTest {
  protected:
   GLRendererWithDefaultHarnessTest() {
-    output_surface_ =
-        FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create());
-    CHECK(output_surface_->BindToClient(&output_surface_client_));
+    output_surface_ = FakeOutputSurface::Create3d();
+    output_surface_->BindToClient(&output_surface_client_);
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_->context_provider(), shared_bitmap_manager_.get());
     renderer_ = base::MakeUnique<FakeRendererGL>(
         &settings_, output_surface_.get(), resource_provider_.get());
     renderer_->Initialize();
     renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(std::vector<ui::LatencyInfo>()); }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
 // Closing the namespace here so that GLRendererShaderTest can take advantage
 // of the friend relationship with GLRenderer and all of the mock classes
 // declared above it.
 }  // namespace
 
 class GLRendererShaderTest : public GLRendererTest {
  protected:
   GLRendererShaderTest() {
     output_surface_ = FakeOutputSurface::Create3d();
-    CHECK(output_surface_->BindToClient(&output_surface_client_));
+    output_surface_->BindToClient(&output_surface_client_);
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_->context_provider(), shared_bitmap_manager_.get());
     renderer_.reset(new FakeRendererGL(&settings_, output_surface_.get(),
                                        resource_provider_.get()));
     renderer_->Initialize();
     renderer_->SetVisible(true);
   }
 
@@ skipping 206 matching lines @@
   }
   void getVertexAttribiv(GLuint index, GLenum pname, GLint* value) override {
     ADD_FAILURE();
   }
   GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname) override {
     ADD_FAILURE();
     return 0;
   }
 };
 TEST_F(GLRendererTest, InitializationDoesNotMakeSynchronousCalls) {
+  auto context = base::MakeUnique<ForbidSynchronousCallContext>();
+  auto provider = TestContextProvider::Create(std::move(context));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(std::unique_ptr<TestWebGraphicsContext3D>(
-          new ForbidSynchronousCallContext)));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
   LoseContextOnFirstGetContext() {}
 
   void getProgramiv(GLuint program, GLenum pname, GLint* value) override {
     context_lost_ = true;
     *value = 0;
   }
 
   void getShaderiv(GLuint shader, GLenum pname, GLint* value) override {
     context_lost_ = true;
     *value = 0;
   }
 };
 
 TEST_F(GLRendererTest, InitializationWithQuicklyLostContextDoesNotAssert) {
+  auto context = base::MakeUnique<LoseContextOnFirstGetContext>();
+  auto provider = TestContextProvider::Create(std::move(context));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(std::unique_ptr<TestWebGraphicsContext3D>(
-          new LoseContextOnFirstGetContext)));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
 }
 
 class ClearCountingContext : public TestWebGraphicsContext3D {
  public:
   ClearCountingContext() { test_capabilities_.discard_framebuffer = true; }
 
   MOCK_METHOD3(discardFramebufferEXT,
                void(GLenum target,
                     GLsizei numAttachments,
                     const GLenum* attachments));
   MOCK_METHOD1(clear, void(GLbitfield mask));
 };
 
 TEST_F(GLRendererTest, OpaqueBackground) {
   std::unique_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
 
+  auto provider = TestContextProvider::Create(std::move(context_owned));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(std::move(context_owned)));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
@@ skipping 17 matching lines @@
   EXPECT_CALL(*context, clear(_)).Times(1);
 #endif
   DrawFrame(&renderer, viewport_size);
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_F(GLRendererTest, TransparentBackground) {
   std::unique_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
 
+  auto provider = TestContextProvider::Create(std::move(context_owned));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(std::move(context_owned)));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
@@ skipping 10 matching lines @@
   EXPECT_CALL(*context, clear(_)).Times(1);
   DrawFrame(&renderer, viewport_size);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_F(GLRendererTest, OffscreenOutputSurface) {
   std::unique_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
 
+  auto provider = TestContextProvider::Create(std::move(context_owned));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::CreateOffscreen(std::move(context_owned)));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::CreateOffscreen(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
@@ skipping 32 matching lines @@
 
  private:
   GLenum active_texture_;
 };
 
 TEST_F(GLRendererTest, ActiveTextureState) {
   std::unique_ptr<TextureStateTrackingContext> context_owned(
       new TextureStateTrackingContext);
   TextureStateTrackingContext* context = context_owned.get();
 
+  auto provider = TestContextProvider::Create(std::move(context_owned));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(std::move(context_owned)));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
@@ skipping 57 matching lines @@
   MOCK_METHOD1(clear, void(GLbitfield mask));
   MOCK_METHOD4(drawElements,
                void(GLenum mode, GLsizei count, GLenum type, GLintptr offset));
 };
 
 TEST_F(GLRendererTest, ShouldClearRootRenderPass) {
   std::unique_ptr<NoClearRootRenderPassMockContext> mock_context_owned(
       new NoClearRootRenderPassMockContext);
   NoClearRootRenderPassMockContext* mock_context = mock_context_owned.get();
 
+  auto provider = TestContextProvider::Create(std::move(mock_context_owned));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(std::move(mock_context_owned)));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.should_clear_root_render_pass = false;
 
@@ skipping 61 matching lines @@
       scissor_enabled_ = false;
   }
 
  private:
   bool scissor_enabled_ = false;
 };
 
 TEST_F(GLRendererTest, ScissorTestWhenClearing) {
   auto gl_owned = base::MakeUnique<ScissorTestOnClearCheckingGLES2Interface>();
 
+  auto provider = TestContextProvider::Create(std::move(gl_owned));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
-  std::unique_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
-      TestContextProvider::Create(std::move(gl_owned))));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+  std::unique_ptr<OutputSurface> output_surface(
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
@@ skipping 49 matching lines @@
   void reset_discarded() { discarded_ = 0; }
 
  private:
   int discarded_ = 0;
 };
 
 TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) {
   auto gl_owned = base::MakeUnique<DiscardCheckingGLES2Interface>();
   auto* gl = gl_owned.get();
 
+  auto provider = TestContextProvider::Create(std::move(gl_owned));
+  provider->BindToCurrentThread();
+
   FakeOutputSurfaceClient output_surface_client;
-  auto output_surface = FakeOutputSurface::Create3d(std::move(gl_owned));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+  auto output_surface = FakeOutputSurface::Create3d(std::move(provider));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   FakeRendererGL renderer(&settings, output_surface.get(),
@@ skipping 58 matching lines @@
 };
 
 TEST_F(GLRendererTest, DrawFramePreservesFramebuffer) {
   // When using render-to-FBO to display the surface, all rendering is done
   // to a non-zero FBO. Make sure that the framebuffer is always restored to
   // the correct framebuffer during rendering, if changed.
   // Note: there is one path that will set it to 0, but that is after the render
   // has finished.
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<FakeOutputSurface> output_surface(
-      FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create()));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d());
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
@@ skipping 316 matching lines @@
   // through the OutputSurface abstraction.
   MOCK_METHOD2(bindFramebuffer, void(GLenum target, GLuint framebuffer));
   MOCK_METHOD3(reshapeWithScaleFactor,
                void(int width, int height, float scale_factor));
   MOCK_METHOD4(drawElements,
                void(GLenum mode, GLsizei count, GLenum type, GLintptr offset));
 };
 
 class MockOutputSurface : public OutputSurface {
  public:
-  MockOutputSurface()
-      : OutputSurface(TestContextProvider::Create(
-            base::MakeUnique<StrictMock<OutputSurfaceMockContext>>())) {}
+  explicit MockOutputSurface(scoped_refptr<ContextProvider> provider)
+      : OutputSurface(std::move(provider)) {}
   virtual ~MockOutputSurface() {}
 
+  void BindToClient(OutputSurfaceClient*) override {}
+
   MOCK_METHOD0(EnsureBackbuffer, void());
   MOCK_METHOD0(DiscardBackbuffer, void());
   MOCK_METHOD4(Reshape,
                void(const gfx::Size& size,
                     float scale_factor,
                     const gfx::ColorSpace& color_space,
                     bool has_alpha));
   MOCK_METHOD0(BindFramebuffer, void());
   MOCK_METHOD0(GetFramebufferCopyTextureFormat, GLenum());
   MOCK_METHOD1(SwapBuffers_, void(OutputSurfaceFrame& frame));  // NOLINT
   void SwapBuffers(OutputSurfaceFrame frame) override { SwapBuffers_(frame); }
   MOCK_CONST_METHOD0(GetOverlayCandidateValidator,
                      OverlayCandidateValidator*());
   MOCK_CONST_METHOD0(IsDisplayedAsOverlayPlane, bool());
   MOCK_CONST_METHOD0(GetOverlayTextureId, unsigned());
   MOCK_CONST_METHOD0(SurfaceIsSuspendForRecycle, bool());
   MOCK_CONST_METHOD0(HasExternalStencilTest, bool());
   MOCK_METHOD0(ApplyExternalStencil, void());
 };
 
 class MockOutputSurfaceTest : public GLRendererTest {
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
+    auto context = base::MakeUnique<StrictMock<OutputSurfaceMockContext>>();
+    context_ = context.get();
+    auto provider = TestContextProvider::Create(std::move(context));
+    provider->BindToCurrentThread();
+    output_surface_ =
+        base::MakeUnique<StrictMock<MockOutputSurface>>(std::move(provider));
+
     FakeOutputSurfaceClient output_surface_client_;
-    CHECK(output_surface_.BindToClient(&output_surface_client_));
+    output_surface_->BindToClient(&output_surface_client_);
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
-        output_surface_.context_provider(), shared_bitmap_manager_.get());
+        output_surface_->context_provider(), shared_bitmap_manager_.get());
 
-    renderer_.reset(new FakeRendererGL(&settings_, &output_surface_,
+    renderer_.reset(new FakeRendererGL(&settings_, output_surface_.get(),
                                        resource_provider_.get()));
-    EXPECT_CALL(output_surface_, GetOverlayCandidateValidator()).Times(1);
+    EXPECT_CALL(*output_surface_, GetOverlayCandidateValidator()).Times(1);
     renderer_->Initialize();
 
-    EXPECT_CALL(output_surface_, EnsureBackbuffer()).Times(1);
+    EXPECT_CALL(*output_surface_, EnsureBackbuffer()).Times(1);
     renderer_->SetVisible(true);
-    Mock::VerifyAndClearExpectations(&output_surface_);
+    Mock::VerifyAndClearExpectations(output_surface_.get());
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(std::vector<ui::LatencyInfo>()); }
 
   void DrawFrame(float device_scale_factor,
                  const gfx::Size& viewport_size,
                  bool transparent) {
     RenderPassId render_pass_id(1, 0);
     RenderPass* render_pass =
         AddRenderPass(&render_passes_in_draw_order_, render_pass_id,
                       gfx::Rect(viewport_size), gfx::Transform());
     AddQuad(render_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
     render_pass->has_transparent_background = transparent;
 
-    EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
+    EXPECT_CALL(*output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
-    EXPECT_CALL(output_surface_,
+    EXPECT_CALL(*output_surface_,
                 Reshape(viewport_size, device_scale_factor, _, transparent))
         .Times(1);
 
-    EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
+    EXPECT_CALL(*output_surface_, BindFramebuffer()).Times(1);
 
-    EXPECT_CALL(*Context(), drawElements(_, _, _, _)).Times(1);
+    EXPECT_CALL(*context_, drawElements(_, _, _, _)).Times(1);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_, device_scale_factor,
                          gfx::ColorSpace(), viewport_size);
   }
 
-  OutputSurfaceMockContext* Context() {
-    return static_cast<OutputSurfaceMockContext*>(
-        static_cast<TestContextProvider*>(output_surface_.context_provider())
-            ->TestContext3d());
-  }
-
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
-  StrictMock<MockOutputSurface> output_surface_;
+  OutputSurfaceMockContext* context_ = nullptr;
+  std::unique_ptr<StrictMock<MockOutputSurface>> output_surface_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
 TEST_F(MockOutputSurfaceTest, BackbufferDiscard) {
   // Drop backbuffer on hide.
-  EXPECT_CALL(output_surface_, DiscardBackbuffer()).Times(1);
+  EXPECT_CALL(*output_surface_, DiscardBackbuffer()).Times(1);
   renderer_->SetVisible(false);
-  Mock::VerifyAndClearExpectations(&output_surface_);
+  Mock::VerifyAndClearExpectations(output_surface_.get());
 
   // Restore backbuffer on show.
-  EXPECT_CALL(output_surface_, EnsureBackbuffer()).Times(1);
+  EXPECT_CALL(*output_surface_, EnsureBackbuffer()).Times(1);
   renderer_->SetVisible(true);
-  Mock::VerifyAndClearExpectations(&output_surface_);
+  Mock::VerifyAndClearExpectations(output_surface_.get());
 }
 
 class TestOverlayProcessor : public OverlayProcessor {
  public:
   class Strategy : public OverlayProcessor::Strategy {
    public:
     Strategy() {}
     ~Strategy() override {}
     MOCK_METHOD3(Attempt,
                  bool(ResourceProvider* resource_provider,
@@ skipping 31 matching lines @@
 void MailboxReleased(const gpu::SyncToken& sync_token,
                      bool lost_resource,
                      BlockingTaskRunner* main_thread_task_runner) {}
 
 void IgnoreCopyResult(std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<FakeOutputSurface> output_surface(
       FakeOutputSurface::Create3d());
-  CHECK(output_surface->BindToClient(&output_surface_client));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
   std::unique_ptr<TextureMailboxDeleter> mailbox_deleter(
       new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
 
   RendererSettings settings;
@@ skipping 127 matching lines @@
                     unsigned overlay_texture_id,
                     const gfx::Rect& display_bounds,
                     const gfx::RectF& uv_rect));
 };
 
 TEST_F(GLRendererTest, OverlaySyncTokensAreProcessed) {
   std::unique_ptr<WaitSyncTokenCountingContext> context_owned(
       new WaitSyncTokenCountingContext);
   WaitSyncTokenCountingContext* context = context_owned.get();
 
+  auto provider = TestContextProvider::Create(std::move(context_owned));
+  provider->BindToCurrentThread();
+
   MockOverlayScheduler overlay_scheduler;
-  scoped_refptr<TestContextProvider> context_provider =
-      TestContextProvider::Create(std::move(context_owned));
-  context_provider->support()->SetScheduleOverlayPlaneCallback(base::Bind(
+  provider->support()->SetScheduleOverlayPlaneCallback(base::Bind(
       &MockOverlayScheduler::Schedule, base::Unretained(&overlay_scheduler)));
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
-      FakeOutputSurface::Create3d(context_provider));
-  CHECK(output_surface->BindToClient(&output_surface_client));
+      FakeOutputSurface::Create3d(std::move(provider)));
+  output_surface->BindToClient(&output_surface_client);
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface->context_provider(),
                                    shared_bitmap_manager.get());
   std::unique_ptr<TextureMailboxDeleter> mailbox_deleter(
       new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
 
   RendererSettings settings;
@@ skipping 63 matching lines @@
   MOCK_METHOD1(Disable, void(GLenum cap));
   MOCK_METHOD4(Scissor, void(GLint x, GLint y, GLsizei width, GLsizei height));
 };
 
 class GLRendererPartialSwapTest : public GLRendererTest {
  protected:
   void RunTest(bool partial_swap) {
     auto gl_owned = base::MakeUnique<PartialSwapMockGLES2Interface>();
     auto* gl = gl_owned.get();
 
+    auto provider = TestContextProvider::Create(std::move(gl_owned));
+    provider->BindToCurrentThread();
+
     FakeOutputSurfaceClient output_surface_client;
     std::unique_ptr<FakeOutputSurface> output_surface(
-        FakeOutputSurface::Create3d(std::move(gl_owned)));
-    CHECK(output_surface->BindToClient(&output_surface_client));
+        FakeOutputSurface::Create3d(std::move(provider)));
+    output_surface->BindToClient(&output_surface_client);
 
     std::unique_ptr<ResourceProvider> resource_provider =
         FakeResourceProvider::Create(output_surface->context_provider(),
                                      nullptr);
 
     RendererSettings settings;
     settings.partial_swap_enabled = partial_swap;
     FakeRendererGL renderer(&settings, output_surface.get(),
                             resource_provider.get());
     renderer.Initialize();
@@ skipping 57 matching lines @@
     MockContextSupport() {}
     MOCK_METHOD1(SetAggressivelyFreeResources,
                  void(bool aggressively_free_resources));
   };
 
   void SetUp() override {
     auto context_support = base::MakeUnique<MockContextSupport>();
     context_support_ptr_ = context_support.get();
     auto context_provider = TestContextProvider::Create(
         TestWebGraphicsContext3D::Create(), std::move(context_support));
+    context_provider->BindToCurrentThread();
     output_surface_ = FakeOutputSurface::Create3d(std::move(context_provider));
     output_surface_->BindToClient(&output_surface_client_);
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_->context_provider(), nullptr);
     renderer_ =
         base::MakeUnique<GLRenderer>(&settings_, output_surface_.get(),
                                      resource_provider_.get(), nullptr, 0);
     renderer_->Initialize();
   }
 
@@ skipping 11 matching lines @@
   renderer_->SetVisible(true);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc