cc: Make OutputSurface entirely live on one thread in tests.

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 111 matching lines @@
     EXPECT_TRUE(layer_tree_host()->GetTaskRunnerProvider()->IsMainThread());
     EXPECT_TRUE(result->HasBitmap());
     std::unique_ptr<SkBitmap> bitmap = result->TakeBitmap();
     EXPECT_EQ(result->size().ToString(),
               gfx::Size(bitmap->width(), bitmap->height()).ToString());
     callbacks_[id] = result->size();
   }
 
   void AfterTest() override { EXPECT_EQ(4u, callbacks_.size()); }
 
-  std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
+  std::unique_ptr<OutputSurface> CreateDisplayOutputSurfaceOnThread(
       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_);
@@ skipping 316 matching lines @@
     parent_layer_->AddChild(copy_layer_);
 
     layer_tree()->SetRootLayer(root_);
     LayerTreeHostCopyRequestTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
-    auto surface = LayerTreeHostCopyRequestTest::CreateCompositorFrameSink(
+    auto frame_sink = LayerTreeHostCopyRequestTest::CreateCompositorFrameSink(
         std::move(compositor_context_provider),
         std::move(worker_context_provider));
-    display_ = surface->display();
-    return surface;
+    frame_sink_ = frame_sink.get();
+    return frame_sink;
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
 
     copy_layer_->RequestCopyOfOutput(
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest::
                  CopyOutputCallback,
             base::Unretained(this))));
@@ skipping 16 matching lines @@
       return;
     }
 
     EXPECT_EQ(2u, render_passes.size());
     // The root pass is the back of the list.
     copy_layer_render_pass_id = render_passes[0]->id;
     parent_render_pass_id = render_passes[1]->id;
   }
 
   void DisplayDidDrawAndSwapOnThread() override {
-    DirectRenderer* renderer = display_->renderer_for_testing();
+    DirectRenderer* renderer = frame_sink_->display()->renderer_for_testing();
 
     // |parent| owns a surface, but it was hidden and not part of the copy
     // request so it should not allocate any resource.
     EXPECT_FALSE(
         renderer->HasAllocatedResourcesForTesting(parent_render_pass_id));
 
     // TODO(crbug.com/564832): Ignore the extra frame that occurs due to copy
     // completion. This can be removed when the extra commit is removed.
     if (did_swap_) {
       EXPECT_FALSE(
           renderer->HasAllocatedResourcesForTesting(copy_layer_render_pass_id));
     } else {
       // |copy_layer| should have been rendered to a texture since it was needed
       // for a copy request.
       EXPECT_TRUE(
           renderer->HasAllocatedResourcesForTesting(copy_layer_render_pass_id));
     }
 
     did_swap_ = true;
   }
 
   void AfterTest() override { EXPECT_TRUE(did_swap_); }
 
   RenderPassId parent_render_pass_id;
   RenderPassId copy_layer_render_pass_id;
-  Display* display_ = nullptr;
+  TestCompositorFrameSink* frame_sink_ = nullptr;
   bool did_swap_ = false;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> grand_parent_layer_;
   scoped_refptr<FakePictureLayer> parent_layer_;
   scoped_refptr<FakePictureLayer> copy_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest);
@@ skipping 177 matching lines @@
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> root_;
   scoped_refptr<FakePictureLayer> copy_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAsyncTwoReadbacksWithoutDraw);
 
 class LayerTreeHostCopyRequestTestDeleteTexture
     : public LayerTreeHostCopyRequestTest {
  protected:
-  std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
+  std::unique_ptr<OutputSurface> CreateDisplayOutputSurfaceOnThread(
       scoped_refptr<ContextProvider> compositor_context_provider) override {
     display_context_provider_ = TestContextProvider::Create();
     return FakeOutputSurface::Create3d(display_context_provider_);
   }
 
   void SetupTree() override {
     root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     copy_layer_ = FakePictureLayer::Create(&client_);
@@ skipping 37 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());
+
+    // Drop the reference to 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 38 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostCopyRequestTestDeleteTexture);
 
 class LayerTreeHostCopyRequestTestCountTextures
     : public LayerTreeHostCopyRequestTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     // Always allocate only a single texture at a time through ResourceProvider.
     settings->renderer_settings.texture_id_allocation_chunk_size = 1;
   }
 
-  std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
+  std::unique_ptr<OutputSurface> CreateDisplayOutputSurfaceOnThread(
       scoped_refptr<ContextProvider> compositor_context_provider) override {
     // These tests expect the LayerTreeHostImpl to share a context with
     // the Display so that sync points are not needed and the texture counts
     // are visible together.
     // Since this test does not override CreateCompositorFrameSink, the
     // |compositor_context_provider| will be a TestContextProvider.
     display_context_provider_ =
         static_cast<TestContextProvider*>(compositor_context_provider.get());
     return FakeOutputSurface::Create3d(std::move(compositor_context_provider));
   }
@@ skipping 424 matching lines @@
   int num_draws_;
   bool copy_happened_;
   bool draw_happened_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest);
 
 }  // namespace
 }  // namespace cc