cc: Allow TestDelegatingOutputSurface to be used for non-pixel tests.

cc/test/layer_tree_pixel_test.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 "cc/test/layer_tree_pixel_test.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "cc/base/switches.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
-#include "cc/output/direct_renderer.h"
+#include "cc/output/texture_mailbox_deleter.h"
 #include "cc/resources/texture_mailbox.h"
+#include "cc/scheduler/begin_frame_source.h"
+#include "cc/scheduler/delay_based_time_source.h"
 #include "cc/test/paths.h"
 #include "cc/test/pixel_comparator.h"
-#include "cc/test/pixel_test_delegating_output_surface.h"
 #include "cc/test/pixel_test_output_surface.h"
 #include "cc/test/pixel_test_software_output_device.h"
 #include "cc/test/pixel_test_utils.h"
+#include "cc/test/test_delegating_output_surface.h"
 #include "cc/test/test_in_process_context_provider.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 LayerTreePixelTest::LayerTreePixelTest()
     : pixel_comparator_(new ExactPixelComparator(true)),
       test_type_(PIXEL_TEST_GL),
       pending_texture_mailbox_callbacks_(0) {}
 
 LayerTreePixelTest::~LayerTreePixelTest() {}
 
 void LayerTreePixelTest::InitializeSettings(LayerTreeSettings* settings) {
   // The PixelTestDelegatingOutputSurface will provide a BeginFrameSource.
   settings->use_output_surface_begin_frame_source = true;
 }
 
 std::unique_ptr<OutputSurface> LayerTreePixelTest::CreateOutputSurface() {
-  scoped_refptr<TestInProcessContextProvider> compositor;
-  scoped_refptr<TestInProcessContextProvider> worker;
-  scoped_refptr<TestInProcessContextProvider> display;
+  // Always test Webview shenanigans.
+  gfx::Size surface_expansion_size(40, 60);
+
+  scoped_refptr<TestInProcessContextProvider> compositor_context_provider;
+  scoped_refptr<TestInProcessContextProvider> worker_context_provider;
+  scoped_refptr<TestInProcessContextProvider> display_context_provider;
+  std::unique_ptr<PixelTestOutputSurface> display_output_surface;
   if (test_type_ == PIXEL_TEST_GL) {
-    compositor = new TestInProcessContextProvider(nullptr);
-    worker = new TestInProcessContextProvider(compositor.get());
-    display = new TestInProcessContextProvider(nullptr);
+    compositor_context_provider = new TestInProcessContextProvider(nullptr);
+    worker_context_provider =
+        new TestInProcessContextProvider(compositor_context_provider.get());
+    display_context_provider = new TestInProcessContextProvider(nullptr);
+    bool flipped_output_surface = false;
+    display_output_surface = base::MakeUnique<PixelTestOutputSurface>(
+        std::move(display_context_provider), nullptr, flipped_output_surface);
+  } else {
+    std::unique_ptr<PixelTestSoftwareOutputDevice> software_output_device(
+        new PixelTestSoftwareOutputDevice);
+    software_output_device->set_surface_expansion_size(surface_expansion_size);
+    display_output_surface = base::MakeUnique<PixelTestOutputSurface>(
+        std::move(software_output_device));
   }
-  const bool allow_force_reclaim_resources = !HasImplThread();
-  const bool synchronous_composite =
-      !layer_tree_host()->settings().single_thread_proxy_scheduler;
-  // Always test Webview shenanigans.
-  const gfx::Size surface_expansion_size(40, 60);
-  std::unique_ptr<PixelTestDelegatingOutputSurface> delegating_output_surface(
-      new PixelTestDelegatingOutputSurface(
-          std::move(compositor), std::move(worker), std::move(display),
-          RendererSettings(), shared_bitmap_manager(),
-          gpu_memory_buffer_manager(), surface_expansion_size,
-          allow_force_reclaim_resources, synchronous_composite));
-  delegating_output_surface->SetEnlargePassTextureAmount(
-      enlarge_texture_amount_);
-  return std::move(delegating_output_surface);
+  display_output_surface->set_surface_expansion_size(surface_expansion_size);
+
+  auto* task_runner = ImplThreadTaskRunner();
+  CHECK(task_runner);
+
+  std::unique_ptr<SyntheticBeginFrameSource> begin_frame_source;
+  std::unique_ptr<DisplayScheduler> scheduler;
+  if (layer_tree_host()->settings().single_thread_proxy_scheduler) {
+    begin_frame_source.reset(new DelayBasedBeginFrameSource(
+        base::MakeUnique<DelayBasedTimeSource>(task_runner)));
+    scheduler.reset(new DisplayScheduler(
+        begin_frame_source.get(), task_runner,
+        display_output_surface->capabilities().max_frames_pending));
+  }
+
+  std::unique_ptr<Display> display(
+      new Display(shared_bitmap_manager(), gpu_memory_buffer_manager(),
+                  RendererSettings(), std::move(begin_frame_source),
+                  std::move(display_output_surface), std::move(scheduler),
+                  base::MakeUnique<TextureMailboxDeleter>(task_runner)));
+  display->SetEnlargePassTextureAmountForTesting(enlarge_texture_amount_);
+
+  const bool context_shared_with_compositor = false;
+  const bool allow_force_reclaim_resources = true;
+  return base::MakeUnique<TestDelegatingOutputSurface>(
+      std::move(compositor_context_provider),
+      std::move(worker_context_provider), std::move(display),
+      context_shared_with_compositor, allow_force_reclaim_resources);
 }
 
 std::unique_ptr<CopyOutputRequest>
 LayerTreePixelTest::CreateCopyOutputRequest() {
   return CopyOutputRequest::CreateBitmapRequest(
       base::Bind(&LayerTreePixelTest::ReadbackResult, base::Unretained(this)));
 }
 
 void LayerTreePixelTest::ReadbackResult(
     std::unique_ptr<CopyOutputResult> result) {
@@ skipping 188 matching lines @@
 }
 
 void LayerTreePixelTest::Finish() {
   std::unique_ptr<gpu::GLInProcessContext> context =
       CreateTestInProcessContext();
   GLES2Interface* gl = context->GetImplementation();
   gl->Finish();
 }
 
 }  // namespace cc