Handle RGBA_4444 scales in > max texture size images

cc/tiles/gpu_image_decode_cache_unittest.cc

 // Copyright 2016 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/tiles/gpu_image_decode_cache.h"
 
 #include "cc/paint/draw_image.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_tile_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkImageGenerator.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace cc {
 namespace {
 
 gfx::ColorSpace DefaultColorSpace() {
   return gfx::ColorSpace::CreateSRGB();
 }
 
 PaintImage::Id s_paint_image_id = PaintImage::GetNextId();
 
 PaintImage CreatePaintImage(sk_sp<SkImage> image) {
   return PaintImage(s_paint_image_id, image);
 }
 
 size_t kGpuMemoryLimitBytes = 96 * 1024 * 1024;
 class TestGpuImageDecodeCache : public GpuImageDecodeCache {
  public:
-  explicit TestGpuImageDecodeCache(ContextProvider* context)
+  explicit TestGpuImageDecodeCache(ContextProvider* context,
+                                   ResourceFormat format)
       : GpuImageDecodeCache(context,
-                            ResourceFormat::RGBA_8888,
+                            format,
                             kGpuMemoryLimitBytes,
                             kGpuMemoryLimitBytes) {}
 };
 
+class TestImageGenerator : public SkImageGenerator {
+ public:
+  explicit TestImageGenerator(const SkImageInfo& info)
+      : SkImageGenerator(info),
+        image_backing_memory_(info.getSafeSize(info.minRowBytes()), 0),
+        image_pixmap_(info, image_backing_memory_.data(), info.minRowBytes()) {}
+
+ protected:
+  bool onGetPixels(const SkImageInfo& info,
+                   void* pixels,
+                   size_t rowBytes,
+                   const Options&) override {
+    return image_pixmap_.readPixels(info, pixels, rowBytes, 0, 0);
+  }
+
+ private:
+  std::vector<uint8_t> image_backing_memory_;
+  SkPixmap image_pixmap_;
+};
+
 sk_sp<SkImage> CreateImage(int width, int height) {
-  SkBitmap bitmap;
   gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB();
-  bitmap.allocPixels(
-      SkImageInfo::MakeN32Premul(width, height, color_space.ToSkColorSpace()));
-  bitmap.eraseColor(0);
-  return SkImage::MakeFromBitmap(bitmap);
+  std::unique_ptr<TestImageGenerator> generator(new TestImageGenerator(
+      SkImageInfo::MakeN32Premul(width, height, color_space.ToSkColorSpace())));
+  return SkImage::MakeFromGenerator(std::move(generator));
 }
 
 SkMatrix CreateMatrix(const SkSize& scale, bool is_decomposable) {
   SkMatrix matrix;
   matrix.setScale(scale.width(), scale.height());
 
   if (!is_decomposable) {
     // Perspective is not decomposable, add it.
     matrix[SkMatrix::kMPersp0] = 0.1f;
   }
 
   return matrix;
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageSameImage) {
+using GpuImageDecodeCacheTest = ::testing::TestWithParam<ResourceFormat>;
+
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageSameImage) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 11 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task.get() == another_task.get());
 
   TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(task.get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageSmallerScale) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageSmallerScale) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 11 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task.get() == another_task.get());
 
   TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(task.get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(another_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageLowerQuality) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageLowerQuality) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable);
 
   DrawImage draw_image(CreatePaintImage(image),
                        SkIRect::MakeWH(image->width(), image->height()),
                        kHigh_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
 
   DrawImage another_draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       kLow_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> another_task;
   need_unref = cache.GetTaskForImageAndRef(
       another_draw_image, ImageDecodeCache::TracingInfo(), &another_task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task.get() == another_task.get());
 
   TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(task.get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(another_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageDifferentImage) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageDifferentImage) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       CreatePaintImage(first_image),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> first_task;
@@ skipping 17 matching lines @@
 
   TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(first_task.get());
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(first_draw_image);
   cache.UnrefImage(second_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScale) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageLargerScale) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       CreatePaintImage(first_image),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> first_task;
@@ skipping 30 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(third_task.get() == second_task.get());
 
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(second_draw_image);
   cache.UnrefImage(third_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScaleNoReuse) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageLargerScaleNoReuse) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       CreatePaintImage(first_image),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> first_task;
