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

cc/trees/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/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 8209 matching lines @@
   UIResourceId ui_resource_id = 1;
   host_impl_->CreateUIResource(ui_resource_id, bitmap);
   EXPECT_EQ(1u, context3d->NumTextures());
   ResourceId id1 = host_impl_->ResourceIdForUIResource(ui_resource_id);
   EXPECT_NE(0u, id1);
 }
 
 void ShutdownReleasesContext_Callback(
     std::unique_ptr<CopyOutputResult> result) {}
 
+class FrameSinkClient : public TestCompositorFrameSinkClient {
+ public:
+  explicit FrameSinkClient(
+      scoped_refptr<ContextProvider> display_context_provider)
+      : display_context_provider_(std::move(display_context_provider)) {}
+
+  std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
+      scoped_refptr<ContextProvider> compositor_context_provider) override {
+    return FakeOutputSurface::Create3d(std::move(display_context_provider_));
+  }
+
+  void DisplayReceivedCompositorFrame(const CompositorFrame& frame) override {}
+  void DisplayWillDrawAndSwap(bool will_draw_and_swap,
+                              const RenderPassList& render_passes) override {}
+  void DisplayDidDrawAndSwap() override {}
+
+ private:
+  scoped_refptr<ContextProvider> display_context_provider_;
+};
+
 TEST_F(LayerTreeHostImplTest, ShutdownReleasesContext) {
   scoped_refptr<TestContextProvider> context_provider =
       TestContextProvider::Create();
+  FrameSinkClient test_client_(context_provider);
 
-  CreateHostImpl(
-      DefaultSettings(),
-      base::MakeUnique<TestCompositorFrameSink>(
-          context_provider, TestContextProvider::CreateWorker(),
-          FakeOutputSurface::Create3d(context_provider), nullptr, nullptr,
-          RendererSettings(), base::ThreadTaskRunnerHandle::Get().get(),
-          true /* synchronous_composite */,
-          false /* force_disable_reclaim_resources */));
+  auto compositor_frame_sink = base::MakeUnique<TestCompositorFrameSink>(
+      context_provider, TestContextProvider::CreateWorker(), nullptr, nullptr,
+      RendererSettings(), base::ThreadTaskRunnerHandle::Get().get(),
+      true /* synchronous_composite */,
+      false /* force_disable_reclaim_resources */);
+  compositor_frame_sink->SetClient(&test_client_);
+
+  CreateHostImpl(DefaultSettings(), std::move(compositor_frame_sink));
 
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
 
   LayerImpl* root = host_impl_->active_tree()->root_layer_for_testing();
   root->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(
           base::Bind(&ShutdownReleasesContext_Callback)));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
 
   LayerTreeHostImpl::FrameData frame;
@@ skipping 3221 matching lines @@
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 
   // Re-initialize with a software output surface.
   compositor_frame_sink_ = FakeCompositorFrameSink::CreateSoftware();
   host_impl_->InitializeRenderer(compositor_frame_sink_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc