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

cc/test/layer_tree_test.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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 475 matching lines @@
   TestHooks* test_hooks_;
 };
 
 class LayerTreeTestCompositorFrameSinkClient
     : public TestCompositorFrameSinkClient {
  public:
   explicit LayerTreeTestCompositorFrameSinkClient(TestHooks* hooks)
       : hooks_(hooks) {}
 
   // TestCompositorFrameSinkClient implementation.
+  std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
+      scoped_refptr<ContextProvider> compositor_context_provider) override {
+    return hooks_->CreateDisplayOutputSurfaceOnThread(
+        std::move(compositor_context_provider));
+  }
   void DisplayReceivedCompositorFrame(const CompositorFrame& frame) override {
     hooks_->DisplayReceivedCompositorFrameOnThread(frame);
   }
   void DisplayWillDrawAndSwap(bool will_draw_and_swap,
                               const RenderPassList& render_passes) override {
     hooks_->DisplayWillDrawAndSwapOnThread(will_draw_and_swap, render_passes);
   }
   void DisplayDidDrawAndSwap() override {
     hooks_->DisplayDidDrawAndSwapOnThread();
   }
@@ skipping 359 matching lines @@
 
 void LayerTreeTest::RequestNewCompositorFrameSink() {
   scoped_refptr<TestContextProvider> shared_context_provider =
       TestContextProvider::Create();
   scoped_refptr<TestContextProvider> worker_context_provider =
       TestContextProvider::CreateWorker();
 
   auto compositor_frame_sink = CreateCompositorFrameSink(
       std::move(shared_context_provider), std::move(worker_context_provider));
   compositor_frame_sink->SetClient(compositor_frame_sink_client_.get());
-
-    layer_tree_host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
+  layer_tree_host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 std::unique_ptr<TestCompositorFrameSink>
 LayerTreeTest::CreateCompositorFrameSink(
     scoped_refptr<ContextProvider> compositor_context_provider,
     scoped_refptr<ContextProvider> worker_context_provider) {
   bool synchronous_composite =
       !HasImplThread() &&
       !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
   // Disable reclaim resources by default to act like the Display lives
   // out-of-process.
   bool force_disable_reclaim_resources = true;
   return base::MakeUnique<TestCompositorFrameSink>(
       compositor_context_provider, std::move(worker_context_provider),
-      CreateDisplayOutputSurface(compositor_context_provider),
       shared_bitmap_manager(), gpu_memory_buffer_manager(),
       layer_tree_host()->GetSettings().renderer_settings, impl_task_runner_,
       synchronous_composite, force_disable_reclaim_resources);
 }
 
-std::unique_ptr<OutputSurface> LayerTreeTest::CreateDisplayOutputSurface(
+std::unique_ptr<OutputSurface>
+LayerTreeTest::CreateDisplayOutputSurfaceOnThread(
     scoped_refptr<ContextProvider> compositor_context_provider) {
   // By default the Display shares a context with the LayerTreeHostImpl.
   return FakeOutputSurface::Create3d(std::move(compositor_context_provider));
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->GetLayerTree()->root_layer())
     layer_tree_host_->GetLayerTree()->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_ = nullptr;
   layer_tree_host_in_process_ = nullptr;
@@ skipping 21 matching lines @@
   DCHECK(!IsRemoteTest());
   return layer_tree_host_in_process_;
 }
 
 Proxy* LayerTreeTest::proxy() {
   return layer_tree_host_in_process() ? layer_tree_host_in_process()->proxy()
                                       : NULL;
 }
 
 }  // namespace cc