@@ skipping 28 matching lines @@
   TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(first_task.get());
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(first_draw_image);
   cache.UnrefImage(second_draw_image);
   cache.UnrefImage(third_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageHigherQuality) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageHigherQuality) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable);
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       CreatePaintImage(first_image),
       SkIRect::MakeWH(first_image->width(), first_image->height()),
       kLow_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> first_task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 16 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(second_task);
   EXPECT_TRUE(first_task.get() != second_task.get());
 
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(second_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedAndLocked) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedAndLocked) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 22 matching lines @@
 
   TestTileTaskRunner::ProcessTask(another_task.get());
 
   // Finally, complete the original decode task.
   TestTileTaskRunner::CompleteTask(task->dependencies()[0].get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedNotLocked) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedNotLocked) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 22 matching lines @@
   EXPECT_TRUE(another_task);
   EXPECT_EQ(another_task->dependencies().size(), 1u);
   EXPECT_TRUE(task->dependencies()[0]);
 
   TestTileTaskRunner::ProcessTask(another_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(another_task.get());
 
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyUploaded) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageAlreadyUploaded) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 12 matching lines @@
       draw_image, ImageDecodeCache::TracingInfo(), &another_task);
   EXPECT_TRUE(need_unref);
   EXPECT_FALSE(another_task);
 
   TestTileTaskRunner::CompleteTask(task.get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 24 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(third_task);
   EXPECT_FALSE(third_task.get() == task.get());
 
   TestTileTaskRunner::ProcessTask(third_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(third_task.get());
 
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledWhileReffedGetsNewTask) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageCanceledWhileReffedGetsNewTask) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 28 matching lines @@
   EXPECT_FALSE(third_task.get() == task.get());
 
   ASSERT_GT(third_task->dependencies().size(), 0u);
   TestTileTaskRunner::ProcessTask(third_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(third_task.get());
 
   // Unref!
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, NoTaskForImageAlreadyFailedDecoding) {
+TEST_P(GpuImageDecodeCacheTest, NoTaskForImageAlreadyFailedDecoding) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 10 matching lines @@
 
   scoped_refptr<TileTask> another_task;
   need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &another_task);
   EXPECT_FALSE(need_unref);
   EXPECT_EQ(another_task.get(), nullptr);
 
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDraw) {
+TEST_P(GpuImageDecodeCacheTest, GetDecodedImageForDraw) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 11 matching lines @@
       cache.GetDecodedImageForDraw(draw_image);
   EXPECT_TRUE(decoded_draw_image.image());
   EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetLargeDecodedImageForDraw) {
+TEST_P(GpuImageDecodeCacheTest, GetLargeDecodedImageForDraw) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(1, 24000);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 12 matching lines @@
   EXPECT_TRUE(decoded_draw_image.image());
   EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
   EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) {
+TEST_P(GpuImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   cache.SetAllByteLimitsForTesting(0);
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable),
       DefaultColorSpace());
