Split GPU and OOP raster in cc_unittests

OOP raster isn't available as an option in cc_unittests, except for
Vulkan where it is enabled by default. GPU raster relies on GL, and
shouldn't be used with Vulkan.

Make the difference between GPU raster and OOP raster options explicit,
and clarify some of the messaging which mentions Vulkan and GPU raster.

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

cc/test/layer_tree_pixel_resource_test.cc

@@ -19,7 +19,9 @@ namespace cc {
 
 LayerTreeHostPixelResourceTest::LayerTreeHostPixelResourceTest(
     PixelResourceTestCase test_case)
-    : LayerTreePixelTest(test_case.renderer_type), test_case_(test_case) {}
+    : LayerTreePixelTest(test_case.renderer_type), test_case_(test_case) {
+  set_raster_type(test_case_.raster_type);
+}
 
 const char* LayerTreeHostPixelResourceTest::GetRendererSuffix() const {
   switch (renderer_type_) {
@@ -35,13 +37,6 @@ const char* LayerTreeHostPixelResourceTest::GetRendererSuffix() const {
   }
 }
 
-void LayerTreeHostPixelResourceTest::InitializeSettings(
-    LayerTreeSettings* settings) {
-  LayerTreePixelTest::InitializeSettings(settings);
-  if (raster_type() != GPU)
-    settings->gpu_rasterization_disabled = true;
-}
-
 std::unique_ptr<RasterBufferProvider>
 LayerTreeHostPixelResourceTest::CreateRasterBufferProvider(
     LayerTreeHostImpl* host_impl) {
@@ -75,21 +70,22 @@ LayerTreeHostPixelResourceTest::CreateRasterBufferProvider(
     }
   }
   switch (raster_type()) {
-    case SOFTWARE:
+    case TestRasterType::kBitmap:
       EXPECT_FALSE(compositor_context_provider);
       EXPECT_TRUE(use_software_renderer());
 
       return std::make_unique<BitmapRasterBufferProvider>(
           host_impl->layer_tree_frame_sink());
-    case GPU: {
+    case TestRasterType::kGpu:
+    case TestRasterType::kOop:
       EXPECT_TRUE(compositor_context_provider);
       EXPECT_TRUE(worker_context_provider);
       EXPECT_FALSE(use_software_renderer());
       return std::make_unique<GpuRasterBufferProvider>(
           compositor_context_provider, worker_context_provider, false,
-          gpu_raster_format, gfx::Size(), true, use_oopr());
-    }
-    case ZERO_COPY:
+          gpu_raster_format, gfx::Size(), true,
+          /*enable_oop_rasterization=*/raster_type() == TestRasterType::kOop);
+    case TestRasterType::kZeroCopy:
       EXPECT_TRUE(compositor_context_provider);
       EXPECT_TRUE(gpu_memory_buffer_manager);
       EXPECT_FALSE(use_software_renderer());
@@ -97,7 +93,7 @@ LayerTreeHostPixelResourceTest::CreateRasterBufferProvider(
       return std::make_unique<ZeroCopyRasterBufferProvider>(
           gpu_memory_buffer_manager, compositor_context_provider,
           sw_raster_format);
-    case ONE_COPY:
+    case TestRasterType::kOneCopy:
       EXPECT_TRUE(compositor_context_provider);
       EXPECT_TRUE(worker_context_provider);
       EXPECT_FALSE(use_software_renderer());

cc/test/layer_tree_pixel_resource_test.h

@@ -5,21 +5,16 @@
 #ifndef CC_TEST_LAYER_TREE_PIXEL_RESOURCE_TEST_H_
 #define CC_TEST_LAYER_TREE_PIXEL_RESOURCE_TEST_H_
 
+#include <memory>
+
 #include "base/memory/ref_counted.h"
 #include "cc/test/layer_tree_pixel_test.h"
 
 namespace cc {
 
-enum RasterType {
-  SOFTWARE,
-  GPU,
-  ONE_COPY,
-  ZERO_COPY,
-};
-
 struct PixelResourceTestCase {
   LayerTreeTest::RendererType renderer_type;
-  RasterType raster_type;
+  TestRasterType raster_type;
 };
 
 class LayerTreeHostPixelResourceTest : public LayerTreePixelTest {
@@ -28,12 +23,8 @@ class LayerTreeHostPixelResourceTest : public LayerTreePixelTest {
 
   RendererType renderer_type() const { return test_case_.renderer_type; }
 
-  RasterType raster_type() const { return test_case_.raster_type; }
-
   const char* GetRendererSuffix() const;
 
-  void InitializeSettings(LayerTreeSettings* settings) override;
-
   std::unique_ptr<RasterBufferProvider> CreateRasterBufferProvider(
       LayerTreeHostImpl* host_impl) override;
 

cc/test/layer_tree_pixel_test.cc

@@ -37,9 +37,26 @@ using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
+namespace {
+
+TestRasterType GetDefaultRasterType(LayerTreeTest::RendererType renderer_type) {
+  switch (renderer_type) {
+    case LayerTreeTest::RENDERER_SOFTWARE:
+      return TestRasterType::kBitmap;
+    case LayerTreeTest::RENDERER_SKIA_VK:
+    case LayerTreeTest::RENDERER_SKIA_DAWN:
+      return TestRasterType::kOop;
+    default:
+      return TestRasterType::kOneCopy;
+  }
+}
+
+}  // namespace
+
 LayerTreePixelTest::LayerTreePixelTest(
     LayerTreeTest::RendererType renderer_type)
     : LayerTreeTest(renderer_type),
+      raster_type_(GetDefaultRasterType(renderer_type)),
       pixel_comparator_(new ExactPixelComparator(true)),
       pending_texture_mailbox_callbacks_(0) {}
 
@@ -54,18 +71,14 @@ LayerTreePixelTest::CreateLayerTreeFrameSink(
   scoped_refptr<viz::TestInProcessContextProvider> compositor_context_provider;
   scoped_refptr<viz::TestInProcessContextProvider> worker_context_provider;
   if (!use_software_renderer()) {
-    // Use gpu rasterization when using vulkan.
-    if (use_oopr())
-      DCHECK(gpu_rasterization_);
     compositor_context_provider =
         base::MakeRefCounted<viz::TestInProcessContextProvider>(
-            /*enable_gpu_rasterization=*/gpu_rasterization_,
+            /*enable_gpu_rasterization=*/use_accelerated_raster(),
             /*enable_oop_rasterization=*/false, /*support_locking=*/false);
-    // With vulkan, OOPR has to be enabled.
     worker_context_provider =
         base::MakeRefCounted<viz::TestInProcessContextProvider>(
-            /*enable_gpu_rasterization=*/gpu_rasterization_,
-            /*enable_oop_rasterization=*/use_oopr(),
+            /*enable_gpu_rasterization=*/use_accelerated_raster(),
+            /*enable_oop_rasterization=*/raster_type() == TestRasterType::kOop,
             /*support_locking=*/true);
     // Bind worker context to main thread like it is in production. This is
     // needed to fully initialize the context. Compositor context is bound to
@@ -98,16 +111,25 @@ void LayerTreePixelTest::DrawLayersOnThread(LayerTreeHostImpl* host_impl) {
         host_impl->layer_tree_frame_sink()->context_provider();
     viz::RasterContextProvider* worker_context_provider =
         host_impl->layer_tree_frame_sink()->worker_context_provider();
-    EXPECT_EQ(gpu_rasterization_,
+    EXPECT_EQ(use_accelerated_raster(),
               context_provider->ContextCapabilities().gpu_rasterization);
-    EXPECT_EQ(gpu_rasterization_,
+    EXPECT_EQ(use_accelerated_raster(),
               worker_context_provider->ContextCapabilities().gpu_rasterization);
+    EXPECT_EQ(
+        raster_type() == TestRasterType::kOop,
+        worker_context_provider->ContextCapabilities().supports_oop_raster);
   } else {
-    EXPECT_FALSE(gpu_rasterization_);
+    EXPECT_EQ(TestRasterType::kBitmap, raster_type());
   }
   LayerTreeTest::DrawLayersOnThread(host_impl);
 }
 
+void LayerTreePixelTest::InitializeSettings(LayerTreeSettings* settings) {
+  LayerTreeTest::InitializeSettings(settings);
+  settings->gpu_rasterization_disabled = !use_accelerated_raster();
+  settings->use_zero_copy = raster_type() == TestRasterType::kZeroCopy;
+}
+
 std::unique_ptr<viz::SkiaOutputSurface>
 LayerTreePixelTest::CreateDisplaySkiaOutputSurfaceOnThread() {
   // Set up the SkiaOutputSurfaceImpl.

cc/test/layer_tree_pixel_test.h

@@ -41,6 +41,14 @@ class PixelComparator;
 class SolidColorLayer;
 class TextureLayer;
 
+enum class TestRasterType {
+  kBitmap,
+  kGpu,
+  kOop,
+  kOneCopy,
+  kZeroCopy,
+};
+
 class LayerTreePixelTest : public LayerTreeTest {
  protected:
   explicit LayerTreePixelTest(RendererType renderer_type);
@@ -58,6 +66,7 @@ class LayerTreePixelTest : public LayerTreeTest {
   std::unique_ptr<viz::OutputSurface> CreateDisplayOutputSurfaceOnThread(
       scoped_refptr<viz::ContextProvider> compositor_context_provider) override;
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override;
+  void InitializeSettings(LayerTreeSettings* settings) override;
 
   virtual std::unique_ptr<viz::CopyOutputRequest> CreateCopyOutputRequest();
 
@@ -114,9 +123,18 @@ class LayerTreePixelTest : public LayerTreeTest {
     enlarge_texture_amount_ = enlarge_texture_amount;
   }
 
-  // Gpu rasterization is not used in pixel tests by default, except on Vulkan
-  // where it is required. Tests may opt into using it.
-  void set_gpu_rasterization() { gpu_rasterization_ = true; }
+  // Gpu rasterization is not used in pixel tests by default, and OOP
+  // rasterization is used by default only for Vulkan and Skia Dawn. Tests may
+  // opt into using a different raster mode.
+  void set_raster_type(TestRasterType raster_type) {
+    raster_type_ = raster_type;
+  }
+
+  TestRasterType raster_type() const { return raster_type_; }
+  bool use_accelerated_raster() const {
+    return raster_type_ == TestRasterType::kGpu ||
+           raster_type_ == TestRasterType::kOop;
+  }
 
   // Common CSS colors defined for tests to use.
   static const SkColor kCSSOrange = 0xffffa500;
@@ -125,7 +143,7 @@ class LayerTreePixelTest : public LayerTreeTest {
   static const SkColor kCSSLime = 0xff00ff00;
   static const SkColor kCSSBlack = 0xff000000;
 
-  bool gpu_rasterization_ = use_oopr();
+  TestRasterType raster_type_;
   gl::DisableNullDrawGLBindings enable_pixel_output_;
   std::unique_ptr<PixelComparator> pixel_comparator_;
   scoped_refptr<Layer> content_root_;  // Not used in layer list mode.

cc/test/layer_tree_test.h

@@ -5,6 +5,9 @@
 #ifndef CC_TEST_LAYER_TREE_TEST_H_
 #define CC_TEST_LAYER_TREE_TEST_H_
 
+#include <memory>
+#include <string>
+
 #include "base/memory/ref_counted.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/threading/thread.h"
@@ -223,10 +226,6 @@ class LayerTreeTest : public testing::Test, public TestHooks {
     return renderer_type_ == RENDERER_SOFTWARE;
   }
   bool use_skia_vulkan() const { return renderer_type_ == RENDERER_SKIA_VK; }
-  bool use_oopr() const {
-    return renderer_type_ == RENDERER_SKIA_VK ||
-           renderer_type_ == RENDERER_SKIA_DAWN;
-  }
   bool use_d3d12() const {
 #if defined(OS_WIN)
     return renderer_type_ == RENDERER_SKIA_DAWN;

cc/trees/layer_tree_host_pixeltest_blending.cc

@@ -260,11 +260,11 @@ class LayerTreeHostBlendingPixelTest
 };
 
 std::vector<PixelResourceTestCase> const kTestCases = {
-    {LayerTreeTest::RENDERER_SOFTWARE, SOFTWARE},
-    {LayerTreeTest::RENDERER_GL, ZERO_COPY},
-    {LayerTreeTest::RENDERER_SKIA_GL, GPU},
+    {LayerTreeTest::RENDERER_SOFTWARE, TestRasterType::kBitmap},
+    {LayerTreeTest::RENDERER_GL, TestRasterType::kZeroCopy},
+    {LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kGpu},
 #if defined(ENABLE_CC_VULKAN_TESTS)
-    {LayerTreeTest::RENDERER_SKIA_VK, GPU},
+    {LayerTreeTest::RENDERER_SKIA_VK, TestRasterType::kOop},
 #endif  // defined(ENABLE_CC_VULKAN_TESTS)
 };
 

cc/trees/layer_tree_host_pixeltest_masks.cc

@@ -29,15 +29,16 @@ namespace {
 // TODO(penghuang): Fix vulkan with one copy or zero copy
 // https://crbug.com/979703
 std::vector<PixelResourceTestCase> const kTestCases = {
-    {LayerTreeTest::RENDERER_SOFTWARE, SOFTWARE},
-    {LayerTreeTest::RENDERER_GL, GPU},
-    {LayerTreeTest::RENDERER_GL, ONE_COPY},
-    {LayerTreeTest::RENDERER_GL, ZERO_COPY},
-    {LayerTreeTest::RENDERER_SKIA_GL, GPU},
-    {LayerTreeTest::RENDERER_SKIA_GL, ONE_COPY},
-    {LayerTreeTest::RENDERER_SKIA_GL, ZERO_COPY},
+    {LayerTreeTest::RENDERER_SOFTWARE, TestRasterType::kBitmap},
+    {LayerTreeTest::RENDERER_GL, TestRasterType::kGpu},
+    {LayerTreeTest::RENDERER_GL, TestRasterType::kOneCopy},
+    {LayerTreeTest::RENDERER_GL, TestRasterType::kZeroCopy},
+    {LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kGpu},
+    {LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kOneCopy},
+    {LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kZeroCopy},
 #if defined(ENABLE_CC_VULKAN_TESTS)
-    {LayerTreeTest::RENDERER_SKIA_VK, GPU},
+    {LayerTreeTest::RENDERER_SKIA_VK, TestRasterType::kOop},
+    {LayerTreeTest::RENDERER_SKIA_VK, TestRasterType::kZeroCopy},
 #endif  // defined(ENABLE_CC_VULKAN_TESTS)
 };
 
@@ -575,14 +576,14 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST_P(LayerTreeHostMasksForBackdropFiltersPixelTestWithLayerList, Test) {
   base::FilePath image_name =
-      (raster_type() == GPU)
+      (raster_type() == TestRasterType::kGpu)
           ? base::FilePath(FILE_PATH_LITERAL("mask_of_backdrop_filter_gpu.png"))
           : base::FilePath(FILE_PATH_LITERAL("mask_of_backdrop_filter.png"));
 
-  if (use_skia_vulkan() && raster_type() == GPU) {
-    // Vulkan with GPU raster has 4 pixels errors (the circle mask shape is
-    // slight different).
-    float percentage_pixels_large_error = 0.04f;  // 4px / (100*100)
+  if (use_skia_vulkan() && raster_type() == TestRasterType::kOop) {
+    // Vulkan with OOP raster has 3 pixels errors (the circle mask shape is
+    // slightly different).
+    float percentage_pixels_large_error = 0.031f;  // 3px / (100*100)
     float percentage_pixels_small_error = 0.0f;
     float average_error_allowed_in_bad_pixels = 182.f;
     int large_error_allowed = 182;
@@ -634,14 +635,14 @@ TEST_P(LayerTreeHostMasksForBackdropFiltersPixelTestWithLayerTree, Test) {
   blur->SetMaskLayer(mask);
 
   base::FilePath image_name =
-      (raster_type() == GPU)
+      (raster_type() == TestRasterType::kGpu)
           ? base::FilePath(FILE_PATH_LITERAL("mask_of_backdrop_filter_gpu.png"))
           : base::FilePath(FILE_PATH_LITERAL("mask_of_backdrop_filter.png"));
 
-  if (use_skia_vulkan() && raster_type() == GPU) {
-    // Vulkan with GPU raster has 4 pixels errors (the circle mask shape is
-    // slight different).
-    float percentage_pixels_large_error = 0.04f;  // 4px / (100*100)
+  if (use_skia_vulkan() && raster_type() == TestRasterType::kOop) {
+    // Vulkan with OOP raster has 3 pixels errors (the circle mask shape is
+    // slightly different).
+    float percentage_pixels_large_error = 0.031f;  // 3px / (100*100)
     float percentage_pixels_small_error = 0.0f;
     float average_error_allowed_in_bad_pixels = 182.f;
     int large_error_allowed = 182;
@@ -867,18 +868,23 @@ class LayerTreeHostMaskAsBlendingPixelTest
 };
 
 MaskTestConfig const kTestConfigs[] = {
-    MaskTestConfig{{LayerTreeTest::RENDERER_SOFTWARE, SOFTWARE}, 0},
-    MaskTestConfig{{LayerTreeTest::RENDERER_GL, ZERO_COPY}, 0},
-    MaskTestConfig{{LayerTreeTest::RENDERER_GL, ZERO_COPY}, kUseAntialiasing},
-    MaskTestConfig{{LayerTreeTest::RENDERER_GL, ZERO_COPY}, kForceShaders},
-    MaskTestConfig{{LayerTreeTest::RENDERER_GL, ZERO_COPY},
+    MaskTestConfig{{LayerTreeTest::RENDERER_SOFTWARE, TestRasterType::kBitmap},
+                   0},
+    MaskTestConfig{{LayerTreeTest::RENDERER_GL, TestRasterType::kZeroCopy}, 0},
+    MaskTestConfig{{LayerTreeTest::RENDERER_GL, TestRasterType::kZeroCopy},
+                   kUseAntialiasing},
+    MaskTestConfig{{LayerTreeTest::RENDERER_GL, TestRasterType::kZeroCopy},
+                   kForceShaders},
+    MaskTestConfig{{LayerTreeTest::RENDERER_GL, TestRasterType::kZeroCopy},
                    kUseAntialiasing | kForceShaders},
-    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_GL, ZERO_COPY}, 0},
-    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_GL, ZERO_COPY},
+    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kZeroCopy},
+                   0},
+    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kZeroCopy},
                    kUseAntialiasing},
 #if defined(ENABLE_CC_VULKAN_TESTS)
-    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_VK, ZERO_COPY}, 0},
-    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_VK, ZERO_COPY},
+    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_VK, TestRasterType::kZeroCopy},
+                   0},
+    MaskTestConfig{{LayerTreeTest::RENDERER_SKIA_VK, TestRasterType::kZeroCopy},
                    kUseAntialiasing},
 #endif  // defined(ENABLE_CC_VULKAN_TESTS)
 };
@@ -1021,7 +1027,7 @@ TEST_P(LayerTreeHostMaskAsBlendingPixelTest, RotatedClippedCircle) {
   mask_isolation->AddChild(mask_layer);
 
   base::FilePath image_name =
-      (raster_type() == SOFTWARE)
+      (raster_type() == TestRasterType::kBitmap)
           ? base::FilePath(
                 FILE_PATH_LITERAL("mask_as_blending_rotated_circle.png"))
           : base::FilePath(
@@ -1067,7 +1073,7 @@ TEST_P(LayerTreeHostMaskAsBlendingPixelTest, RotatedClippedCircleUnderflow) {
   mask_isolation->AddChild(mask_layer);
 
   base::FilePath image_name =
-      (raster_type() == SOFTWARE)
+      (raster_type() == TestRasterType::kBitmap)
           ? base::FilePath(FILE_PATH_LITERAL(
                 "mask_as_blending_rotated_circle_underflow.png"))
           : base::FilePath(FILE_PATH_LITERAL(
@@ -1135,7 +1141,7 @@ INSTANTIATE_TEST_SUITE_P(PixelResourceTest,
 TEST_P(LayerTreeHostMasksForBackdropFiltersAndBlendPixelTest, Test) {
   base::FilePath result_path(
       FILE_PATH_LITERAL("mask_of_backdrop_filter_and_blend_.png"));
-  if (raster_type() != GPU) {
+  if (!use_accelerated_raster()) {
     result_path = result_path.InsertBeforeExtensionASCII("sw");
   } else {
     result_path = result_path.InsertBeforeExtensionASCII(GetRendererSuffix());

cc/trees/layer_tree_host_pixeltest_synchronous.cc

@@ -24,7 +24,6 @@ class LayerTreeHostSynchronousPixelTest
   void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreePixelTest::InitializeSettings(settings);
     settings->single_thread_proxy_scheduler = false;
-    settings->use_zero_copy = use_zero_copy_;
   }
 
   RendererType renderer_type() const { return GetParam(); }
@@ -49,8 +48,6 @@ class LayerTreeHostSynchronousPixelTest
     RunSingleThreadedPixelTest(root,
                                base::FilePath(FILE_PATH_LITERAL("green.png")));
   }
-
-  bool use_zero_copy_ = false;
 };
 
 LayerTreeTest::RendererType const kRendererTypesGpu[] = {
@@ -66,12 +63,12 @@ INSTANTIATE_TEST_SUITE_P(All,
                          ::testing::ValuesIn(kRendererTypesGpu));
 
 TEST_P(LayerTreeHostSynchronousPixelTest, OneContentLayerZeroCopy) {
-  use_zero_copy_ = true;
+  set_raster_type(TestRasterType::kZeroCopy);
   DoContentLayerTest();
 }
 
 TEST_P(LayerTreeHostSynchronousPixelTest, OneContentLayerGpuRasterization) {
-  set_gpu_rasterization();
+  set_raster_type(TestRasterType::kGpu);
   DoContentLayerTest();
 }
 

cc/trees/layer_tree_host_pixeltest_tiles.cc

@@ -20,16 +20,9 @@
 namespace cc {
 namespace {
 
-enum RasterMode {
-  BITMAP,
-  ONE_COPY,
-  GPU,
-  GPU_LOW_BIT_DEPTH,
-};
-
 struct TilesTestConfig {
   LayerTreeTest::RendererType renderer_type;
-  RasterMode raster_mode;
+  TestRasterType raster_type;
 };
 
 class LayerTreeHostTilesPixelTest
@@ -37,33 +30,13 @@ class LayerTreeHostTilesPixelTest
       public ::testing::WithParamInterface<TilesTestConfig> {
  protected:
   LayerTreeHostTilesPixelTest() : LayerTreePixelTest(renderer_type()) {
-    switch (raster_mode()) {
-      case GPU:
-      case GPU_LOW_BIT_DEPTH:
-        set_gpu_rasterization();
-        break;
-      default:
-        break;
-    }
+    set_raster_type(GetParam().raster_type);
   }
 
   RendererType renderer_type() const { return GetParam().renderer_type; }
 
-  RasterMode raster_mode() const { return GetParam().raster_mode; }
-
   void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreePixelTest::InitializeSettings(settings);
-    switch (raster_mode()) {
-      case ONE_COPY:
-        settings->use_zero_copy = false;
-        break;
-      case GPU_LOW_BIT_DEPTH:
-        settings->use_rgba_4444 = true;
-        settings->unpremultiply_and_dither_low_bit_depth_tiles = true;
-        break;
-      default:
-        break;
-    }
 
     settings->use_partial_raster = use_partial_raster_;
   }
@@ -180,14 +153,13 @@ class LayerTreeHostTilesTestPartialInvalidation
 };
 
 std::vector<TilesTestConfig> const kTestCases = {
-    {LayerTreeTest::RENDERER_SOFTWARE, BITMAP},
-    {LayerTreeTest::RENDERER_GL, ONE_COPY},
-    {LayerTreeTest::RENDERER_GL, GPU},
-    {LayerTreeTest::RENDERER_SKIA_GL, ONE_COPY},
-    {LayerTreeTest::RENDERER_SKIA_GL, GPU},
+    {LayerTreeTest::RENDERER_SOFTWARE, TestRasterType::kBitmap},
+    {LayerTreeTest::RENDERER_GL, TestRasterType::kOneCopy},
+    {LayerTreeTest::RENDERER_GL, TestRasterType::kGpu},
+    {LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kOneCopy},
+    {LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kGpu},
 #if defined(ENABLE_CC_VULKAN_TESTS)
-    {LayerTreeTest::RENDERER_SKIA_VK, ONE_COPY},
-    {LayerTreeTest::RENDERER_SKIA_VK, GPU},
+    {LayerTreeTest::RENDERER_SKIA_VK, TestRasterType::kOop},
 #endif  // defined(ENABLE_CC_VULKAN_TESTS)
 };
 
@@ -216,10 +188,12 @@ TEST_P(LayerTreeHostTilesTestPartialInvalidation, FullRaster) {
 }
 
 std::vector<TilesTestConfig> const kTestCasesMultiThread = {
-    {LayerTreeTest::RENDERER_GL, ONE_COPY},
-    {LayerTreeTest::RENDERER_SKIA_GL, ONE_COPY},
+    {LayerTreeTest::RENDERER_GL, TestRasterType::kOneCopy},
+    {LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kOneCopy},
 #if defined(ENABLE_CC_VULKAN_TESTS)
-    {LayerTreeTest::RENDERER_SKIA_VK, ONE_COPY},
+    // TODO(sgilhuly): Switch this to one copy raster once is is supported for
+    // Vulkan in these tests.
+    {LayerTreeTest::RENDERER_SKIA_VK, TestRasterType::kOop},
 #endif  // defined(ENABLE_CC_VULKAN_TESTS)
 };
 
@@ -253,8 +227,15 @@ TEST_P(LayerTreeHostTilesTestPartialInvalidationMultiThread, FullRaster) {
                base::FilePath(FILE_PATH_LITERAL("blue_yellow_flipped.png")));
 }
 
-using LayerTreeHostTilesTestPartialInvalidationLowBitDepth =
-    LayerTreeHostTilesTestPartialInvalidation;
+class LayerTreeHostTilesTestPartialInvalidationLowBitDepth
+    : public LayerTreeHostTilesTestPartialInvalidation {
+ protected:
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    LayerTreeHostTilesPixelTest::InitializeSettings(settings);
+    settings->use_rgba_4444 = true;
+    settings->unpremultiply_and_dither_low_bit_depth_tiles = true;
+  }
+};
 
 // This test doesn't work on Vulkan because on our hardware we can't render to
 // RGBA4444 format using either SwiftShader or native Vulkan. See
@@ -263,8 +244,8 @@ INSTANTIATE_TEST_SUITE_P(
     All,
     LayerTreeHostTilesTestPartialInvalidationLowBitDepth,
     ::testing::Values(
-        TilesTestConfig{LayerTreeTest::RENDERER_SKIA_GL, GPU_LOW_BIT_DEPTH},
-        TilesTestConfig{LayerTreeTest::RENDERER_GL, GPU_LOW_BIT_DEPTH}));
+        TilesTestConfig{LayerTreeTest::RENDERER_SKIA_GL, TestRasterType::kGpu},
+        TilesTestConfig{LayerTreeTest::RENDERER_GL, TestRasterType::kGpu}));
 
 TEST_P(LayerTreeHostTilesTestPartialInvalidationLowBitDepth, PartialRaster) {
   use_partial_raster_ = true;