Index: cc/tiles/gpu_image_decode_cache_unittest.cc |
diff --git a/cc/tiles/gpu_image_decode_controller_unittest.cc b/cc/tiles/gpu_image_decode_cache_unittest.cc |
similarity index 66% |
rename from cc/tiles/gpu_image_decode_controller_unittest.cc |
rename to cc/tiles/gpu_image_decode_cache_unittest.cc |
index feea99efcbf7f85ba73aa5339c0d87b4ae394c1f..072dfd91d9f2d7355c433f0b5caae8bcec893a97 100644 |
--- a/cc/tiles/gpu_image_decode_controller_unittest.cc |
+++ b/cc/tiles/gpu_image_decode_cache_unittest.cc |
@@ -2,7 +2,7 @@ |
// 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_controller.h" |
+#include "cc/tiles/gpu_image_decode_cache.h" |
#include "cc/playback/draw_image.h" |
#include "cc/test/test_context_provider.h" |
@@ -14,12 +14,12 @@ namespace cc { |
namespace { |
size_t kGpuMemoryLimitBytes = 96 * 1024 * 1024; |
-class TestGpuImageDecodeController : public GpuImageDecodeController { |
+class TestGpuImageDecodeCache : public GpuImageDecodeCache { |
public: |
- explicit TestGpuImageDecodeController(ContextProvider* context) |
- : GpuImageDecodeController(context, |
- ResourceFormat::RGBA_8888, |
- kGpuMemoryLimitBytes) {} |
+ explicit TestGpuImageDecodeCache(ContextProvider* context) |
+ : GpuImageDecodeCache(context, |
+ ResourceFormat::RGBA_8888, |
+ kGpuMemoryLimitBytes) {} |
}; |
sk_sp<SkImage> CreateImage(int width, int height) { |
@@ -40,10 +40,10 @@ SkMatrix CreateMatrix(const SkSize& scale, bool is_decomposable) { |
return matrix; |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageSameImage) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageSameImage) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
sk_sp<SkImage> image = CreateImage(100, 100); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -52,8 +52,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageSameImage) { |
quality, |
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -61,22 +61,22 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageSameImage) { |
image, SkIRect::MakeWH(image->width(), image->height()), quality, |
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- another_draw_image, ImageDecodeController::TracingInfo(), &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()); |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageSmallerScale) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageSmallerScale) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
sk_sp<SkImage> image = CreateImage(100, 100); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -85,8 +85,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageSmallerScale) { |
quality, |
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -94,22 +94,22 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageSmallerScale) { |
image, SkIRect::MakeWH(image->width(), image->height()), quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- another_draw_image, ImageDecodeController::TracingInfo(), &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()); |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(another_draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(another_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageLowerQuality) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageLowerQuality) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
sk_sp<SkImage> image = CreateImage(100, 100); |
bool is_decomposable = true; |
SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); |
@@ -117,8 +117,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLowerQuality) { |
DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
kHigh_SkFilterQuality, matrix); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -126,22 +126,22 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLowerQuality) { |
SkIRect::MakeWH(image->width(), image->height()), |
kLow_SkFilterQuality, matrix); |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- another_draw_image, ImageDecodeController::TracingInfo(), &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()); |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(another_draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(another_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageDifferentImage) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -150,8 +150,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> first_task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- first_draw_image, ImageDecodeController::TracingInfo(), &first_task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(first_task); |
@@ -161,8 +161,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
SkIRect::MakeWH(second_image->width(), second_image->height()), quality, |
CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable)); |
scoped_refptr<TileTask> second_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(second_task); |
EXPECT_TRUE(first_task.get() != second_task.get()); |
@@ -172,14 +172,14 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageDifferentImage) { |
TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(second_task.get()); |
- controller.UnrefImage(first_draw_image); |
- controller.UnrefImage(second_draw_image); |
+ cache.UnrefImage(first_draw_image); |
+ cache.UnrefImage(second_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScale) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScale) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -188,22 +188,22 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScale) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> first_task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- first_draw_image, ImageDecodeController::TracingInfo(), &first_task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(first_task); |
TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(first_task.get()); |
- controller.UnrefImage(first_draw_image); |
+ cache.UnrefImage(first_draw_image); |
DrawImage second_draw_image( |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); |
scoped_refptr<TileTask> second_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(second_task); |
EXPECT_TRUE(first_task.get() != second_task.get()); |
@@ -212,22 +212,22 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScale) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> third_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- third_draw_image, ImageDecodeController::TracingInfo(), &third_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(third_task.get() == second_task.get()); |
TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(second_task.get()); |
- controller.UnrefImage(second_draw_image); |
- controller.UnrefImage(third_draw_image); |
+ cache.UnrefImage(second_draw_image); |
+ cache.UnrefImage(third_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScaleNoReuse) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScaleNoReuse) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -236,8 +236,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScaleNoReuse) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> first_task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- first_draw_image, ImageDecodeController::TracingInfo(), &first_task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(first_task); |
@@ -245,8 +245,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScaleNoReuse) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); |
scoped_refptr<TileTask> second_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(second_task); |
EXPECT_TRUE(first_task.get() != second_task.get()); |
@@ -255,8 +255,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScaleNoReuse) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> third_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- third_draw_image, ImageDecodeController::TracingInfo(), &third_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ third_draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(third_task.get() == first_task.get()); |
@@ -265,15 +265,15 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageLargerScaleNoReuse) { |
TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(second_task.get()); |
- controller.UnrefImage(first_draw_image); |
- controller.UnrefImage(second_draw_image); |
- controller.UnrefImage(third_draw_image); |
+ cache.UnrefImage(first_draw_image); |
+ cache.UnrefImage(second_draw_image); |
+ cache.UnrefImage(third_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageHigherQuality) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageHigherQuality) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); |
@@ -282,22 +282,22 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageHigherQuality) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
kLow_SkFilterQuality, matrix); |
scoped_refptr<TileTask> first_task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- first_draw_image, ImageDecodeController::TracingInfo(), &first_task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(first_task); |
TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(first_task.get()); |
- controller.UnrefImage(first_draw_image); |
+ cache.UnrefImage(first_draw_image); |
DrawImage second_draw_image( |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
kHigh_SkFilterQuality, matrix); |
scoped_refptr<TileTask> second_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(second_task); |
EXPECT_TRUE(first_task.get() != second_task.get()); |
@@ -305,13 +305,13 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageHigherQuality) { |
TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(second_task.get()); |
- controller.UnrefImage(second_draw_image); |
+ cache.UnrefImage(second_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedAndLocked) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedAndLocked) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -320,8 +320,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedAndLocked) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
EXPECT_EQ(task->dependencies().size(), 1u); |
@@ -338,8 +338,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedAndLocked) { |
// Get the image again - we should have an upload task, but no dependent |
// decode task, as the decode was already locked. |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &another_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(another_task); |
EXPECT_EQ(another_task->dependencies().size(), 0u); |
@@ -349,14 +349,14 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedAndLocked) { |
// Finally, complete the original decode task. |
TestTileTaskRunner::CompleteTask(task->dependencies()[0].get()); |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedNotLocked) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedNotLocked) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -365,8 +365,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedNotLocked) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
EXPECT_EQ(task->dependencies().size(), 1u); |
@@ -380,13 +380,13 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedNotLocked) { |
TestTileTaskRunner::CompleteTask(task.get()); |
// Unref the image. |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
// Get the image again - we should have an upload task and a dependent decode |
// task - this dependent task will typically just re-lock the image. |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &another_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(another_task); |
EXPECT_EQ(another_task->dependencies().size(), 1u); |
@@ -395,13 +395,13 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyDecodedNotLocked) { |
TestTileTaskRunner::ProcessTask(another_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(another_task.get()); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyUploaded) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyUploaded) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -410,8 +410,8 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyUploaded) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
EXPECT_EQ(task->dependencies().size(), 1u); |
@@ -422,21 +422,21 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageAlreadyUploaded) { |
TestTileTaskRunner::RunTask(task.get()); |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &another_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
EXPECT_TRUE(need_unref); |
EXPECT_FALSE(another_task); |
TestTileTaskRunner::CompleteTask(task.get()); |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -445,16 +445,16 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &another_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(another_task.get() == task.get()); |
@@ -463,13 +463,13 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { |
TestTileTaskRunner::CompleteTask(task.get()); |
// Fully cancel everything (so the raster would unref things). |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
// Here a new task is created. |
scoped_refptr<TileTask> third_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &third_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(third_task); |
EXPECT_FALSE(third_task.get() == task.get()); |
@@ -477,14 +477,13 @@ TEST(GpuImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) { |
TestTileTaskRunner::ProcessTask(third_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(third_task.get()); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, |
- GetTaskForImageCanceledWhileReffedGetsNewTask) { |
+TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledWhileReffedGetsNewTask) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -493,16 +492,16 @@ TEST(GpuImageDecodeControllerTest, |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &another_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(another_task.get() == task.get()); |
@@ -513,8 +512,8 @@ TEST(GpuImageDecodeControllerTest, |
// Note that here, everything is reffed, but a new task is created. This is |
// possible with repeated schedule/cancel operations. |
scoped_refptr<TileTask> third_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &third_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &third_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(third_task); |
EXPECT_FALSE(third_task.get() == task.get()); |
@@ -523,15 +522,15 @@ TEST(GpuImageDecodeControllerTest, |
TestTileTaskRunner::ProcessTask(third_task.get()); |
// 3 Unrefs! |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(draw_image); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, NoTaskForImageAlreadyFailedDecoding) { |
+TEST(GpuImageDecodeCacheTest, NoTaskForImageAlreadyFailedDecoding) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -540,8 +539,8 @@ TEST(GpuImageDecodeControllerTest, NoTaskForImageAlreadyFailedDecoding) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -550,21 +549,21 @@ TEST(GpuImageDecodeControllerTest, NoTaskForImageAlreadyFailedDecoding) { |
TestTileTaskRunner::CancelTask(task.get()); |
TestTileTaskRunner::CompleteTask(task.get()); |
- controller.SetImageDecodingFailedForTesting(draw_image); |
+ cache.SetImageDecodingFailedForTesting(draw_image); |
scoped_refptr<TileTask> another_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &another_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &another_task); |
EXPECT_FALSE(need_unref); |
EXPECT_EQ(another_task.get(), nullptr); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetDecodedImageForDraw) { |
+TEST(GpuImageDecodeCacheTest, GetDecodedImageForDraw) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -573,8 +572,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDraw) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -585,20 +584,20 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDraw) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ 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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- controller.UnrefImage(draw_image); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetLargeDecodedImageForDraw) { |
+TEST(GpuImageDecodeCacheTest, GetLargeDecodedImageForDraw) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -607,8 +606,8 @@ TEST(GpuImageDecodeControllerTest, GetLargeDecodedImageForDraw) { |
quality, |
CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -619,25 +618,25 @@ TEST(GpuImageDecodeControllerTest, GetLargeDecodedImageForDraw) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ cache.GetDecodedImageForDraw(draw_image); |
EXPECT_TRUE(decoded_draw_image.image()); |
EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); |
EXPECT_FALSE(decoded_draw_image.is_at_raster_decode()); |
- EXPECT_TRUE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- controller.UnrefImage(draw_image); |
- EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.UnrefImage(draw_image); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
} |
-TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) { |
+TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
- controller.SetCachedBytesLimitForTesting(0); |
+ cache.SetCachedBytesLimitForTesting(0); |
sk_sp<SkImage> image = CreateImage(100, 100); |
DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
@@ -645,8 +644,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) { |
CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_FALSE(need_unref); |
EXPECT_FALSE(task); |
@@ -654,19 +653,19 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawLargerScale) { |
+TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawLargerScale) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -675,8 +674,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawLargerScale) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -687,8 +686,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawLargerScale) { |
image, SkIRect::MakeWH(image->width(), image->height()), quality, |
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable)); |
scoped_refptr<TileTask> larger_task; |
- bool larger_need_unref = controller.GetTaskForImageAndRef( |
- larger_draw_image, ImageDecodeController::TracingInfo(), &larger_task); |
+ bool larger_need_unref = cache.GetTaskForImageAndRef( |
+ larger_draw_image, ImageDecodeCache::TracingInfo(), &larger_task); |
EXPECT_TRUE(larger_need_unref); |
EXPECT_TRUE(larger_task); |
@@ -699,32 +698,31 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawLargerScale) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ 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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
DecodedDrawImage larger_decoded_draw_image = |
- controller.GetDecodedImageForDraw(larger_draw_image); |
+ cache.GetDecodedImageForDraw(larger_draw_image); |
EXPECT_TRUE(larger_decoded_draw_image.image()); |
EXPECT_TRUE(larger_decoded_draw_image.image()->isTextureBacked()); |
EXPECT_FALSE(larger_decoded_draw_image.is_at_raster_decode()); |
- EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image()); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- controller.UnrefImage(draw_image); |
- controller.DrawWithImageFinished(larger_draw_image, |
- larger_decoded_draw_image); |
- controller.UnrefImage(larger_draw_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(GpuImageDecodeControllerTest, GetDecodedImageForDrawHigherQuality) { |
+TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawHigherQuality) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkMatrix matrix = CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable); |
@@ -732,8 +730,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawHigherQuality) { |
DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
kLow_SkFilterQuality, matrix); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -744,9 +742,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawHigherQuality) { |
image, SkIRect::MakeWH(image->width(), image->height()), |
kHigh_SkFilterQuality, matrix); |
scoped_refptr<TileTask> hq_task; |
- bool hq_needs_unref = controller.GetTaskForImageAndRef( |
- higher_quality_draw_image, ImageDecodeController::TracingInfo(), |
- &hq_task); |
+ bool hq_needs_unref = cache.GetTaskForImageAndRef( |
+ higher_quality_draw_image, ImageDecodeCache::TracingInfo(), &hq_task); |
EXPECT_TRUE(hq_needs_unref); |
EXPECT_TRUE(hq_task); |
@@ -757,32 +754,32 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawHigherQuality) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ 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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
DecodedDrawImage larger_decoded_draw_image = |
- controller.GetDecodedImageForDraw(higher_quality_draw_image); |
+ cache.GetDecodedImageForDraw(higher_quality_draw_image); |
EXPECT_TRUE(larger_decoded_draw_image.image()); |
EXPECT_TRUE(larger_decoded_draw_image.image()->isTextureBacked()); |
EXPECT_FALSE(larger_decoded_draw_image.is_at_raster_decode()); |
- EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image()); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- controller.UnrefImage(draw_image); |
- controller.DrawWithImageFinished(higher_quality_draw_image, |
- larger_decoded_draw_image); |
- controller.UnrefImage(higher_quality_draw_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(GpuImageDecodeControllerTest, GetDecodedImageForDrawNegative) { |
+TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawNegative) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -791,8 +788,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawNegative) { |
image, SkIRect::MakeWH(image->width(), image->height()), quality, |
CreateMatrix(SkSize::Make(-0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -803,22 +800,22 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawNegative) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ cache.GetDecodedImageForDraw(draw_image); |
EXPECT_TRUE(decoded_draw_image.image()); |
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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- controller.UnrefImage(draw_image); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, GetLargeScaledDecodedImageForDraw) { |
+TEST(GpuImageDecodeCacheTest, GetLargeScaledDecodedImageForDraw) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -827,8 +824,8 @@ TEST(GpuImageDecodeControllerTest, GetLargeScaledDecodedImageForDraw) { |
quality, |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -839,28 +836,28 @@ TEST(GpuImageDecodeControllerTest, GetLargeScaledDecodedImageForDraw) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ cache.GetDecodedImageForDraw(draw_image); |
EXPECT_TRUE(decoded_draw_image.image()); |
// The mip level scale should never go below 0 in any dimension. |
EXPECT_EQ(1, decoded_draw_image.image()->width()); |
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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- controller.UnrefImage(draw_image); |
- EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.UnrefImage(draw_image); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
} |
-TEST(GpuImageDecodeControllerTest, AtRasterUsedDirectlyIfSpaceAllows) { |
+TEST(GpuImageDecodeCacheTest, AtRasterUsedDirectlyIfSpaceAllows) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
- controller.SetCachedBytesLimitForTesting(0); |
+ cache.SetCachedBytesLimitForTesting(0); |
sk_sp<SkImage> image = CreateImage(100, 100); |
DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
@@ -868,8 +865,8 @@ TEST(GpuImageDecodeControllerTest, AtRasterUsedDirectlyIfSpaceAllows) { |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_FALSE(need_unref); |
EXPECT_FALSE(task); |
@@ -877,35 +874,35 @@ TEST(GpuImageDecodeControllerTest, AtRasterUsedDirectlyIfSpaceAllows) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.SetCachedBytesLimitForTesting(96 * 1024 * 1024); |
+ cache.SetCachedBytesLimitForTesting(96 * 1024 * 1024); |
// Finish our draw after increasing the memory limit, image should be added to |
// cache. |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
scoped_refptr<TileTask> another_task; |
- bool another_task_needs_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool another_task_needs_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(another_task_needs_unref); |
EXPECT_FALSE(another_task); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, |
+TEST(GpuImageDecodeCacheTest, |
GetDecodedImageForDrawAtRasterDecodeMultipleTimes) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
- controller.SetCachedBytesLimitForTesting(0); |
+ cache.SetCachedBytesLimitForTesting(0); |
sk_sp<SkImage> image = CreateImage(100, 100); |
DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
@@ -916,26 +913,26 @@ TEST(GpuImageDecodeControllerTest, |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
DecodedDrawImage another_decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ cache.GetDecodedImageForDraw(draw_image); |
EXPECT_EQ(decoded_draw_image.image()->uniqueID(), |
another_decoded_draw_image.image()->uniqueID()); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- controller.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.DrawWithImageFinished(draw_image, another_decoded_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, |
+TEST(GpuImageDecodeCacheTest, |
GetLargeDecodedImageForDrawAtRasterDecodeMultipleTimes) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -948,30 +945,30 @@ TEST(GpuImageDecodeControllerTest, |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ cache.GetDecodedImageForDraw(draw_image); |
EXPECT_TRUE(decoded_draw_image.image()); |
EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked()); |
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode()); |
- EXPECT_TRUE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
- EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
DecodedDrawImage second_decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ 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(controller.DiscardableIsLockedForTesting(draw_image)); |
+ EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image)); |
- controller.DrawWithImageFinished(draw_image, second_decoded_draw_image); |
- EXPECT_FALSE(controller.DiscardableIsLockedForTesting(draw_image)); |
+ cache.DrawWithImageFinished(draw_image, second_decoded_draw_image); |
+ EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image)); |
} |
-TEST(GpuImageDecodeControllerTest, ZeroSizedImagesAreSkipped) { |
+TEST(GpuImageDecodeCacheTest, ZeroSizedImagesAreSkipped) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -981,8 +978,8 @@ TEST(GpuImageDecodeControllerTest, ZeroSizedImagesAreSkipped) { |
CreateMatrix(SkSize::Make(0.f, 0.f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_FALSE(task); |
EXPECT_FALSE(need_unref); |
@@ -990,16 +987,16 @@ TEST(GpuImageDecodeControllerTest, ZeroSizedImagesAreSkipped) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ cache.GetDecodedImageForDraw(draw_image); |
EXPECT_FALSE(decoded_draw_image.image()); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { |
+TEST(GpuImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -1009,8 +1006,8 @@ TEST(GpuImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { |
quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_FALSE(task); |
EXPECT_FALSE(need_unref); |
@@ -1018,16 +1015,16 @@ TEST(GpuImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) { |
// DrawWithImageFinished. |
ContextProvider::ScopedContextLock context_lock(context_provider.get()); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image); |
+ cache.GetDecodedImageForDraw(draw_image); |
EXPECT_FALSE(decoded_draw_image.image()); |
- controller.DrawWithImageFinished(draw_image, decoded_draw_image); |
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, CanceledTasksDoNotCountAgainstBudget) { |
+TEST(GpuImageDecodeCacheTest, CanceledTasksDoNotCountAgainstBudget) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -1037,9 +1034,9 @@ TEST(GpuImageDecodeControllerTest, CanceledTasksDoNotCountAgainstBudget) { |
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
- EXPECT_NE(0u, controller.GetBytesUsedForTesting()); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
+ EXPECT_NE(0u, cache.GetBytesUsedForTesting()); |
EXPECT_TRUE(task); |
EXPECT_TRUE(need_unref); |
@@ -1048,14 +1045,14 @@ TEST(GpuImageDecodeControllerTest, CanceledTasksDoNotCountAgainstBudget) { |
TestTileTaskRunner::CancelTask(task.get()); |
TestTileTaskRunner::CompleteTask(task.get()); |
- controller.UnrefImage(draw_image); |
- EXPECT_EQ(0u, controller.GetBytesUsedForTesting()); |
+ cache.UnrefImage(draw_image); |
+ EXPECT_EQ(0u, cache.GetBytesUsedForTesting()); |
} |
-TEST(GpuImageDecodeControllerTest, ShouldAggressivelyFreeResources) { |
+TEST(GpuImageDecodeCacheTest, ShouldAggressivelyFreeResources) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -1065,8 +1062,8 @@ TEST(GpuImageDecodeControllerTest, ShouldAggressivelyFreeResources) { |
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> task; |
{ |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
} |
@@ -1074,29 +1071,29 @@ TEST(GpuImageDecodeControllerTest, ShouldAggressivelyFreeResources) { |
TestTileTaskRunner::ProcessTask(task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(task.get()); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
// We should now have data image in our cache. |
- DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); |
+ DCHECK_GT(cache.GetBytesUsedForTesting(), 0u); |
- // Tell our controller to aggressively free resources. |
- controller.SetShouldAggressivelyFreeResources(true); |
- DCHECK_EQ(0u, controller.GetBytesUsedForTesting()); |
+ // Tell our cache to aggressively free resources. |
+ cache.SetShouldAggressivelyFreeResources(true); |
+ DCHECK_EQ(0u, cache.GetBytesUsedForTesting()); |
// Attempting to upload a new image should result in at-raster decode. |
{ |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_FALSE(need_unref); |
EXPECT_FALSE(task); |
} |
- // We now tell the controller to not aggressively free resources. Uploads |
+ // We now tell the cache to not aggressively free resources. Uploads |
// should work again. |
- controller.SetShouldAggressivelyFreeResources(false); |
+ cache.SetShouldAggressivelyFreeResources(false); |
{ |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
} |
@@ -1105,14 +1102,14 @@ TEST(GpuImageDecodeControllerTest, ShouldAggressivelyFreeResources) { |
TestTileTaskRunner::ProcessTask(task.get()); |
// The image should be in our cache after un-ref. |
- controller.UnrefImage(draw_image); |
- DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); |
+ cache.UnrefImage(draw_image); |
+ DCHECK_GT(cache.GetBytesUsedForTesting(), 0u); |
} |
-TEST(GpuImageDecodeControllerTest, OrphanedImagesFreeOnReachingZeroRefs) { |
+TEST(GpuImageDecodeCacheTest, OrphanedImagesFreeOnReachingZeroRefs) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -1122,14 +1119,14 @@ TEST(GpuImageDecodeControllerTest, OrphanedImagesFreeOnReachingZeroRefs) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> first_task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- first_draw_image, ImageDecodeController::TracingInfo(), &first_task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(first_task); |
// The budget should account for exactly one image. |
- EXPECT_EQ(controller.GetBytesUsedForTesting(), |
- controller.GetDrawImageSizeForTesting(first_draw_image)); |
+ EXPECT_EQ(cache.GetBytesUsedForTesting(), |
+ cache.GetDrawImageSizeForTesting(first_draw_image)); |
// Create a larger version of |first_image|, this should immediately free the |
// memory used by |first_image| for the smaller scale. |
@@ -1137,8 +1134,8 @@ TEST(GpuImageDecodeControllerTest, OrphanedImagesFreeOnReachingZeroRefs) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); |
scoped_refptr<TileTask> second_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(second_task); |
EXPECT_TRUE(first_task.get() != second_task.get()); |
@@ -1146,28 +1143,28 @@ TEST(GpuImageDecodeControllerTest, OrphanedImagesFreeOnReachingZeroRefs) { |
TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(second_task.get()); |
- controller.UnrefImage(second_draw_image); |
+ cache.UnrefImage(second_draw_image); |
// The budget should account for both images one image. |
- EXPECT_EQ(controller.GetBytesUsedForTesting(), |
- controller.GetDrawImageSizeForTesting(second_draw_image) + |
- controller.GetDrawImageSizeForTesting(first_draw_image)); |
+ EXPECT_EQ(cache.GetBytesUsedForTesting(), |
+ cache.GetDrawImageSizeForTesting(second_draw_image) + |
+ cache.GetDrawImageSizeForTesting(first_draw_image)); |
// Unref the first image, it was orphaned, so it should be immediately |
// deleted. |
TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(first_task.get()); |
- controller.UnrefImage(first_draw_image); |
+ cache.UnrefImage(first_draw_image); |
// The budget should account for exactly one image. |
- EXPECT_EQ(controller.GetBytesUsedForTesting(), |
- controller.GetDrawImageSizeForTesting(second_draw_image)); |
+ EXPECT_EQ(cache.GetBytesUsedForTesting(), |
+ cache.GetDrawImageSizeForTesting(second_draw_image)); |
} |
-TEST(GpuImageDecodeControllerTest, OrphanedZeroRefImagesImmediatelyDeleted) { |
+TEST(GpuImageDecodeCacheTest, OrphanedZeroRefImagesImmediatelyDeleted) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -1177,18 +1174,18 @@ TEST(GpuImageDecodeControllerTest, OrphanedZeroRefImagesImmediatelyDeleted) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable)); |
scoped_refptr<TileTask> first_task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- first_draw_image, ImageDecodeController::TracingInfo(), &first_task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ first_draw_image, ImageDecodeCache::TracingInfo(), &first_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(first_task); |
TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(first_task.get()); |
- controller.UnrefImage(first_draw_image); |
+ cache.UnrefImage(first_draw_image); |
// The budget should account for exactly one image. |
- EXPECT_EQ(controller.GetBytesUsedForTesting(), |
- controller.GetDrawImageSizeForTesting(first_draw_image)); |
+ EXPECT_EQ(cache.GetBytesUsedForTesting(), |
+ cache.GetDrawImageSizeForTesting(first_draw_image)); |
// Create a larger version of |first_image|, this should immediately free the |
// memory used by |first_image| for the smaller scale. |
@@ -1196,8 +1193,8 @@ TEST(GpuImageDecodeControllerTest, OrphanedZeroRefImagesImmediatelyDeleted) { |
first_image, SkIRect::MakeWH(first_image->width(), first_image->height()), |
quality, CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); |
scoped_refptr<TileTask> second_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- second_draw_image, ImageDecodeController::TracingInfo(), &second_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ second_draw_image, ImageDecodeCache::TracingInfo(), &second_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(second_task); |
EXPECT_TRUE(first_task.get() != second_task.get()); |
@@ -1205,17 +1202,17 @@ TEST(GpuImageDecodeControllerTest, OrphanedZeroRefImagesImmediatelyDeleted) { |
TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(second_task.get()); |
- controller.UnrefImage(second_draw_image); |
+ cache.UnrefImage(second_draw_image); |
// The budget should account for exactly one image. |
- EXPECT_EQ(controller.GetBytesUsedForTesting(), |
- controller.GetDrawImageSizeForTesting(second_draw_image)); |
+ EXPECT_EQ(cache.GetBytesUsedForTesting(), |
+ cache.GetDrawImageSizeForTesting(second_draw_image)); |
} |
-TEST(GpuImageDecodeControllerTest, QualityCappedAtMedium) { |
+TEST(GpuImageDecodeCacheTest, QualityCappedAtMedium) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
sk_sp<SkImage> image = CreateImage(100, 100); |
bool is_decomposable = true; |
SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable); |
@@ -1225,8 +1222,8 @@ TEST(GpuImageDecodeControllerTest, QualityCappedAtMedium) { |
SkIRect::MakeWH(image->width(), image->height()), |
kLow_SkFilterQuality, matrix); |
scoped_refptr<TileTask> low_task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- low_draw_image, ImageDecodeController::TracingInfo(), &low_task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ low_draw_image, ImageDecodeCache::TracingInfo(), &low_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(low_task); |
@@ -1236,8 +1233,8 @@ TEST(GpuImageDecodeControllerTest, QualityCappedAtMedium) { |
SkIRect::MakeWH(image->width(), image->height()), |
kMedium_SkFilterQuality, matrix); |
scoped_refptr<TileTask> medium_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- medium_draw_image, ImageDecodeController::TracingInfo(), &medium_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ medium_draw_image, ImageDecodeCache::TracingInfo(), &medium_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(medium_task.get()); |
EXPECT_FALSE(low_task.get() == medium_task.get()); |
@@ -1247,8 +1244,8 @@ TEST(GpuImageDecodeControllerTest, QualityCappedAtMedium) { |
SkIRect::MakeWH(image->width(), image->height()), |
kHigh_SkFilterQuality, matrix); |
scoped_refptr<TileTask> large_task; |
- need_unref = controller.GetTaskForImageAndRef( |
- large_draw_image, ImageDecodeController::TracingInfo(), &large_task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ large_draw_image, ImageDecodeCache::TracingInfo(), &large_task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(medium_task.get() == large_task.get()); |
@@ -1257,17 +1254,17 @@ TEST(GpuImageDecodeControllerTest, QualityCappedAtMedium) { |
TestTileTaskRunner::ProcessTask(medium_task->dependencies()[0].get()); |
TestTileTaskRunner::ProcessTask(medium_task.get()); |
- controller.UnrefImage(low_draw_image); |
- controller.UnrefImage(medium_draw_image); |
- controller.UnrefImage(large_draw_image); |
+ 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(GpuImageDecodeControllerTest, GetDecodedImageForDrawMipUsageChange) { |
+TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawMipUsageChange) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
bool is_decomposable = true; |
SkFilterQuality quality = kHigh_SkFilterQuality; |
@@ -1277,8 +1274,8 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawMipUsageChange) { |
quality, |
CreateMatrix(SkSize::Make(1.0f, 1.0f), is_decomposable)); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_TRUE(need_unref); |
EXPECT_TRUE(task); |
@@ -1288,7 +1285,7 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawMipUsageChange) { |
TestTileTaskRunner::CancelTask(task.get()); |
TestTileTaskRunner::CompleteTask(task.get()); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
// Must hold context lock before calling GetDecodedImageForDraw / |
// DrawWithImageFinished. |
@@ -1299,14 +1296,14 @@ TEST(GpuImageDecodeControllerTest, GetDecodedImageForDrawMipUsageChange) { |
image, SkIRect::MakeWH(image->width(), image->height()), quality, |
CreateMatrix(SkSize::Make(0.6f, 0.6f), is_decomposable)); |
DecodedDrawImage decoded_draw_image = |
- controller.GetDecodedImageForDraw(draw_image_mips); |
- controller.DrawWithImageFinished(draw_image_mips, decoded_draw_image); |
+ cache.GetDecodedImageForDraw(draw_image_mips); |
+ cache.DrawWithImageFinished(draw_image_mips, decoded_draw_image); |
} |
-TEST(GpuImageDecodeControllerTest, MemoryStateSuspended) { |
+TEST(GpuImageDecodeCacheTest, MemoryStateSuspended) { |
auto context_provider = TestContextProvider::Create(); |
context_provider->BindToCurrentThread(); |
- TestGpuImageDecodeController controller(context_provider.get()); |
+ TestGpuImageDecodeCache cache(context_provider.get()); |
// First Insert an image into our cache. |
sk_sp<SkImage> image = CreateImage(1, 1); |
@@ -1315,53 +1312,53 @@ TEST(GpuImageDecodeControllerTest, MemoryStateSuspended) { |
DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()), |
kLow_SkFilterQuality, matrix); |
scoped_refptr<TileTask> task; |
- bool need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ bool 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()); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
// The image should be cached. |
- DCHECK_GT(controller.GetBytesUsedForTesting(), 0u); |
- DCHECK_EQ(controller.GetNumCacheEntriesForTesting(), 1u); |
+ DCHECK_GT(cache.GetBytesUsedForTesting(), 0u); |
+ DCHECK_EQ(cache.GetNumCacheEntriesForTesting(), 1u); |
// Set us to the not visible state (prerequisite for SUSPENDED). |
- controller.SetShouldAggressivelyFreeResources(true); |
+ cache.SetShouldAggressivelyFreeResources(true); |
// Image should be cached, but not using memory budget. |
- DCHECK_EQ(controller.GetBytesUsedForTesting(), 0u); |
- DCHECK_EQ(controller.GetNumCacheEntriesForTesting(), 1u); |
+ DCHECK_EQ(cache.GetBytesUsedForTesting(), 0u); |
+ DCHECK_EQ(cache.GetNumCacheEntriesForTesting(), 1u); |
// Set us to the SUSPENDED state. |
- controller.OnMemoryStateChange(base::MemoryState::SUSPENDED); |
+ cache.OnMemoryStateChange(base::MemoryState::SUSPENDED); |
// Nothing should be cached. |
- DCHECK_EQ(controller.GetBytesUsedForTesting(), 0u); |
- DCHECK_EQ(controller.GetNumCacheEntriesForTesting(), 0u); |
+ DCHECK_EQ(cache.GetBytesUsedForTesting(), 0u); |
+ DCHECK_EQ(cache.GetNumCacheEntriesForTesting(), 0u); |
// Attempts to get a task for the image should fail, as we have no space (at |
// raster only). |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ need_unref = cache.GetTaskForImageAndRef( |
+ draw_image, ImageDecodeCache::TracingInfo(), &task); |
EXPECT_FALSE(need_unref); |
EXPECT_FALSE(task); |
// Restore us to visible and NORMAL memory state. |
- controller.OnMemoryStateChange(base::MemoryState::NORMAL); |
- controller.SetShouldAggressivelyFreeResources(false); |
+ cache.OnMemoryStateChange(base::MemoryState::NORMAL); |
+ cache.SetShouldAggressivelyFreeResources(false); |
// We should now be able to create a task again (space available). |
- need_unref = controller.GetTaskForImageAndRef( |
- draw_image, ImageDecodeController::TracingInfo(), &task); |
+ 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()); |
- controller.UnrefImage(draw_image); |
+ cache.UnrefImage(draw_image); |
} |
} // namespace |