Add Skia Dawn variants of viz_unittests

These tests are enabled using the GN arg "skia_use_dawn = true".

Bug: 1021566
Change-Id: Ifeaa6c3bb0ab9fbfa74fb4946ef61227f6bfacd7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2037346Reviewed-by: kylechar <kylechar@chromium.org>
Commit-Queue: Sean Gilhuly <sgilhuly@chromium.org>
Cr-Commit-Position: refs/heads/master@{#748369}

cc/test/pixel_test.cc

@@ -14,7 +14,6 @@
 #include "base/memory/shared_memory_mapping.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
-#include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
@@ -23,6 +22,7 @@
 #include "cc/test/pixel_test_output_surface.h"
 #include "cc/test/pixel_test_utils.h"
 #include "components/viz/client/client_resource_provider.h"
+#include "components/viz/common/features.h"
 #include "components/viz/common/frame_sinks/begin_frame_source.h"
 #include "components/viz/common/frame_sinks/copy_output_request.h"
 #include "components/viz/common/frame_sinks/copy_output_result.h"
@@ -54,22 +54,37 @@
 
 namespace cc {
 
-PixelTest::PixelTest(bool enable_vulkan)
+PixelTest::PixelTest(GraphicsBackend backend)
     : device_viewport_size_(gfx::Size(200, 200)),
       disable_picture_quad_image_filtering_(false),
       output_surface_client_(std::make_unique<FakeOutputSurfaceClient>()) {
   // Keep texture sizes exactly matching the bounds of the RenderPass to avoid
   // floating point badness in texcoords.
   renderer_settings_.dont_round_texture_sizes_for_pixel_tests = true;
-  if (enable_vulkan) {
+
+  // Check if the graphics backend needs to initialize Vulkan.
+  bool init_vulkan = false;
+  if (backend == kSkiaVulkan) {
+    scoped_feature_list_.InitAndEnableFeature(features::kVulkan);
+    init_vulkan = true;
+  } else if (backend == kSkiaDawn) {
+    scoped_feature_list_.InitAndEnableFeature(features::kSkiaDawn);
+#if defined(OS_LINUX)
+    init_vulkan = true;
+#elif defined(OS_WIN)
+    // TODO(sgilhuly): Initialize D3D12 for Windows.
+#else
+    NOTREACHED();
+#endif
+  }
+
+  if (init_vulkan) {
     auto* command_line = base::CommandLine::ForCurrentProcess();
     bool use_gpu = command_line->HasSwitch(::switches::kUseGpuInTests);
     command_line->AppendSwitchASCII(
         ::switches::kUseVulkan,
         use_gpu ? ::switches::kVulkanImplementationNameNative
                 : ::switches::kVulkanImplementationNameSwiftshader);
-    scoped_feature_list_ = std::make_unique<base::test::ScopedFeatureList>();
-    scoped_feature_list_->InitAndEnableFeature(features::kVulkan);
   }
 }
 

cc/test/pixel_test.h

@@ -12,6 +12,7 @@
 #include "base/files/file_util.h"
 #include "base/memory/shared_memory_mapping.h"
 #include "base/single_thread_task_runner.h"
+#include "base/test/scoped_feature_list.h"
 #include "cc/test/pixel_comparator.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "components/viz/client/client_resource_provider.h"
@@ -27,12 +28,6 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 
-namespace base {
-namespace test {
-class ScopedFeatureList;
-}
-}
-
 namespace viz {
 class CopyOutputResult;
 class DirectRenderer;
@@ -43,13 +38,27 @@ class TestSharedBitmapManager;
 }
 
 namespace cc {
+class DawnSkiaRenderer;
 class FakeOutputSurfaceClient;
 class OutputSurface;
 class VulkanSkiaRenderer;
 
 class PixelTest : public testing::Test {
  protected:
-  explicit PixelTest(bool use_vulkan = false);
+  // Some graphics backends require command line or base::Feature initialization
+  // which must occur in the constructor to avoid potential races.
+  enum GraphicsBackend {
+    // The pixel test will be initialized for software or GL renderers. No work
+    // needs to be done in the constructor.
+    kDefault,
+    // SkiaRenderer with the Vulkan backend will be used.
+    kSkiaVulkan,
+    // SkiaRenderer with the Dawn backend will be used; on Linux this will
+    // initialize Vulkan, and on Windows this will initialize D3D12.
+    kSkiaDawn,
+  };
+
+  explicit PixelTest(GraphicsBackend backend = kDefault);
   ~PixelTest() override;
 
   bool RunPixelTest(viz::RenderPassList* pass_list,
@@ -96,7 +105,7 @@ class PixelTest : public testing::Test {
 
   // |scoped_feature_list_| must be the first member to ensure that it is
   // destroyed after any member that might be using it.
-  std::unique_ptr<base::test::ScopedFeatureList> scoped_feature_list_;
+  base::test::ScopedFeatureList scoped_feature_list_;
   viz::TestGpuServiceHolder::ScopedResetter gpu_service_resetter_;
 
   // For SkiaRenderer.
@@ -138,7 +147,7 @@ class PixelTest : public testing::Test {
 template<typename RendererType>
 class RendererPixelTest : public PixelTest {
  public:
-  RendererPixelTest() : PixelTest(use_vulkan()) {}
+  RendererPixelTest() : PixelTest(backend()) {}
 
   RendererType* renderer() {
     return static_cast<RendererType*>(renderer_.get());
@@ -149,6 +158,8 @@ class RendererPixelTest : public PixelTest {
   const char* renderer_type() {
     if (std::is_base_of<viz::GLRenderer, RendererType>::value)
       return "gl";
+    if (std::is_base_of<DawnSkiaRenderer, RendererType>::value)
+      return "dawn";
     if (std::is_base_of<viz::SkiaRenderer, RendererType>::value)
       return "skia";
     if (std::is_base_of<viz::SoftwareRenderer, RendererType>::value)
@@ -157,8 +168,12 @@ class RendererPixelTest : public PixelTest {
   }
 
   bool use_gpu() const { return !!child_context_provider_; }
-  bool use_vulkan() const {
-    return std::is_base_of<VulkanSkiaRenderer, RendererType>::value;
+  GraphicsBackend backend() const {
+    if (std::is_base_of<VulkanSkiaRenderer, RendererType>::value)
+      return kSkiaVulkan;
+    if (std::is_base_of<DawnSkiaRenderer, RendererType>::value)
+      return kSkiaDawn;
+    return kDefault;
   }
 
  protected:
@@ -170,7 +185,9 @@ class RendererPixelTest : public PixelTest {
 class GLRendererWithFlippedSurface : public viz::GLRenderer {};
 class SkiaRendererWithFlippedSurface : public viz::SkiaRenderer {};
 class VulkanSkiaRenderer : public viz::SkiaRenderer {};
-class VulkanSkiaRendererWithFlippedSurface : public viz::SkiaRenderer {};
+class VulkanSkiaRendererWithFlippedSurface : public VulkanSkiaRenderer {};
+class DawnSkiaRenderer : public viz::SkiaRenderer {};
+class DawnSkiaRendererWithFlippedSurface : public DawnSkiaRenderer {};
 
 template <>
 inline void RendererPixelTest<viz::GLRenderer>::SetUp() {
@@ -207,6 +224,16 @@ inline void RendererPixelTest<VulkanSkiaRendererWithFlippedSurface>::SetUp() {
   SetUpSkiaRenderer(gfx::SurfaceOrigin::kTopLeft);
 }
 
+template <>
+inline void RendererPixelTest<DawnSkiaRenderer>::SetUp() {
+  SetUpSkiaRenderer(gfx::SurfaceOrigin::kBottomLeft);
+}
+
+template <>
+inline void RendererPixelTest<DawnSkiaRendererWithFlippedSurface>::SetUp() {
+  SetUpSkiaRenderer(gfx::SurfaceOrigin::kTopLeft);
+}
+
 typedef RendererPixelTest<viz::GLRenderer> GLRendererPixelTest;
 typedef RendererPixelTest<viz::SoftwareRenderer> SoftwareRendererPixelTest;
 

components/viz/service/BUILD.gn

@@ -537,6 +537,8 @@ viz_source_set("unit_tests") {
     ]
   }
 
+  defines = []
+
   if (enable_vulkan) {
     deps += [
       "//gpu/vulkan:test_support",
@@ -547,9 +549,13 @@ viz_source_set("unit_tests") {
     # CFI issue: https://crbug.com/967819
     # LSAN issue: https://crbug.com/971357
     if (use_x11 && !is_cfi && !is_lsan) {
-      defines = [ "ENABLE_VIZ_VULKAN_TESTS" ]
+      defines += [ "ENABLE_VIZ_VULKAN_TESTS" ]
     }
   }
+
+  if (skia_use_dawn) {
+    defines += [ "ENABLE_VIZ_DAWN_TESTS" ]
+  }
 }
 
 viz_source_set("perf_tests") {

components/viz/service/display/renderer_pixeltest.cc

@@ -887,10 +887,23 @@ using RendererTypes = ::testing::Types<GLRenderer,
 #if defined(ENABLE_VIZ_VULKAN_TESTS)
                                        ,
                                        cc::VulkanSkiaRenderer
+#endif
+#if defined(ENABLE_VIZ_DAWN_TESTS)
+                                       ,
+                                       cc::DawnSkiaRenderer
 #endif
                                        >;
 TYPED_TEST_SUITE(RendererPixelTest, RendererTypes);
 
+using RendererTypesNonDawn = ::testing::Types<GLRenderer,
+                                              SoftwareRenderer,
+                                              SkiaRenderer
+#if defined(ENABLE_VIZ_VULKAN_TESTS)
+                                              ,
+                                              cc::VulkanSkiaRenderer
+#endif
+                                              >;
+
 class SoftwareRendererPixelTest
     : public cc::RendererPixelTest<SoftwareRenderer> {};
 
@@ -898,6 +911,8 @@ class SoftwareRendererPixelTest
 template <typename RendererType>
 class GPURendererPixelTest : public cc::RendererPixelTest<RendererType> {};
 
+// TODO(crbug.com/1021566): Enable these tests for SkiaRenderer Dawn once video
+// is supported.
 using GPURendererTypes = ::testing::Types<GLRenderer,
                                           SkiaRenderer
 #if defined(ENABLE_VIZ_VULKAN_TESTS)
@@ -1378,7 +1393,12 @@ TYPED_TEST_SUITE(IntersectingQuadPixelTest, RendererTypes);
 TYPED_TEST_SUITE(IntersectingVideoQuadPixelTest, GPURendererTypes);
 TYPED_TEST_SUITE(IntersectingQuadSoftwareTest, SoftwareRendererTypes);
 
-TYPED_TEST(IntersectingQuadPixelTest, SolidColorQuads) {
+// TODO(crbug.com/1021566): Enable this test for SkiaRenderer Dawn.
+template <typename TypeParam>
+class IntersectingQuadPixelTestNonDawn
+    : public IntersectingQuadPixelTest<TypeParam> {};
+TYPED_TEST_SUITE(IntersectingQuadPixelTestNonDawn, RendererTypesNonDawn);
+TYPED_TEST(IntersectingQuadPixelTestNonDawn, SolidColorQuads) {
   this->SetupQuadStateAndRenderPass();
 
   auto* quad = this->template CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -3002,6 +3022,10 @@ using BackdropFilterRendererTypes = ::testing::Types<GLRenderer,
 #if defined(ENABLE_VIZ_VULKAN_TESTS)
                                                      ,
                                                      cc::VulkanSkiaRenderer
+#endif
+#if defined(ENABLE_VIZ_DAWN_TESTS)
+                                                     ,
+                                                     cc::DawnSkiaRenderer
 #endif
                                                      >;
 
@@ -3376,7 +3400,7 @@ TYPED_TEST(GPURendererPixelTest, AxisAligned) {
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list, base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")),
-      cc::ExactPixelComparator(true)));
+      cc::FuzzyPixelOffByOneComparator(true)));
 }
 
 // This test tests that forcing anti-aliasing off works as expected for
@@ -4254,6 +4278,10 @@ using FlippedOutputSurfaceRendererTypes =
 #if defined(ENABLE_VIZ_VULKAN_TESTS)
                      ,
                      cc::VulkanSkiaRendererWithFlippedSurface
+#endif
+#if defined(ENABLE_VIZ_DAWN_TESTS)
+                     ,
+                     cc::DawnSkiaRendererWithFlippedSurface
 #endif
                      >;
 
@@ -4926,6 +4954,10 @@ using SkiaRendererTypes = ::testing::Types<SkiaRenderer
 #if defined(ENABLE_VIZ_VULKAN_TESTS)
                                            ,
                                            cc::VulkanSkiaRenderer
+#endif
+#if defined(ENABLE_VIZ_DAWN_TESTS)
+                                           ,
+                                           cc::DawnSkiaRenderer
 #endif
                                            >;
 TYPED_TEST_SUITE(SkiaRendererPixelTestWithOverdrawFeedback, SkiaRendererTypes);

components/viz/service/display/surface_aggregator_pixeltest.cc

@@ -65,6 +65,10 @@ using RendererTypes = ::testing::Types<GLRenderer,
 #ifdef ENABLE_VIZ_VULKAN_TESTS
                                        ,
                                        cc::VulkanSkiaRenderer
+#endif
+#ifdef ENABLE_VIZ_DAWN_TESTS
+                                       ,
+                                       cc::DawnSkiaRenderer
 #endif
                                        >;
 TYPED_TEST_SUITE(SurfaceAggregatorPixelTest, RendererTypes);