@@ skipping 10 matching lines @@
   DecodedDrawImage decoded_draw_image =
       cache.GetDecodedImageForDraw(draw_image);
   EXPECT_TRUE(decoded_draw_image.image());
   EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawLargerScale) {
+TEST_P(GpuImageDecodeCacheTest, GetDecodedImageForDrawLargerScale) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 35 matching lines @@
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 
   EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image());
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
   cache.DrawWithImageFinished(larger_draw_image, larger_decoded_draw_image);
   cache.UnrefImage(larger_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawHigherQuality) {
+TEST_P(GpuImageDecodeCacheTest, GetDecodedImageForDrawHigherQuality) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable);
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(CreatePaintImage(image),
                        SkIRect::MakeWH(image->width(), image->height()),
                        kLow_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
@@ skipping 34 matching lines @@
 
   EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image());
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
   cache.DrawWithImageFinished(higher_quality_draw_image,
                               larger_decoded_draw_image);
   cache.UnrefImage(higher_quality_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawNegative) {
+TEST_P(GpuImageDecodeCacheTest, GetDecodedImageForDrawNegative) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(-0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 13 matching lines @@
   EXPECT_EQ(decoded_draw_image.image()->width(), 50);
   EXPECT_EQ(decoded_draw_image.image()->height(), 50);
   EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetLargeScaledDecodedImageForDraw) {
+TEST_P(GpuImageDecodeCacheTest, GetLargeScaledDecodedImageForDraw) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(1, 48000);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 15 matching lines @@
   EXPECT_EQ(24000, decoded_draw_image.image()->height());
   EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
   EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, AtRasterUsedDirectlyIfSpaceAllows) {
+TEST_P(GpuImageDecodeCacheTest, AtRasterUsedDirectlyIfSpaceAllows) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   cache.SetAllByteLimitsForTesting(0);
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
@@ skipping 21 matching lines @@
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
 
   scoped_refptr<TileTask> another_task;
   bool another_task_needs_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
   EXPECT_TRUE(another_task_needs_unref);
   EXPECT_FALSE(another_task);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest,
-     GetDecodedImageForDrawAtRasterDecodeMultipleTimes) {
+TEST_P(GpuImageDecodeCacheTest,
+       GetDecodedImageForDrawAtRasterDecodeMultipleTimes) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   cache.SetAllByteLimitsForTesting(0);
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
@@ skipping 10 matching lines @@
 
   DecodedDrawImage another_decoded_draw_image =
       cache.GetDecodedImageForDraw(draw_image);
   EXPECT_EQ(decoded_draw_image.image()->uniqueID(),
             another_decoded_draw_image.image()->uniqueID());
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.DrawWithImageFinished(draw_image, another_decoded_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest,
-     GetLargeDecodedImageForDrawAtRasterDecodeMultipleTimes) {
+TEST_P(GpuImageDecodeCacheTest,
+       GetLargeDecodedImageForDrawAtRasterDecodeMultipleTimes) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(1, 24000);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable),
       DefaultColorSpace());
 
   // Must hold context lock before calling GetDecodedImageForDraw /
@@ skipping 13 matching lines @@
       cache.GetDecodedImageForDraw(draw_image);
   EXPECT_TRUE(second_decoded_draw_image.image());
   EXPECT_FALSE(second_decoded_draw_image.image()->isTextureBacked());
   EXPECT_TRUE(second_decoded_draw_image.is_at_raster_decode());
   EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, second_decoded_draw_image);
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, ZeroSizedImagesAreSkipped) {
+TEST_P(GpuImageDecodeCacheTest, ZeroSizedImagesAreSkipped) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable),
       DefaultColorSpace());
 
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
   EXPECT_FALSE(task);
   EXPECT_FALSE(need_unref);
 
   // Must hold context lock before calling GetDecodedImageForDraw /
   // DrawWithImageFinished.
   ContextProvider::ScopedContextLock context_lock(context_provider.get());
   DecodedDrawImage decoded_draw_image =
       cache.GetDecodedImageForDraw(draw_image);
   EXPECT_FALSE(decoded_draw_image.image());
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) {
+TEST_P(GpuImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image),
       SkIRect::MakeXYWH(150, 150, image->width(), image->height()), quality,
       CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable),
       DefaultColorSpace());
 
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
   EXPECT_FALSE(task);
   EXPECT_FALSE(need_unref);
 
   // Must hold context lock before calling GetDecodedImageForDraw /
   // DrawWithImageFinished.
   ContextProvider::ScopedContextLock context_lock(context_provider.get());
   DecodedDrawImage decoded_draw_image =
       cache.GetDecodedImageForDraw(draw_image);
   EXPECT_FALSE(decoded_draw_image.image());
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, CanceledTasksDoNotCountAgainstBudget) {
+TEST_P(GpuImageDecodeCacheTest, CanceledTasksDoNotCountAgainstBudget) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(CreatePaintImage(image),
                        SkIRect::MakeXYWH(0, 0, image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable),
                        DefaultColorSpace());
 
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
   EXPECT_NE(0u, cache.GetBytesUsedForTesting());
   EXPECT_TRUE(task);
   EXPECT_TRUE(need_unref);
 
   TestTileTaskRunner::CancelTask(task->dependencies()[0].get());
   TestTileTaskRunner::CompleteTask(task->dependencies()[0].get());
   TestTileTaskRunner::CancelTask(task.get());
   TestTileTaskRunner::CompleteTask(task.get());
 
   cache.UnrefImage(draw_image);
   EXPECT_EQ(0u, cache.GetBytesUsedForTesting());
 }
 
-TEST(GpuImageDecodeCacheTest, ShouldAggressivelyFreeResources) {
+TEST_P(GpuImageDecodeCacheTest, ShouldAggressivelyFreeResources) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
   {
@@ skipping 40 matching lines @@
     EXPECT_TRUE(task);
 
     TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
     TestTileTaskRunner::ProcessTask(task.get());
     cache.UnrefImage(draw_image);
 
     EXPECT_GT(cache.GetBytesUsedForTesting(), 0u);
   }
 }
 
-TEST(GpuImageDecodeCacheTest, OrphanedImagesFreeOnReachingZeroRefs) {
+TEST_P(GpuImageDecodeCacheTest, OrphanedImagesFreeOnReachingZeroRefs) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   // Create a downscaled image.
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       CreatePaintImage(first_image),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
@@ skipping 35 matching lines @@
   // deleted.
   TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(first_task.get());
   cache.UnrefImage(first_draw_image);
 
   // The budget should account for exactly one image.
   EXPECT_EQ(cache.GetBytesUsedForTesting(),
             cache.GetDrawImageSizeForTesting(second_draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, OrphanedZeroRefImagesImmediatelyDeleted) {
+TEST_P(GpuImageDecodeCacheTest, OrphanedZeroRefImagesImmediatelyDeleted) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   // Create a downscaled image.
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       CreatePaintImage(first_image),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
       CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
       DefaultColorSpace());
@@ skipping 28 matching lines @@
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(second_draw_image);
 
   // The budget should account for exactly one image.
   EXPECT_EQ(cache.GetBytesUsedForTesting(),
             cache.GetDrawImageSizeForTesting(second_draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, QualityCappedAtMedium) {
+TEST_P(GpuImageDecodeCacheTest, QualityCappedAtMedium) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable);
 
   // Create an image with kLow_FilterQuality.
   DrawImage low_draw_image(CreatePaintImage(image),
                            SkIRect::MakeWH(image->width(), image->height()),
                            kLow_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> low_task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 28 matching lines @@
   TestTileTaskRunner::ProcessTask(medium_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(medium_task.get());
 
   cache.UnrefImage(low_draw_image);
   cache.UnrefImage(medium_draw_image);
   cache.UnrefImage(large_draw_image);
 }
 
 // Ensure that switching to a mipped version of an image after the initial
 // cache entry creation doesn't cause a buffer overflow/crash.
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawMipUsageChange) {
+TEST_P(GpuImageDecodeCacheTest, GetDecodedImageForDrawMipUsageChange) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   // Create an image decode task and cache entry that does not need mips.
   sk_sp<SkImage> image = CreateImage(4000, 4000);
   DrawImage draw_image(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable),
       DefaultColorSpace());
   scoped_refptr<TileTask> task;
@@ skipping 17 matching lines @@
   // Do an at-raster decode of the above image that *does* require mips.
   DrawImage draw_image_mips(
       CreatePaintImage(image), SkIRect::MakeWH(image->width(), image->height()),
       quality, CreateMatrix(SkSize::Make(0.6f, 0.6f), is_decomposable),
       DefaultColorSpace());
   DecodedDrawImage decoded_draw_image =
       cache.GetDecodedImageForDraw(draw_image_mips);
   cache.DrawWithImageFinished(draw_image_mips, decoded_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, MemoryStateSuspended) {
+TEST_P(GpuImageDecodeCacheTest, MemoryStateSuspended) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
 
   // First Insert an image into our cache.
   sk_sp<SkImage> image = CreateImage(1, 1);
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable);
   DrawImage draw_image(CreatePaintImage(image),
                        SkIRect::MakeWH(image->width(), image->height()),
                        kLow_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> task;
   bool need_unref = cache.GetTaskForImageAndRef(
@@ skipping 47 matching lines @@
   need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
 
   TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(task.get());
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, OutOfRasterDecodeTask) {
+TEST_P(GpuImageDecodeCacheTest, OutOfRasterDecodeTask) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
 
   sk_sp<SkImage> image = CreateImage(1, 1);
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable);
   DrawImage draw_image(CreatePaintImage(image),
                        SkIRect::MakeWH(image->width(), image->height()),
                        kLow_SkFilterQuality, matrix, DefaultColorSpace());
 
   scoped_refptr<TileTask> task;
   bool need_unref =
       cache.GetOutOfRasterDecodeTaskForImageAndRef(draw_image, &task);
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task);
   EXPECT_TRUE(cache.IsInInUseCacheForTesting(draw_image));
 
   // Run the decode task.
   TestTileTaskRunner::ProcessTask(task.get());
 
   // The image should remain in the cache till we unref it.
   EXPECT_TRUE(cache.IsInInUseCacheForTesting(draw_image));
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, ZeroCacheNormalWorkingSet) {
+TEST_P(GpuImageDecodeCacheTest, ZeroCacheNormalWorkingSet) {
   // Setup - Image cache has a normal working set, but zero cache size.
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   GpuImageDecodeCache cache(context_provider.get(), ResourceFormat::RGBA_8888,
                             kGpuMemoryLimitBytes, 0);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   // Add an image to the cache. Due to normal working set, this should produce
   // a task and a ref.
@@ skipping 34 matching lines @@
   EXPECT_TRUE(task3);
   EXPECT_EQ(task3->dependencies().size(), 1u);
   EXPECT_TRUE(task->dependencies()[0]);
 
   TestTileTaskRunner::ProcessTask(task3->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(task3.get());
 
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, SmallCacheNormalWorkingSet) {
+TEST_P(GpuImageDecodeCacheTest, SmallCacheNormalWorkingSet) {
   // Cache will fit one (but not two) 100x100 images.
   size_t cache_size = 190 * 100 * 4;
 
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   GpuImageDecodeCache cache(context_provider.get(), ResourceFormat::RGBA_8888,
                             kGpuMemoryLimitBytes, cache_size);
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
@@ skipping 73 matching lines @@
     EXPECT_EQ(task->dependencies().size(), 1u);
     EXPECT_TRUE(task->dependencies()[0]);
 
     // Run the task and unref the image.
     TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
     TestTileTaskRunner::ProcessTask(task.get());
     cache.UnrefImage(draw_image);
   }
 }
 
-TEST(GpuImageDecodeCacheTest, ClearCache) {
+TEST_P(GpuImageDecodeCacheTest, ClearCache) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   for (int i = 0; i < 10; ++i) {
     sk_sp<SkImage> image = CreateImage(100, 100);
     DrawImage draw_image(
         CreatePaintImage(image),
         SkIRect::MakeWH(image->width(), image->height()), quality,
         CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable),
         DefaultColorSpace());
@@ skipping 12 matching lines @@
   EXPECT_EQ(cache.GetNumCacheEntriesForTesting(), 10u);
 
   // Tell our cache to clear resources.
   cache.ClearCache();
 
   // We should now have nothing in our cache.
   EXPECT_EQ(cache.GetBytesUsedForTesting(), 0u);
   EXPECT_EQ(cache.GetNumCacheEntriesForTesting(), 0u);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageDifferentColorSpace) {
+TEST_P(GpuImageDecodeCacheTest, GetTaskForImageDifferentColorSpace) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
-  TestGpuImageDecodeCache cache(context_provider.get());
+  TestGpuImageDecodeCache cache(context_provider.get(), GetParam());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   gfx::ColorSpace color_space_a = gfx::ColorSpace::CreateSRGB();
   gfx::ColorSpace color_space_b = gfx::ColorSpace::CreateXYZD50();
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       CreatePaintImage(first_image),
       SkIRect::MakeWH(first_image->width(), first_image->height()), quality,
@@ skipping 28 matching lines @@
   TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(first_task.get());
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(first_draw_image);
   cache.UnrefImage(second_draw_image);
   cache.UnrefImage(third_draw_image);
 }
 
+INSTANTIATE_TEST_CASE_P(GpuImageDecodeCacheTests,
+                        GpuImageDecodeCacheTest,
+                        ::testing::Values(ResourceFormat::RGBA_8888,
+                                          ResourceFormat::RGBA_4444));
+
 }  // namespace
 }  // namespace cc