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

content/test/layouttest_support.cc

 // Copyright (c) 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 "content/public/test/layouttest_support.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 303 matching lines @@
   int64_t TraceId() const override { return 0; }
 
  private:
   std::unique_ptr<cc::CopyOutputRequest> copy_request_;
   FindCompositorFrameSinkCallback find_compositor_frame_sink_callback_;
   cc::TestCompositorFrameSink* compositor_frame_sink_from_commit_ = nullptr;
 };
 
 }  // namespace
 
-class LayoutTestDependenciesImpl : public LayoutTestDependencies {
+class LayoutTestDependenciesImpl : public LayoutTestDependencies,
+                                   public cc::TestCompositorFrameSinkClient {
  public:
   std::unique_ptr<cc::CompositorFrameSink> CreateCompositorFrameSink(
       int32_t routing_id,
       scoped_refptr<gpu::GpuChannelHost> gpu_channel,
       scoped_refptr<cc::ContextProvider> compositor_context_provider,
       scoped_refptr<cc::ContextProvider> worker_context_provider,
       CompositorDependencies* deps) override {
-    // This is for an offscreen context for the compositor. So the default
-    // framebuffer doesn't need alpha, depth, stencil, antialiasing.
-    gpu::gles2::ContextCreationAttribHelper attributes;
-    attributes.alpha_size = -1;
-    attributes.depth_size = 0;
-    attributes.stencil_size = 0;
-    attributes.samples = 0;
-    attributes.sample_buffers = 0;
-    attributes.bind_generates_resource = false;
-    attributes.lose_context_when_out_of_memory = true;
-    const bool automatic_flushes = false;
-    const bool support_locking = false;
-
-    bool flipped_output_surface = false;
-    std::unique_ptr<cc::OutputSurface> display_output_surface(
-        new cc::PixelTestOutputSurface(
-            make_scoped_refptr(new ContextProviderCommandBuffer(
-                std::move(gpu_channel), gpu::GPU_STREAM_DEFAULT,
-                gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle,
-                GURL("chrome://gpu/"
-                     "LayoutTestDependenciesImpl::CreateOutputSurface"),
-                automatic_flushes, support_locking, gpu::SharedMemoryLimits(),
-                attributes, nullptr,
-                command_buffer_metrics::OFFSCREEN_CONTEXT_FOR_TESTING)),
-            flipped_output_surface));
+    // This could override the GpuChannel for a CompositorFrameSink that was
+    // previously being created but in that case the old GpuChannel would be
+    // lost as would the CompositorFrameSink.
+    gpu_channel_ = gpu_channel;
 
     auto* task_runner = deps->GetCompositorImplThreadTaskRunner().get();
     bool synchronous_composite = !task_runner;
     if (!task_runner)
       task_runner = base::ThreadTaskRunnerHandle::Get().get();
 
     cc::LayerTreeSettings settings =
         RenderWidgetCompositor::GenerateLayerTreeSettings(
             *base::CommandLine::ForCurrentProcess(), deps, 1.f);
 
     auto compositor_frame_sink = base::MakeUnique<cc::TestCompositorFrameSink>(
         std::move(compositor_context_provider),
-        std::move(worker_context_provider), std::move(display_output_surface),
-        deps->GetSharedBitmapManager(), deps->GetGpuMemoryBufferManager(),
-        settings.renderer_settings, task_runner, synchronous_composite,
+        std::move(worker_context_provider), deps->GetSharedBitmapManager(),
+        deps->GetGpuMemoryBufferManager(), settings.renderer_settings,
+        task_runner, synchronous_composite,
         false /* force_disable_reclaim_resources */);
+    compositor_frame_sink->SetClient(this);
     compositor_frame_sinks_[routing_id] = compositor_frame_sink.get();
     return std::move(compositor_frame_sink);
   }
 
   std::unique_ptr<cc::SwapPromise> RequestCopyOfOutput(
       int32_t routing_id,
       std::unique_ptr<cc::CopyOutputRequest> request) override {
     // Note that we can't immediately check compositor_frame_sinks_, since it
     // may not have been created yet. Instead, we wait until OnCommit to find
     // the currently active CompositorFrameSink for the given RenderWidget
     // routing_id.
     return base::MakeUnique<CopyRequestSwapPromise>(
         std::move(request),
         base::Bind(
             &LayoutTestDependenciesImpl::FindCompositorFrameSink,
             // |this| will still be valid, because its lifetime is tied to
             // RenderThreadImpl, which outlives layout test execution.
             base::Unretained(this), routing_id));
   }
 
+  // TestCompositorFrameSinkClient implementation.
+  std::unique_ptr<cc::OutputSurface> CreateDisplayOutputSurface(
+      scoped_refptr<cc::ContextProvider> compositor_context_provider) override {
+    // This is for an offscreen context for the compositor. So the default
+    // framebuffer doesn't need alpha, depth, stencil, antialiasing.
+    gpu::gles2::ContextCreationAttribHelper attributes;
+    attributes.alpha_size = -1;
+    attributes.depth_size = 0;
+    attributes.stencil_size = 0;
+    attributes.samples = 0;
+    attributes.sample_buffers = 0;
+    attributes.bind_generates_resource = false;
+    attributes.lose_context_when_out_of_memory = true;
+    const bool automatic_flushes = false;
+    const bool support_locking = false;
+
+    bool flipped_output_surface = false;
+    return base::MakeUnique<cc::PixelTestOutputSurface>(
+        make_scoped_refptr(new ContextProviderCommandBuffer(
+            gpu_channel_, gpu::GPU_STREAM_DEFAULT,
+            gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle,
+            GURL("chrome://gpu/"
+                 "LayoutTestDependenciesImpl::CreateOutputSurface"),
+            automatic_flushes, support_locking, gpu::SharedMemoryLimits(),
+            attributes, nullptr,
+            command_buffer_metrics::OFFSCREEN_CONTEXT_FOR_TESTING)),
+        flipped_output_surface);
+  }
+  void DisplayReceivedCompositorFrame(
+      const cc::CompositorFrame& frame) override {}
+  void DisplayWillDrawAndSwap(
+      bool will_draw_and_swap,
+      const cc::RenderPassList& render_passes) override {}
+  void DisplayDidDrawAndSwap() override {}
+
  private:
   cc::TestCompositorFrameSink* FindCompositorFrameSink(int32_t routing_id) {
     auto it = compositor_frame_sinks_.find(routing_id);
     return it == compositor_frame_sinks_.end() ? nullptr : it->second;
   }
 
   // Entries are not removed, so this map can grow. However, it is only used in
   // layout tests, so this memory usage does not occur in production.
   // Entries in this map will outlive the output surface, because this object is
   // owned by RenderThreadImpl, which outlives layout test execution.
   std::unordered_map<int32_t, cc::TestCompositorFrameSink*>
       compositor_frame_sinks_;
+  scoped_refptr<gpu::GpuChannelHost> gpu_channel_;
 };
 
 void EnableRendererLayoutTestMode() {
   RenderThreadImpl::current()->set_layout_test_dependencies(
       base::MakeUnique<LayoutTestDependenciesImpl>());
 
 #if defined(OS_WIN)
   RegisterSideloadedTypefaces(SkFontMgr_New_DirectWrite());
 #endif
 }
@@ skipping 689 matching lines @@
   return result;
 }
 
 void SchedulerRunIdleTasks(const base::Closure& callback) {
   blink::scheduler::RendererScheduler* scheduler =
       content::RenderThreadImpl::current()->GetRendererScheduler();
   blink::scheduler::RunIdleTasksForTesting(scheduler, callback);
 }
 
 }  // namespace content