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

cc/trees/layer_tree_host_unittest_copyrequest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 122 matching lines @@
       scoped_refptr<ContextProvider> compositor_context_provider) override {
     if (!use_gl_renderer_) {
       return FakeOutputSurface::CreateSoftware(
           base::WrapUnique(new SoftwareOutputDevice));
     }
 
     scoped_refptr<TestContextProvider> display_context_provider =
         TestContextProvider::Create();
     TestContextSupport* context_support = display_context_provider->support();
     context_support->set_out_of_order_callbacks(out_of_order_callbacks_);
+    display_context_provider->BindToCurrentThread();
 
     return FakeOutputSurface::Create3d(std::move(display_context_provider));
   }
 
   bool use_gl_renderer_;
   bool out_of_order_callbacks_ = false;
   std::map<size_t, gfx::Size> callbacks_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root;
   scoped_refptr<FakePictureLayer> child;
@@ skipping 574 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAsyncTwoReadbacksWithoutDraw);
 
 class LayerTreeHostCopyRequestTestDeleteTexture
     : public LayerTreeHostCopyRequestTest {
  protected:
   std::unique_ptr<OutputSurface> CreateDisplayOutputSurfaceOnThread(
       scoped_refptr<ContextProvider> compositor_context_provider) override {
     display_context_provider_ = TestContextProvider::Create();
+    display_context_provider_->BindToCurrentThread();
     return FakeOutputSurface::Create3d(display_context_provider_);
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
     copy_layer_->SetBounds(gfx::Size(10, 10));
     root_->AddChild(copy_layer_);
@@ skipping 35 matching lines @@
                                   CheckNumTexturesAfterReadbackDestroyed,
                               base::Unretained(this)));
   }
 
   void CheckNumTexturesAfterReadbackDestroyed() {
     // After the copy we had |num_textures_after_readback_| many textures, but
     // releasing the copy output request should cause the texture in the request
     // to be destroyed by the compositor, so we should have 1 less by now.
     EXPECT_EQ(num_textures_after_readback_ - 1,
               display_context_provider_->TestContext3d()->NumTextures());
+
+    // Unref the context provider on the compositor thread.
+    display_context_provider_ = nullptr;
     EndTest();
   }
 
   void DisplayDidDrawAndSwapOnThread() override {
     switch (num_swaps_++) {
       case 0:
         // The layers have been drawn, so any textures required for drawing have
         // been allocated.
         EXPECT_FALSE(result_);
         num_textures_without_readback_ =
@@ skipping 483 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc