cc: Rename ImageDecodeController to ImageDecodeCache.
This patch renames ImageDecodeController to ImageDecodeCache, along
with software and gpu implementations.
R=enne@chromium.org, ericrk@chromium.org
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_trusty_blink_rel
Review-Url: https://codereview.chromium.org/2541183002
Cr-Commit-Position: refs/heads/master@{#435530}
diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 2e357a0..e6cdde6 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -425,9 +425,9 @@
"scheduler/video_frame_controller.h",
"tiles/eviction_tile_priority_queue.cc",
"tiles/eviction_tile_priority_queue.h",
- "tiles/gpu_image_decode_controller.cc",
- "tiles/gpu_image_decode_controller.h",
- "tiles/image_decode_controller.h",
+ "tiles/gpu_image_decode_cache.cc",
+ "tiles/gpu_image_decode_cache.h",
+ "tiles/image_decode_cache.h",
"tiles/image_manager.cc",
"tiles/image_manager.h",
"tiles/mipmap_util.cc",
@@ -444,8 +444,8 @@
"tiles/raster_tile_priority_queue_all.h",
"tiles/raster_tile_priority_queue_required.cc",
"tiles/raster_tile_priority_queue_required.h",
- "tiles/software_image_decode_controller.cc",
- "tiles/software_image_decode_controller.h",
+ "tiles/software_image_decode_cache.cc",
+ "tiles/software_image_decode_cache.h",
"tiles/tile.cc",
"tiles/tile.h",
"tiles/tile_draw_info.cc",
@@ -883,12 +883,12 @@
"test/mock_helper_unittest.cc",
"test/ordered_simple_task_runner_unittest.cc",
"test/test_web_graphics_context_3d_unittest.cc",
- "tiles/gpu_image_decode_controller_unittest.cc",
+ "tiles/gpu_image_decode_cache_unittest.cc",
"tiles/image_manager_unittest.cc",
"tiles/mipmap_util_unittest.cc",
"tiles/picture_layer_tiling_set_unittest.cc",
"tiles/picture_layer_tiling_unittest.cc",
- "tiles/software_image_decode_controller_unittest.cc",
+ "tiles/software_image_decode_cache_unittest.cc",
"tiles/tile_manager_unittest.cc",
"tiles/tile_priority_unittest.cc",
"trees/blocking_task_runner_unittest.cc",
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 91c49e1e..8497191 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -577,8 +577,8 @@
// Only set the image decode controller when we're committing.
if (!pending_set) {
- raster_source_->set_image_decode_controller(
- layer_tree_impl()->image_decode_controller());
+ raster_source_->set_image_decode_cache(
+ layer_tree_impl()->image_decode_cache());
}
// The |new_invalidation| must be cleared before updating tilings since they
@@ -679,8 +679,8 @@
void PictureLayerImpl::RecreateTileResources() {
tilings_ = CreatePictureLayerTilingSet();
if (raster_source_) {
- raster_source_->set_image_decode_controller(
- layer_tree_impl()->image_decode_controller());
+ raster_source_->set_image_decode_cache(
+ layer_tree_impl()->image_decode_cache());
}
}
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 4c9a168..72ce0df 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -339,10 +339,10 @@
playback_settings.playback_to_shared_canvas = true;
// Indicates whether content rasterization should happen through an
// ImageHijackCanvas, which causes image decodes to be managed by an
- // ImageDecodeController. PictureDrawQuads are used for resourceless software
- // draws, while a GPU ImageDecodeController may be in use by the compositor
+ // ImageDecodeCache. PictureDrawQuads are used for resourceless software
+ // draws, while a GPU ImageDecodeCache may be in use by the compositor
// providing the RasterSource. So we disable the image hijack canvas to avoid
- // trying to use the GPU ImageDecodeController while doing a software draw.
+ // trying to use the GPU ImageDecodeCache while doing a software draw.
playback_settings.use_image_hijack_canvas = false;
if (needs_transparency || disable_image_filtering) {
// TODO(aelias): This isn't correct in all cases. We should detect these
diff --git a/cc/playback/image_hijack_canvas.cc b/cc/playback/image_hijack_canvas.cc
index 15c42a7..04b24df 100644
--- a/cc/playback/image_hijack_canvas.cc
+++ b/cc/playback/image_hijack_canvas.cc
@@ -6,7 +6,7 @@
#include "base/optional.h"
#include "cc/playback/discardable_image_map.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
namespace cc {
namespace {
@@ -19,18 +19,18 @@
class ScopedDecodedImageLock {
public:
- ScopedDecodedImageLock(ImageDecodeController* image_decode_controller,
+ ScopedDecodedImageLock(ImageDecodeCache* image_decode_cache,
sk_sp<const SkImage> image,
const SkRect& src_rect,
const SkMatrix& matrix,
const SkPaint* paint)
- : image_decode_controller_(image_decode_controller),
+ : image_decode_cache_(image_decode_cache),
draw_image_(std::move(image),
RoundOutRect(src_rect),
paint ? paint->getFilterQuality() : kNone_SkFilterQuality,
matrix),
decoded_draw_image_(
- image_decode_controller_->GetDecodedImageForDraw(draw_image_)) {
+ image_decode_cache_->GetDecodedImageForDraw(draw_image_)) {
DCHECK(draw_image_.image()->isLazyGenerated());
if (paint) {
decoded_paint_ = *paint;
@@ -39,8 +39,8 @@
}
~ScopedDecodedImageLock() {
- image_decode_controller_->DrawWithImageFinished(draw_image_,
- decoded_draw_image_);
+ image_decode_cache_->DrawWithImageFinished(draw_image_,
+ decoded_draw_image_);
}
const DecodedDrawImage& decoded_image() const { return decoded_draw_image_; }
@@ -49,7 +49,7 @@
}
private:
- ImageDecodeController* image_decode_controller_;
+ ImageDecodeCache* image_decode_cache_;
DrawImage draw_image_;
DecodedDrawImage decoded_draw_image_;
base::Optional<SkPaint> decoded_paint_;
@@ -57,12 +57,10 @@
} // namespace
-ImageHijackCanvas::ImageHijackCanvas(
- int width,
- int height,
- ImageDecodeController* image_decode_controller)
- : SkNWayCanvas(width, height),
- image_decode_controller_(image_decode_controller) {}
+ImageHijackCanvas::ImageHijackCanvas(int width,
+ int height,
+ ImageDecodeCache* image_decode_cache)
+ : SkNWayCanvas(width, height), image_decode_cache_(image_decode_cache) {}
void ImageHijackCanvas::onDrawPicture(const SkPicture* picture,
const SkMatrix* matrix,
@@ -84,7 +82,7 @@
SkMatrix ctm = getTotalMatrix();
ScopedDecodedImageLock scoped_lock(
- image_decode_controller_, sk_ref_sp(image),
+ image_decode_cache_, sk_ref_sp(image),
SkRect::MakeIWH(image->width(), image->height()), ctm, paint);
const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
if (!decoded_image.image())
@@ -124,7 +122,7 @@
matrix.setRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
matrix.postConcat(getTotalMatrix());
- ScopedDecodedImageLock scoped_lock(image_decode_controller_, sk_ref_sp(image),
+ ScopedDecodedImageLock scoped_lock(image_decode_cache_, sk_ref_sp(image),
*src, matrix, paint);
const DecodedDrawImage& decoded_image = scoped_lock.decoded_image();
if (!decoded_image.image())
diff --git a/cc/playback/image_hijack_canvas.h b/cc/playback/image_hijack_canvas.h
index 65d5355..57c2e86c 100644
--- a/cc/playback/image_hijack_canvas.h
+++ b/cc/playback/image_hijack_canvas.h
@@ -10,13 +10,13 @@
namespace cc {
-class ImageDecodeController;
+class ImageDecodeCache;
class ImageHijackCanvas : public SkNWayCanvas {
public:
ImageHijackCanvas(int width,
int height,
- ImageDecodeController* image_decode_controller);
+ ImageDecodeCache* image_decode_cache);
private:
// Ensure that pictures are unpacked by this canvas, instead of being
@@ -39,7 +39,7 @@
const SkRect& dst,
const SkPaint* paint) override;
- ImageDecodeController* image_decode_controller_;
+ ImageDecodeCache* image_decode_cache_;
DISALLOW_COPY_AND_ASSIGN(ImageHijackCanvas);
};
diff --git a/cc/playback/raster_source.cc b/cc/playback/raster_source.cc
index 60f3ac7..9e5e946 100644
--- a/cc/playback/raster_source.cc
+++ b/cc/playback/raster_source.cc
@@ -41,7 +41,7 @@
slow_down_raster_scale_factor_for_debug_(
other->slow_down_raster_scale_factor_for_debug_),
should_attempt_to_use_distance_field_text_(false),
- image_decode_controller_(nullptr) {}
+ image_decode_cache_(nullptr) {}
RasterSource::RasterSource(const RasterSource* other, bool can_use_lcd_text)
: display_list_(other->display_list_),
@@ -58,8 +58,7 @@
other->slow_down_raster_scale_factor_for_debug_),
should_attempt_to_use_distance_field_text_(
other->should_attempt_to_use_distance_field_text_),
- image_decode_controller_(other->image_decode_controller_) {
-}
+ image_decode_cache_(other->image_decode_cache_) {}
RasterSource::~RasterSource() {
}
@@ -95,8 +94,7 @@
} else if (settings.use_image_hijack_canvas) {
const SkImageInfo& info = raster_canvas->imageInfo();
- ImageHijackCanvas canvas(info.width(), info.height(),
- image_decode_controller_);
+ ImageHijackCanvas canvas(info.width(), info.height(), image_decode_cache_);
// Before adding the canvas, make sure that the ImageHijackCanvas is aware
// of the current transform and clip, which may affect the clip bounds.
// Since we query the clip bounds of the current canvas to get the list of
diff --git a/cc/playback/raster_source.h b/cc/playback/raster_source.h
index 4fe6e5a..d040bcf 100644
--- a/cc/playback/raster_source.h
+++ b/cc/playback/raster_source.h
@@ -24,7 +24,7 @@
namespace cc {
class DisplayItemList;
class DrawImage;
-class ImageDecodeController;
+class ImageDecodeCache;
class CC_EXPORT RasterSource : public base::RefCountedThreadSafe<RasterSource> {
public:
@@ -128,22 +128,19 @@
// Image decode controller should be set once. Its lifetime has to exceed that
// of the raster source, since the raster source will access it during raster.
- void set_image_decode_controller(
- ImageDecodeController* image_decode_controller) {
- DCHECK(image_decode_controller);
- image_decode_controller_ = image_decode_controller;
+ void set_image_decode_cache(ImageDecodeCache* image_decode_cache) {
+ DCHECK(image_decode_cache);
+ image_decode_cache_ = image_decode_cache;
}
- // Returns the ImageDecodeController, currently only used by
+ // Returns the ImageDecodeCache, currently only used by
// GpuRasterBufferProvider in order to create its own ImageHijackCanvas.
// Because of the MultiPictureDraw approach used by GPU raster, it does not
// integrate well with the use of the ImageHijackCanvas internal to this
// class. See gpu_raster_buffer_provider.cc for more information.
// TODO(crbug.com/628394): Redesign this to avoid exposing
- // ImageDecodeController from the raster source.
- ImageDecodeController* image_decode_controller() const {
- return image_decode_controller_;
- }
+ // ImageDecodeCache from the raster source.
+ ImageDecodeCache* image_decode_cache() const { return image_decode_cache_; }
protected:
friend class base::RefCountedThreadSafe<RasterSource>;
@@ -171,7 +168,7 @@
// In practice, this is only set once before raster begins, so it's ok with
// respect to threading.
- ImageDecodeController* image_decode_controller_;
+ ImageDecodeCache* image_decode_cache_;
private:
void RasterCommon(SkCanvas* canvas, SkPicture::AbortCallback* callback) const;
diff --git a/cc/playback/raster_source_unittest.cc b/cc/playback/raster_source_unittest.cc
index 0dc74f8..2d04bb2 100644
--- a/cc/playback/raster_source_unittest.cc
+++ b/cc/playback/raster_source_unittest.cc
@@ -10,7 +10,7 @@
#include "cc/test/fake_recording_source.h"
#include "cc/test/skia_common.h"
-#include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/skia/include/core/SkPixelRef.h"
#include "third_party/skia/include/core/SkRefCnt.h"
@@ -581,10 +581,10 @@
bool can_use_lcd = true;
scoped_refptr<RasterSource> raster_source =
recording_source->CreateRasterSource(can_use_lcd);
- SoftwareImageDecodeController controller(
+ SoftwareImageDecodeCache controller(
ResourceFormat::RGBA_8888,
LayerTreeSettings().software_decoded_image_budget_bytes);
- raster_source->set_image_decode_controller(&controller);
+ raster_source->set_image_decode_cache(&controller);
SkBitmap bitmap;
bitmap.allocN32Pixels(size.width() * 0.5f, size.height() * 0.25f);
diff --git a/cc/raster/gpu_raster_buffer_provider.cc b/cc/raster/gpu_raster_buffer_provider.cc
index 3a900412..4cfe51a 100644
--- a/cc/raster/gpu_raster_buffer_provider.cc
+++ b/cc/raster/gpu_raster_buffer_provider.cc
@@ -87,7 +87,7 @@
bool can_use_lcd_text,
bool ignore_resource_color_space,
int msaa_sample_count,
- ImageDecodeController* image_decode_controller,
+ ImageDecodeCache* image_decode_cache,
bool use_image_hijack_canvas) {
ScopedGpuRaster gpu_raster(context_provider);
@@ -106,10 +106,10 @@
SkCanvas* canvas = sk_surface->getCanvas();
std::unique_ptr<ImageHijackCanvas> hijack_canvas;
if (use_image_hijack_canvas) {
- DCHECK(image_decode_controller);
+ DCHECK(image_decode_cache);
const SkImageInfo& info = canvas->imageInfo();
- hijack_canvas.reset(new ImageHijackCanvas(info.width(), info.height(),
- image_decode_controller));
+ hijack_canvas.reset(
+ new ImageHijackCanvas(info.width(), info.height(), image_decode_cache));
SkIRect raster_bounds;
canvas->getClipDeviceBounds(&raster_bounds);
hijack_canvas->clipRect(SkRect::MakeFromIRect(raster_bounds));
@@ -274,7 +274,7 @@
async_worker_context_enabled_, use_distance_field_text,
raster_source->CanUseLCDText(),
raster_source->HasImpliedColorSpace(), msaa_sample_count_,
- raster_source->image_decode_controller(),
+ raster_source->image_decode_cache(),
playback_settings.use_image_hijack_canvas);
const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index b37b81df..4168bcd 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -34,14 +34,13 @@
base::ThreadTaskRunnerHandle::Get().get(),
std::numeric_limits<size_t>::max(),
false /* use_partial_raster */),
- image_decode_controller_(
+ image_decode_cache_(
ResourceFormat::RGBA_8888,
LayerTreeSettings().software_decoded_image_budget_bytes) {
- SetResources(nullptr, &image_decode_controller_,
- g_synchronous_task_graph_runner.Pointer(),
- g_fake_raster_buffer_provider.Pointer(),
- std::numeric_limits<size_t>::max(),
- false /* use_gpu_rasterization */);
+ SetResources(
+ nullptr, &image_decode_cache_, g_synchronous_task_graph_runner.Pointer(),
+ g_fake_raster_buffer_provider.Pointer(),
+ std::numeric_limits<size_t>::max(), false /* use_gpu_rasterization */);
SetTileTaskManagerForTesting(base::MakeUnique<FakeTileTaskManagerImpl>());
}
@@ -51,10 +50,10 @@
base::ThreadTaskRunnerHandle::Get().get(),
std::numeric_limits<size_t>::max(),
false /* use_partial_raster */),
- image_decode_controller_(
+ image_decode_cache_(
ResourceFormat::RGBA_8888,
LayerTreeSettings().software_decoded_image_budget_bytes) {
- SetResources(resource_pool, &image_decode_controller_,
+ SetResources(resource_pool, &image_decode_cache_,
g_synchronous_task_graph_runner.Pointer(),
g_fake_raster_buffer_provider.Pointer(),
std::numeric_limits<size_t>::max(),
diff --git a/cc/test/fake_tile_manager.h b/cc/test/fake_tile_manager.h
index 0a20aac6..d5dde70 100644
--- a/cc/test/fake_tile_manager.h
+++ b/cc/test/fake_tile_manager.h
@@ -8,7 +8,7 @@
#include <set>
#include <vector>
-#include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
#include "cc/tiles/tile_manager.h"
namespace cc {
@@ -28,7 +28,7 @@
std::vector<Tile*> tiles_for_raster;
private:
- SoftwareImageDecodeController image_decode_controller_;
+ SoftwareImageDecodeCache image_decode_cache_;
};
} // namespace cc
diff --git a/cc/tiles/gpu_image_decode_controller.cc b/cc/tiles/gpu_image_decode_cache.cc
similarity index 86%
rename from cc/tiles/gpu_image_decode_controller.cc
rename to cc/tiles/gpu_image_decode_cache.cc
index d78f55f..b06da1f 100644
--- a/cc/tiles/gpu_image_decode_controller.cc
+++ b/cc/tiles/gpu_image_decode_cache.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 <inttypes.h>
@@ -22,7 +22,7 @@
#include "cc/tiles/mipmap_util.h"
#include "gpu/command_buffer/client/context_support.h"
#include "gpu/command_buffer/client/gles2_interface.h"
-#include "gpu_image_decode_controller.h"
+#include "gpu_image_decode_cache.h"
#include "skia/ext/texture_handle.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkRefCnt.h"
@@ -134,24 +134,24 @@
} // namespace
-GpuImageDecodeController::InUseCacheEntry::InUseCacheEntry(
+GpuImageDecodeCache::InUseCacheEntry::InUseCacheEntry(
scoped_refptr<ImageData> image_data)
: image_data(std::move(image_data)) {}
-GpuImageDecodeController::InUseCacheEntry::InUseCacheEntry(
- const InUseCacheEntry&) = default;
-GpuImageDecodeController::InUseCacheEntry::InUseCacheEntry(InUseCacheEntry&&) =
+GpuImageDecodeCache::InUseCacheEntry::InUseCacheEntry(const InUseCacheEntry&) =
default;
-GpuImageDecodeController::InUseCacheEntry::~InUseCacheEntry() = default;
+GpuImageDecodeCache::InUseCacheEntry::InUseCacheEntry(InUseCacheEntry&&) =
+ default;
+GpuImageDecodeCache::InUseCacheEntry::~InUseCacheEntry() = default;
// Task which decodes an image and stores the result in discardable memory.
// This task does not use GPU resources and can be run on any thread.
class ImageDecodeTaskImpl : public TileTask {
public:
- ImageDecodeTaskImpl(GpuImageDecodeController* controller,
+ ImageDecodeTaskImpl(GpuImageDecodeCache* cache,
const DrawImage& draw_image,
- const ImageDecodeController::TracingInfo& tracing_info)
+ const ImageDecodeCache::TracingInfo& tracing_info)
: TileTask(true),
- controller_(controller),
+ cache_(cache),
image_(draw_image),
tracing_info_(tracing_info) {
DCHECK(!SkipImage(draw_image));
@@ -164,21 +164,21 @@
devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
image_.image().get(),
devtools_instrumentation::ScopedImageDecodeTask::GPU);
- controller_->DecodeImage(image_);
+ cache_->DecodeImage(image_);
}
// Overridden from TileTask:
void OnTaskCompleted() override {
- controller_->OnImageDecodeTaskCompleted(image_);
+ cache_->OnImageDecodeTaskCompleted(image_);
}
protected:
~ImageDecodeTaskImpl() override {}
private:
- GpuImageDecodeController* controller_;
+ GpuImageDecodeCache* cache_;
DrawImage image_;
- const ImageDecodeController::TracingInfo tracing_info_;
+ const ImageDecodeCache::TracingInfo tracing_info_;
DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
};
@@ -188,12 +188,12 @@
// concurrent thread.
class ImageUploadTaskImpl : public TileTask {
public:
- ImageUploadTaskImpl(GpuImageDecodeController* controller,
+ ImageUploadTaskImpl(GpuImageDecodeCache* cache,
const DrawImage& draw_image,
scoped_refptr<TileTask> decode_dependency,
- const ImageDecodeController::TracingInfo& tracing_info)
+ const ImageDecodeCache::TracingInfo& tracing_info)
: TileTask(false),
- controller_(controller),
+ cache_(cache),
image_(draw_image),
tracing_info_(tracing_info) {
DCHECK(!SkipImage(draw_image));
@@ -207,31 +207,31 @@
void RunOnWorkerThread() override {
TRACE_EVENT2("cc", "ImageUploadTaskImpl::RunOnWorkerThread", "mode", "gpu",
"source_prepare_tiles_id", tracing_info_.prepare_tiles_id);
- controller_->UploadImage(image_);
+ cache_->UploadImage(image_);
}
// Overridden from TileTask:
void OnTaskCompleted() override {
- controller_->OnImageUploadTaskCompleted(image_);
+ cache_->OnImageUploadTaskCompleted(image_);
}
protected:
~ImageUploadTaskImpl() override {}
private:
- GpuImageDecodeController* controller_;
+ GpuImageDecodeCache* cache_;
DrawImage image_;
- const ImageDecodeController::TracingInfo tracing_info_;
+ const ImageDecodeCache::TracingInfo tracing_info_;
DISALLOW_COPY_AND_ASSIGN(ImageUploadTaskImpl);
};
-GpuImageDecodeController::DecodedImageData::DecodedImageData() = default;
-GpuImageDecodeController::DecodedImageData::~DecodedImageData() {
+GpuImageDecodeCache::DecodedImageData::DecodedImageData() = default;
+GpuImageDecodeCache::DecodedImageData::~DecodedImageData() {
ResetData();
}
-bool GpuImageDecodeController::DecodedImageData::Lock() {
+bool GpuImageDecodeCache::DecodedImageData::Lock() {
DCHECK(!is_locked_);
is_locked_ = data_->Lock();
if (is_locked_)
@@ -239,7 +239,7 @@
return is_locked_;
}
-void GpuImageDecodeController::DecodedImageData::Unlock() {
+void GpuImageDecodeCache::DecodedImageData::Unlock() {
DCHECK(is_locked_);
data_->Unlock();
if (usage_stats_.lock_count == 1)
@@ -247,7 +247,7 @@
is_locked_ = false;
}
-void GpuImageDecodeController::DecodedImageData::SetLockedData(
+void GpuImageDecodeCache::DecodedImageData::SetLockedData(
std::unique_ptr<base::DiscardableMemory> data) {
DCHECK(!is_locked_);
DCHECK(data);
@@ -256,7 +256,7 @@
is_locked_ = true;
}
-void GpuImageDecodeController::DecodedImageData::ResetData() {
+void GpuImageDecodeCache::DecodedImageData::ResetData() {
DCHECK(!is_locked_);
if (data_)
ReportUsageStats();
@@ -264,7 +264,7 @@
usage_stats_ = UsageStats();
}
-void GpuImageDecodeController::DecodedImageData::ReportUsageStats() const {
+void GpuImageDecodeCache::DecodedImageData::ReportUsageStats() const {
// lock_count │ used │ result state
// ═══════════╪═══════╪══════════════════
// 1 │ false │ WASTED_ONCE
@@ -299,13 +299,12 @@
usage_stats_.first_lock_wasted);
}
-GpuImageDecodeController::UploadedImageData::UploadedImageData() = default;
-GpuImageDecodeController::UploadedImageData::~UploadedImageData() {
+GpuImageDecodeCache::UploadedImageData::UploadedImageData() = default;
+GpuImageDecodeCache::UploadedImageData::~UploadedImageData() {
SetImage(nullptr);
}
-void GpuImageDecodeController::UploadedImageData::SetImage(
- sk_sp<SkImage> image) {
+void GpuImageDecodeCache::UploadedImageData::SetImage(sk_sp<SkImage> image) {
DCHECK(!image_ || !image);
if (image_) {
ReportUsageStats();
@@ -314,20 +313,20 @@
image_ = std::move(image);
}
-void GpuImageDecodeController::UploadedImageData::ReportUsageStats() const {
+void GpuImageDecodeCache::UploadedImageData::ReportUsageStats() const {
UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageUploadState.Used",
usage_stats_.used);
UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageUploadState.FirstRefWasted",
usage_stats_.first_ref_wasted);
}
-GpuImageDecodeController::ImageData::ImageData(
+GpuImageDecodeCache::ImageData::ImageData(
DecodedDataMode mode,
size_t size,
const SkImage::DeferredTextureImageUsageParams& upload_params)
: mode(mode), size(size), upload_params(upload_params) {}
-GpuImageDecodeController::ImageData::~ImageData() {
+GpuImageDecodeCache::ImageData::~ImageData() {
// We should never delete ImageData while it is in use or before it has been
// cleaned up.
DCHECK_EQ(0u, upload.ref_count);
@@ -338,9 +337,9 @@
DCHECK(!upload.image());
}
-GpuImageDecodeController::GpuImageDecodeController(ContextProvider* context,
- ResourceFormat decode_format,
- size_t max_gpu_image_bytes)
+GpuImageDecodeCache::GpuImageDecodeCache(ContextProvider* context,
+ ResourceFormat decode_format,
+ size_t max_gpu_image_bytes)
: format_(decode_format),
context_(context),
persistent_cache_(PersistentCache::NO_AUTO_EVICT),
@@ -357,14 +356,13 @@
// Don't register a dump provider in these cases.
if (base::ThreadTaskRunnerHandle::IsSet()) {
base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
- this, "cc::GpuImageDecodeController",
- base::ThreadTaskRunnerHandle::Get());
+ this, "cc::GpuImageDecodeCache", base::ThreadTaskRunnerHandle::Get());
}
// Register this component with base::MemoryCoordinatorClientRegistry.
base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
}
-GpuImageDecodeController::~GpuImageDecodeController() {
+GpuImageDecodeCache::~GpuImageDecodeCache() {
// SetShouldAggressivelyFreeResources will zero our limits and free all
// outstanding image memory.
SetShouldAggressivelyFreeResources(true);
@@ -376,12 +374,11 @@
base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
}
-bool GpuImageDecodeController::GetTaskForImageAndRef(
- const DrawImage& draw_image,
- const TracingInfo& tracing_info,
- scoped_refptr<TileTask>* task) {
+bool GpuImageDecodeCache::GetTaskForImageAndRef(const DrawImage& draw_image,
+ const TracingInfo& tracing_info,
+ scoped_refptr<TileTask>* task) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::GetTaskForImageAndRef");
+ "GpuImageDecodeCache::GetTaskForImageAndRef");
if (SkipImage(draw_image)) {
*task = nullptr;
return false;
@@ -441,16 +438,16 @@
return true;
}
-void GpuImageDecodeController::UnrefImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UnrefImage(const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::UnrefImage");
+ "GpuImageDecodeCache::UnrefImage");
base::AutoLock lock(lock_);
UnrefImageInternal(draw_image);
}
-DecodedDrawImage GpuImageDecodeController::GetDecodedImageForDraw(
+DecodedDrawImage GpuImageDecodeCache::GetDecodedImageForDraw(
const DrawImage& draw_image) {
- TRACE_EVENT0("cc", "GpuImageDecodeController::GetDecodedImageForDraw");
+ TRACE_EVENT0("cc", "GpuImageDecodeCache::GetDecodedImageForDraw");
// We are being called during raster. The context lock must already be
// acquired by the caller.
@@ -498,10 +495,10 @@
return decoded_draw_image;
}
-void GpuImageDecodeController::DrawWithImageFinished(
+void GpuImageDecodeCache::DrawWithImageFinished(
const DrawImage& draw_image,
const DecodedDrawImage& decoded_draw_image) {
- TRACE_EVENT0("cc", "GpuImageDecodeController::DrawWithImageFinished");
+ TRACE_EVENT0("cc", "GpuImageDecodeCache::DrawWithImageFinished");
// We are being called during raster. The context lock must already be
// acquired by the caller.
@@ -519,17 +516,17 @@
DeletePendingImages();
}
-void GpuImageDecodeController::ReduceCacheUsage() {
+void GpuImageDecodeCache::ReduceCacheUsage() {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::ReduceCacheUsage");
+ "GpuImageDecodeCache::ReduceCacheUsage");
base::AutoLock lock(lock_);
EnsureCapacity(0);
}
-void GpuImageDecodeController::SetShouldAggressivelyFreeResources(
+void GpuImageDecodeCache::SetShouldAggressivelyFreeResources(
bool aggressively_free_resources) {
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::SetShouldAggressivelyFreeResources",
+ "GpuImageDecodeCache::SetShouldAggressivelyFreeResources",
"agressive_free_resources", aggressively_free_resources);
if (aggressively_free_resources) {
ContextProvider::ScopedContextLock context_lock(context_);
@@ -548,7 +545,7 @@
}
}
-bool GpuImageDecodeController::OnMemoryDump(
+bool GpuImageDecodeCache::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
using base::trace_event::MemoryAllocatorDump;
@@ -556,12 +553,11 @@
using base::trace_event::MemoryDumpLevelOfDetail;
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::OnMemoryDump");
+ "GpuImageDecodeCache::OnMemoryDump");
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
- std::string dump_name =
- base::StringPrintf("cc/image_memory/controller_0x%" PRIXPTR,
- reinterpret_cast<uintptr_t>(this));
+ std::string dump_name = base::StringPrintf(
+ "cc/image_memory/cache_0x%" PRIXPTR, reinterpret_cast<uintptr_t>(this));
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
dump->AddScalar(MemoryAllocatorDump::kNameSize,
MemoryAllocatorDump::kUnitsBytes, bytes_used_);
@@ -577,7 +573,7 @@
// If we have discardable decoded data, dump this here.
if (image_data->decode.data()) {
std::string discardable_dump_name = base::StringPrintf(
- "cc/image_memory/controller_0x%" PRIXPTR "/discardable/image_%d",
+ "cc/image_memory/cache_0x%" PRIXPTR "/discardable/image_%d",
reinterpret_cast<uintptr_t>(this), image_id);
MemoryAllocatorDump* dump =
image_data->decode.data()->CreateMemoryAllocatorDump(
@@ -598,7 +594,7 @@
if (image_data->upload.image() &&
image_data->mode == DecodedDataMode::GPU) {
std::string gpu_dump_name = base::StringPrintf(
- "cc/image_memory/controller_0x%" PRIXPTR "/gpu/image_%d",
+ "cc/image_memory/cache_0x%" PRIXPTR "/gpu/image_%d",
reinterpret_cast<uintptr_t>(this), image_id);
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(gpu_dump_name);
dump->AddScalar(MemoryAllocatorDump::kNameSize,
@@ -626,9 +622,9 @@
return true;
}
-void GpuImageDecodeController::DecodeImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::DecodeImage(const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::DecodeImage");
+ "GpuImageDecodeCache::DecodeImage");
base::AutoLock lock(lock_);
ImageData* image_data = GetImageDataForDrawImage(draw_image);
DCHECK(image_data);
@@ -636,9 +632,9 @@
DecodeImageIfNecessary(draw_image, image_data);
}
-void GpuImageDecodeController::UploadImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UploadImage(const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::UploadImage");
+ "GpuImageDecodeCache::UploadImage");
ContextProvider::ScopedContextLock context_lock(context_);
base::AutoLock lock(lock_);
ImageData* image_data = GetImageDataForDrawImage(draw_image);
@@ -647,10 +643,10 @@
UploadImageIfNecessary(draw_image, image_data);
}
-void GpuImageDecodeController::OnImageDecodeTaskCompleted(
+void GpuImageDecodeCache::OnImageDecodeTaskCompleted(
const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::OnImageDecodeTaskCompleted");
+ "GpuImageDecodeCache::OnImageDecodeTaskCompleted");
base::AutoLock lock(lock_);
// Decode task is complete, remove our reference to it.
ImageData* image_data = GetImageDataForDrawImage(draw_image);
@@ -663,10 +659,10 @@
UnrefImageDecode(draw_image);
}
-void GpuImageDecodeController::OnImageUploadTaskCompleted(
+void GpuImageDecodeCache::OnImageUploadTaskCompleted(
const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::OnImageUploadTaskCompleted");
+ "GpuImageDecodeCache::OnImageUploadTaskCompleted");
base::AutoLock lock(lock_);
// Upload task is complete, remove our reference to it.
ImageData* image_data = GetImageDataForDrawImage(draw_image);
@@ -683,11 +679,11 @@
// Checks if an existing image decode exists. If not, returns a task to produce
// the requested decode.
-scoped_refptr<TileTask> GpuImageDecodeController::GetImageDecodeTaskAndRef(
+scoped_refptr<TileTask> GpuImageDecodeCache::GetImageDecodeTaskAndRef(
const DrawImage& draw_image,
const TracingInfo& tracing_info) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::GetImageDecodeTaskAndRef");
+ "GpuImageDecodeCache::GetImageDecodeTaskAndRef");
lock_.AssertAcquired();
// This ref is kept alive while an upload task may need this decode. We
@@ -716,9 +712,9 @@
return existing_task;
}
-void GpuImageDecodeController::RefImageDecode(const DrawImage& draw_image) {
+void GpuImageDecodeCache::RefImageDecode(const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::RefImageDecode");
+ "GpuImageDecodeCache::RefImageDecode");
lock_.AssertAcquired();
auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
DCHECK(found != in_use_cache_.end());
@@ -727,9 +723,9 @@
OwnershipChanged(draw_image, found->second.image_data.get());
}
-void GpuImageDecodeController::UnrefImageDecode(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UnrefImageDecode(const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::UnrefImageDecode");
+ "GpuImageDecodeCache::UnrefImageDecode");
lock_.AssertAcquired();
auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
DCHECK(found != in_use_cache_.end());
@@ -743,9 +739,9 @@
}
}
-void GpuImageDecodeController::RefImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::RefImage(const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::RefImage");
+ "GpuImageDecodeCache::RefImage");
lock_.AssertAcquired();
InUseCacheKey key = GenerateInUseCacheKey(draw_image);
auto found = in_use_cache_.find(key);
@@ -770,7 +766,7 @@
OwnershipChanged(draw_image, found->second.image_data.get());
}
-void GpuImageDecodeController::UnrefImageInternal(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UnrefImageInternal(const DrawImage& draw_image) {
lock_.AssertAcquired();
auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
DCHECK(found != in_use_cache_.end());
@@ -786,8 +782,8 @@
// Called any time an image or decode ref count changes. Takes care of any
// necessary memory budget book-keeping and cleanup.
-void GpuImageDecodeController::OwnershipChanged(const DrawImage& draw_image,
- ImageData* image_data) {
+void GpuImageDecodeCache::OwnershipChanged(const DrawImage& draw_image,
+ ImageData* image_data) {
lock_.AssertAcquired();
bool has_any_refs =
@@ -883,9 +879,9 @@
// Ensures that we can fit a new image of size |required_size| in our cache. In
// doing so, this function will free unreferenced image data as necessary to
// create rooom.
-bool GpuImageDecodeController::EnsureCapacity(size_t required_size) {
+bool GpuImageDecodeCache::EnsureCapacity(size_t required_size) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::EnsureCapacity");
+ "GpuImageDecodeCache::EnsureCapacity");
lock_.AssertAcquired();
if (CanFitSize(required_size) && !ExceedsPreferredCount())
@@ -936,7 +932,7 @@
return CanFitSize(required_size);
}
-bool GpuImageDecodeController::CanFitSize(size_t size) const {
+bool GpuImageDecodeCache::CanFitSize(size_t size) const {
lock_.AssertAcquired();
size_t bytes_limit;
@@ -954,7 +950,7 @@
return new_size.IsValid() && new_size.ValueOrDie() <= bytes_limit;
}
-bool GpuImageDecodeController::ExceedsPreferredCount() const {
+bool GpuImageDecodeCache::ExceedsPreferredCount() const {
lock_.AssertAcquired();
size_t items_limit;
@@ -970,9 +966,8 @@
return persistent_cache_.size() > items_limit;
}
-void GpuImageDecodeController::DecodeImageIfNecessary(
- const DrawImage& draw_image,
- ImageData* image_data) {
+void GpuImageDecodeCache::DecodeImageIfNecessary(const DrawImage& draw_image,
+ ImageData* image_data) {
lock_.AssertAcquired();
DCHECK_GT(image_data->decode.ref_count, 0u);
@@ -993,7 +988,7 @@
return;
}
- TRACE_EVENT0("cc", "GpuImageDecodeController::DecodeImage");
+ TRACE_EVENT0("cc", "GpuImageDecodeCache::DecodeImage");
image_data->decode.ResetData();
std::unique_ptr<base::DiscardableMemory> backing_memory;
@@ -1052,9 +1047,8 @@
image_data->decode.SetLockedData(std::move(backing_memory));
}
-void GpuImageDecodeController::UploadImageIfNecessary(
- const DrawImage& draw_image,
- ImageData* image_data) {
+void GpuImageDecodeCache::UploadImageIfNecessary(const DrawImage& draw_image,
+ ImageData* image_data) {
context_->GetLock()->AssertAcquired();
lock_.AssertAcquired();
@@ -1068,7 +1062,7 @@
return;
}
- TRACE_EVENT0("cc", "GpuImageDecodeController::UploadImage");
+ TRACE_EVENT0("cc", "GpuImageDecodeCache::UploadImage");
DCHECK(image_data->decode.is_locked());
DCHECK_GT(image_data->decode.ref_count, 0u);
DCHECK_GT(image_data->upload.ref_count, 0u);
@@ -1108,10 +1102,10 @@
image_data->upload.SetImage(std::move(uploaded_image));
}
-scoped_refptr<GpuImageDecodeController::ImageData>
-GpuImageDecodeController::CreateImageData(const DrawImage& draw_image) {
+scoped_refptr<GpuImageDecodeCache::ImageData>
+GpuImageDecodeCache::CreateImageData(const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::CreateImageData");
+ "GpuImageDecodeCache::CreateImageData");
lock_.AssertAcquired();
DecodedDataMode mode;
@@ -1135,13 +1129,13 @@
return make_scoped_refptr(new ImageData(mode, data_size, params));
}
-void GpuImageDecodeController::DeletePendingImages() {
+void GpuImageDecodeCache::DeletePendingImages() {
context_->GetLock()->AssertAcquired();
lock_.AssertAcquired();
images_pending_deletion_.clear();
}
-SkImageInfo GpuImageDecodeController::CreateImageInfoForDrawImage(
+SkImageInfo GpuImageDecodeCache::CreateImageInfoForDrawImage(
const DrawImage& draw_image,
int upload_scale_mip_level) const {
gfx::Size mip_size =
@@ -1154,11 +1148,10 @@
// Tries to find an ImageData that can be used to draw the provided
// |draw_image|. First looks for an exact entry in our |in_use_cache_|. If one
// cannot be found, it looks for a compatible entry in our |persistent_cache_|.
-GpuImageDecodeController::ImageData*
-GpuImageDecodeController::GetImageDataForDrawImage(
+GpuImageDecodeCache::ImageData* GpuImageDecodeCache::GetImageDataForDrawImage(
const DrawImage& draw_image) {
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "GpuImageDecodeController::GetImageDataForDrawImage");
+ "GpuImageDecodeCache::GetImageDataForDrawImage");
lock_.AssertAcquired();
auto found_in_use = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
if (found_in_use != in_use_cache_.end())
@@ -1186,8 +1179,8 @@
// |image_data|. This is true if the |image_data| is not scaled, or if it
// is scaled at an equal or larger scale and equal or larger quality to
// the provided |draw_image|.
-bool GpuImageDecodeController::IsCompatible(const ImageData* image_data,
- const DrawImage& draw_image) const {
+bool GpuImageDecodeCache::IsCompatible(const ImageData* image_data,
+ const DrawImage& draw_image) const {
bool is_scaled = image_data->upload_params.fPreScaleMipLevel != 0;
bool scale_is_compatible = CalculateUploadScaleMipLevel(draw_image) >=
image_data->upload_params.fPreScaleMipLevel;
@@ -1196,14 +1189,13 @@
return !is_scaled || (scale_is_compatible && quality_is_compatible);
}
-size_t GpuImageDecodeController::GetDrawImageSizeForTesting(
- const DrawImage& image) {
+size_t GpuImageDecodeCache::GetDrawImageSizeForTesting(const DrawImage& image) {
base::AutoLock lock(lock_);
scoped_refptr<ImageData> data = CreateImageData(image);
return data->size;
}
-void GpuImageDecodeController::SetImageDecodingFailedForTesting(
+void GpuImageDecodeCache::SetImageDecodingFailedForTesting(
const DrawImage& image) {
base::AutoLock lock(lock_);
auto found = persistent_cache_.Peek(image.image()->uniqueID());
@@ -1212,7 +1204,7 @@
image_data->decode.decode_failure = true;
}
-bool GpuImageDecodeController::DiscardableIsLockedForTesting(
+bool GpuImageDecodeCache::DiscardableIsLockedForTesting(
const DrawImage& image) {
base::AutoLock lock(lock_);
auto found = persistent_cache_.Peek(image.image()->uniqueID());
@@ -1221,7 +1213,7 @@
return image_data->decode.is_locked();
}
-void GpuImageDecodeController::OnMemoryStateChange(base::MemoryState state) {
+void GpuImageDecodeCache::OnMemoryStateChange(base::MemoryState state) {
switch (state) {
case base::MemoryState::NORMAL:
memory_state_ = state;
diff --git a/cc/tiles/gpu_image_decode_controller.h b/cc/tiles/gpu_image_decode_cache.h
similarity index 93%
rename from cc/tiles/gpu_image_decode_controller.h
rename to cc/tiles/gpu_image_decode_cache.h
index 50cef6c..34f8dca 100644
--- a/cc/tiles/gpu_image_decode_controller.h
+++ b/cc/tiles/gpu_image_decode_cache.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
-#define CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
+#ifndef CC_TILES_GPU_IMAGE_DECODE_CACHE_H_
+#define CC_TILES_GPU_IMAGE_DECODE_CACHE_H_
#include <memory>
#include <unordered_map>
@@ -16,7 +16,7 @@
#include "base/trace_event/memory_dump_provider.h"
#include "cc/base/cc_export.h"
#include "cc/resources/resource_format.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
#include "third_party/skia/include/core/SkRefCnt.h"
namespace cc {
@@ -25,11 +25,11 @@
// OVERVIEW:
//
-// GpuImageDecodeController handles the decode and upload of images that will
+// GpuImageDecodeCache handles the decode and upload of images that will
// be used by Skia's GPU raster path. It also maintains a cache of these
// decoded/uploaded images for later re-use.
//
-// Generally, when an image is required for raster, GpuImageDecodeController
+// Generally, when an image is required for raster, GpuImageDecodeCache
// creates two tasks, one to decode the image, and one to upload the image to
// the GPU. These tasks are completed before the raster task which depends on
// the image. We need to seperate decode and upload tasks, as decode can occur
@@ -74,7 +74,7 @@
//
// REF COUNTING:
//
-// In dealing with the two caches in GpuImageDecodeController, there are three
+// In dealing with the two caches in GpuImageDecodeCache, there are three
// ref-counting concepts in use:
// 1) ImageData upload/decode ref-counts.
// These ref-counts represent the overall number of references to the
@@ -94,17 +94,17 @@
// keeps an ImageData alive while it is present in either the
// |persistent_cache_| or |in_use_cache_|.
//
-class CC_EXPORT GpuImageDecodeController
- : public ImageDecodeController,
+class CC_EXPORT GpuImageDecodeCache
+ : public ImageDecodeCache,
public base::trace_event::MemoryDumpProvider,
public base::MemoryCoordinatorClient {
public:
- explicit GpuImageDecodeController(ContextProvider* context,
- ResourceFormat decode_format,
- size_t max_gpu_image_bytes);
- ~GpuImageDecodeController() override;
+ explicit GpuImageDecodeCache(ContextProvider* context,
+ ResourceFormat decode_format,
+ size_t max_gpu_image_bytes);
+ ~GpuImageDecodeCache() override;
- // ImageDecodeController overrides.
+ // ImageDecodeCache overrides.
// Finds the existing uploaded image for the provided DrawImage. Creates an
// upload task to upload the image if an exsiting image does not exist.
@@ -282,7 +282,7 @@
void DecodeImageIfNecessary(const DrawImage& draw_image,
ImageData* image_data);
- scoped_refptr<GpuImageDecodeController::ImageData> CreateImageData(
+ scoped_refptr<GpuImageDecodeCache::ImageData> CreateImageData(
const DrawImage& image);
SkImageInfo CreateImageInfoForDrawImage(const DrawImage& draw_image,
int upload_scale_mip_level) const;
@@ -331,4 +331,4 @@
} // namespace cc
-#endif // CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
+#endif // CC_TILES_GPU_IMAGE_DECODE_CACHE_H_
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 feea99e..072dfd9 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 {
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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
diff --git a/cc/tiles/image_decode_controller.h b/cc/tiles/image_decode_cache.h
similarity index 86%
rename from cc/tiles/image_decode_controller.h
rename to cc/tiles/image_decode_cache.h
index 10e9398..d20ed37 100644
--- a/cc/tiles/image_decode_controller.h
+++ b/cc/tiles/image_decode_cache.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_TILES_IMAGE_DECODE_CONTROLLER_H_
-#define CC_TILES_IMAGE_DECODE_CONTROLLER_H_
+#ifndef CC_TILES_IMAGE_DECODE_CACHE_H_
+#define CC_TILES_IMAGE_DECODE_CACHE_H_
#include "base/memory/ref_counted.h"
#include "cc/playback/decoded_draw_image.h"
@@ -14,11 +14,11 @@
class TileTask;
-// ImageDecodeController is responsible for generating decode tasks, decoding
+// ImageDecodeCache is responsible for generating decode tasks, decoding
// images, storing images in cache, and being able to return the decoded images
// when requested.
-// ImageDecodeController is responsible for the following things:
+// ImageDecodeCache is responsible for the following things:
// 1. Given a DrawImage, it can return an TileTask which when run will
// decode and cache the resulting image. If the image does not need a task to
// be decoded, then nullptr will be returned. The return value of the
@@ -32,7 +32,7 @@
// and it needs to be scaled/decoded, then this decode will happen as part of
// getting the image. As such, this should only be accessed from a raster
// thread.
-class CC_EXPORT ImageDecodeController {
+class CC_EXPORT ImageDecodeCache {
public:
// This information should be used strictly in tracing, UMA, and any other
// reporting systems.
@@ -50,7 +50,7 @@
const TilePriority::PriorityBin requesting_tile_bin;
};
- virtual ~ImageDecodeController() {}
+ virtual ~ImageDecodeCache() {}
// Fill in an TileTask which will decode the given image when run. In
// case the image is already cached, fills in nullptr. Returns true if the
@@ -76,11 +76,11 @@
virtual void DrawWithImageFinished(const DrawImage& image,
const DecodedDrawImage& decoded_image) = 0;
- // This function informs the controller that now is a good time to clean up
+ // This function informs the cache that now is a good time to clean up
// memory. This is called periodically from the compositor thread.
virtual void ReduceCacheUsage() = 0;
- // This function informs the controller that we are hidden and should not be
+ // This function informs the cache that we are hidden and should not be
// retaining cached resources longer than needed.
virtual void SetShouldAggressivelyFreeResources(
bool aggressively_free_resources) = 0;
@@ -88,4 +88,4 @@
} // namespace cc
-#endif // CC_TILES_IMAGE_DECODE_CONTROLLER_H_
+#endif // CC_TILES_IMAGE_DECODE_CACHE_H_
diff --git a/cc/tiles/image_manager.cc b/cc/tiles/image_manager.cc
index 04d4e61..6b2c918 100644
--- a/cc/tiles/image_manager.cc
+++ b/cc/tiles/image_manager.cc
@@ -9,30 +9,30 @@
ImageManager::ImageManager() = default;
ImageManager::~ImageManager() = default;
-void ImageManager::SetImageDecodeController(ImageDecodeController* controller) {
+void ImageManager::SetImageDecodeCache(ImageDecodeCache* cache) {
// We can only switch from null to non-null and back.
// CHECK to debug crbug.com/650234.
- CHECK(controller || controller_);
- CHECK(!controller || !controller_);
+ CHECK(cache || cache_);
+ CHECK(!cache || !cache_);
- if (!controller) {
+ if (!cache) {
SetPredecodeImages(std::vector<DrawImage>(),
- ImageDecodeController::TracingInfo());
+ ImageDecodeCache::TracingInfo());
}
- controller_ = controller;
+ cache_ = cache;
// Debugging information for crbug.com/650234.
- ++num_times_controller_was_set_;
+ ++num_times_cache_was_set_;
}
void ImageManager::GetTasksForImagesAndRef(
std::vector<DrawImage>* images,
std::vector<scoped_refptr<TileTask>>* tasks,
- const ImageDecodeController::TracingInfo& tracing_info) {
- DCHECK(controller_);
+ const ImageDecodeCache::TracingInfo& tracing_info) {
+ DCHECK(cache_);
for (auto it = images->begin(); it != images->end();) {
scoped_refptr<TileTask> task;
bool need_to_unref_when_finished =
- controller_->GetTaskForImageAndRef(*it, tracing_info, &task);
+ cache_->GetTaskForImageAndRef(*it, tracing_info, &task);
if (task)
tasks->push_back(std::move(task));
@@ -45,19 +45,19 @@
void ImageManager::UnrefImages(const std::vector<DrawImage>& images) {
// Debugging information for crbug.com/650234.
- CHECK(controller_) << num_times_controller_was_set_;
+ CHECK(cache_) << num_times_cache_was_set_;
for (auto image : images)
- controller_->UnrefImage(image);
+ cache_->UnrefImage(image);
}
void ImageManager::ReduceMemoryUsage() {
- DCHECK(controller_);
- controller_->ReduceCacheUsage();
+ DCHECK(cache_);
+ cache_->ReduceCacheUsage();
}
std::vector<scoped_refptr<TileTask>> ImageManager::SetPredecodeImages(
std::vector<DrawImage> images,
- const ImageDecodeController::TracingInfo& tracing_info) {
+ const ImageDecodeCache::TracingInfo& tracing_info) {
std::vector<scoped_refptr<TileTask>> new_tasks;
GetTasksForImagesAndRef(&images, &new_tasks, tracing_info);
UnrefImages(predecode_locked_images_);
diff --git a/cc/tiles/image_manager.h b/cc/tiles/image_manager.h
index 13940a8..2a6e7f2 100644
--- a/cc/tiles/image_manager.h
+++ b/cc/tiles/image_manager.h
@@ -12,7 +12,7 @@
#include "cc/base/cc_export.h"
#include "cc/playback/draw_image.h"
#include "cc/raster/tile_task.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
namespace cc {
@@ -21,23 +21,23 @@
ImageManager();
~ImageManager();
- void SetImageDecodeController(ImageDecodeController* controller);
+ void SetImageDecodeCache(ImageDecodeCache* controller);
void GetTasksForImagesAndRef(
std::vector<DrawImage>* images,
std::vector<scoped_refptr<TileTask>>* tasks,
- const ImageDecodeController::TracingInfo& tracing_info);
+ const ImageDecodeCache::TracingInfo& tracing_info);
void UnrefImages(const std::vector<DrawImage>& images);
void ReduceMemoryUsage();
std::vector<scoped_refptr<TileTask>> SetPredecodeImages(
std::vector<DrawImage> predecode_images,
- const ImageDecodeController::TracingInfo& tracing_info);
+ const ImageDecodeCache::TracingInfo& tracing_info);
private:
- ImageDecodeController* controller_ = nullptr;
+ ImageDecodeCache* cache_ = nullptr;
std::vector<DrawImage> predecode_locked_images_;
// Debugging information for crbug.com/650234.
- size_t num_times_controller_was_set_ = 0;
+ size_t num_times_cache_was_set_ = 0;
DISALLOW_COPY_AND_ASSIGN(ImageManager);
};
diff --git a/cc/tiles/image_manager_unittest.cc b/cc/tiles/image_manager_unittest.cc
index 3d0fc37..509940c2 100644
--- a/cc/tiles/image_manager_unittest.cc
+++ b/cc/tiles/image_manager_unittest.cc
@@ -2,13 +2,13 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
#include "cc/tiles/image_manager.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace cc {
-class TestableController : public ImageDecodeController {
+class TestableCache : public ImageDecodeCache {
public:
bool GetTaskForImageAndRef(const DrawImage& image,
const TracingInfo& tracing_info,
@@ -37,21 +37,21 @@
int number_of_refs_ = 0;
};
-TEST(ImageManagerTest, NullControllerUnrefsImages) {
- TestableController controller;
+TEST(ImageManagerTest, NullCacheUnrefsImages) {
+ TestableCache cache;
ImageManager manager;
- manager.SetImageDecodeController(&controller);
+ manager.SetImageDecodeCache(&cache);
std::vector<DrawImage> images(10);
- ImageDecodeController::TracingInfo tracing_info;
+ ImageDecodeCache::TracingInfo tracing_info;
ASSERT_EQ(10u, images.size());
auto tasks = manager.SetPredecodeImages(std::move(images), tracing_info);
EXPECT_EQ(0u, tasks.size());
- EXPECT_EQ(10, controller.number_of_refs());
+ EXPECT_EQ(10, cache.number_of_refs());
- manager.SetImageDecodeController(nullptr);
- EXPECT_EQ(0, controller.number_of_refs());
+ manager.SetImageDecodeCache(nullptr);
+ EXPECT_EQ(0, cache.number_of_refs());
}
} // namespace cc
diff --git a/cc/tiles/software_image_decode_controller.cc b/cc/tiles/software_image_decode_cache.cc
similarity index 85%
rename from cc/tiles/software_image_decode_controller.cc
rename to cc/tiles/software_image_decode_cache.cc
index 1277ed57..bb2a8d0 100644
--- a/cc/tiles/software_image_decode_controller.cc
+++ b/cc/tiles/software_image_decode_cache.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/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
#include <inttypes.h>
#include <stdint.h>
@@ -57,46 +57,46 @@
class AutoRemoveKeyFromTaskMap {
public:
AutoRemoveKeyFromTaskMap(
- std::unordered_map<SoftwareImageDecodeController::ImageKey,
+ std::unordered_map<SoftwareImageDecodeCache::ImageKey,
scoped_refptr<TileTask>,
- SoftwareImageDecodeController::ImageKeyHash>* task_map,
- const SoftwareImageDecodeController::ImageKey& key)
+ SoftwareImageDecodeCache::ImageKeyHash>* task_map,
+ const SoftwareImageDecodeCache::ImageKey& key)
: task_map_(task_map), key_(key) {}
~AutoRemoveKeyFromTaskMap() { task_map_->erase(key_); }
private:
- std::unordered_map<SoftwareImageDecodeController::ImageKey,
+ std::unordered_map<SoftwareImageDecodeCache::ImageKey,
scoped_refptr<TileTask>,
- SoftwareImageDecodeController::ImageKeyHash>* task_map_;
- const SoftwareImageDecodeController::ImageKey& key_;
+ SoftwareImageDecodeCache::ImageKeyHash>* task_map_;
+ const SoftwareImageDecodeCache::ImageKey& key_;
};
class AutoDrawWithImageFinished {
public:
- AutoDrawWithImageFinished(SoftwareImageDecodeController* controller,
+ AutoDrawWithImageFinished(SoftwareImageDecodeCache* cache,
const DrawImage& draw_image,
const DecodedDrawImage& decoded_draw_image)
- : controller_(controller),
+ : cache_(cache),
draw_image_(draw_image),
decoded_draw_image_(decoded_draw_image) {}
~AutoDrawWithImageFinished() {
- controller_->DrawWithImageFinished(draw_image_, decoded_draw_image_);
+ cache_->DrawWithImageFinished(draw_image_, decoded_draw_image_);
}
private:
- SoftwareImageDecodeController* controller_;
+ SoftwareImageDecodeCache* cache_;
const DrawImage& draw_image_;
const DecodedDrawImage& decoded_draw_image_;
};
class ImageDecodeTaskImpl : public TileTask {
public:
- ImageDecodeTaskImpl(SoftwareImageDecodeController* controller,
- const SoftwareImageDecodeController::ImageKey& image_key,
+ ImageDecodeTaskImpl(SoftwareImageDecodeCache* cache,
+ const SoftwareImageDecodeCache::ImageKey& image_key,
const DrawImage& image,
- const ImageDecodeController::TracingInfo& tracing_info)
+ const ImageDecodeCache::TracingInfo& tracing_info)
: TileTask(true),
- controller_(controller),
+ cache_(cache),
image_key_(image_key),
image_(image),
tracing_info_(tracing_info) {}
@@ -109,27 +109,25 @@
devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
image_.image().get(),
devtools_instrumentation::ScopedImageDecodeTask::SOFTWARE);
- controller_->DecodeImage(image_key_, image_);
+ cache_->DecodeImage(image_key_, image_);
}
// Overridden from TileTask:
- void OnTaskCompleted() override {
- controller_->RemovePendingTask(image_key_);
- }
+ void OnTaskCompleted() override { cache_->RemovePendingTask(image_key_); }
protected:
~ImageDecodeTaskImpl() override {}
private:
- SoftwareImageDecodeController* controller_;
- SoftwareImageDecodeController::ImageKey image_key_;
+ SoftwareImageDecodeCache* cache_;
+ SoftwareImageDecodeCache::ImageKey image_key_;
DrawImage image_;
- const ImageDecodeController::TracingInfo tracing_info_;
+ const ImageDecodeCache::TracingInfo tracing_info_;
DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
};
-SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key) {
+SkSize GetScaleAdjustment(const ImageDecodeCacheKey& key) {
// If the requested filter quality did not require scale, then the adjustment
// is identity.
if (key.can_use_original_decode() || key.should_use_subrect()) {
@@ -146,7 +144,7 @@
}
}
-SkFilterQuality GetDecodedFilterQuality(const ImageDecodeControllerKey& key) {
+SkFilterQuality GetDecodedFilterQuality(const ImageDecodeCacheKey& key) {
return std::min(key.filter_quality(), kLow_SkFilterQuality);
}
@@ -175,7 +173,7 @@
} // namespace
-SoftwareImageDecodeController::SoftwareImageDecodeController(
+SoftwareImageDecodeCache::SoftwareImageDecodeCache(
ResourceFormat format,
size_t locked_memory_limit_bytes)
: decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
@@ -187,14 +185,14 @@
// Don't register a dump provider in these cases.
if (base::ThreadTaskRunnerHandle::IsSet()) {
base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
- this, "cc::SoftwareImageDecodeController",
+ this, "cc::SoftwareImageDecodeCache",
base::ThreadTaskRunnerHandle::Get());
}
// Register this component with base::MemoryCoordinatorClientRegistry.
base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
}
-SoftwareImageDecodeController::~SoftwareImageDecodeController() {
+SoftwareImageDecodeCache::~SoftwareImageDecodeCache() {
DCHECK_EQ(0u, decoded_images_ref_counts_.size());
DCHECK_EQ(0u, at_raster_decoded_images_ref_counts_.size());
@@ -205,7 +203,7 @@
base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
}
-bool SoftwareImageDecodeController::GetTaskForImageAndRef(
+bool SoftwareImageDecodeCache::GetTaskForImageAndRef(
const DrawImage& image,
const TracingInfo& tracing_info,
scoped_refptr<TileTask>* task) {
@@ -218,7 +216,7 @@
// the cache.
ImageKey key = ImageKey::FromDrawImage(image);
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::GetTaskForImageAndRef", "key",
+ "SoftwareImageDecodeCache::GetTaskForImageAndRef", "key",
key.ToString());
// If the target size is empty, we can skip this image during draw (and thus
@@ -290,10 +288,9 @@
return true;
}
-void SoftwareImageDecodeController::RefImage(const ImageKey& key) {
+void SoftwareImageDecodeCache::RefImage(const ImageKey& key) {
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::RefImage", "key",
- key.ToString());
+ "SoftwareImageDecodeCache::RefImage", "key", key.ToString());
lock_.AssertAcquired();
int ref = ++decoded_images_ref_counts_[key];
if (ref == 1) {
@@ -302,7 +299,7 @@
}
}
-void SoftwareImageDecodeController::UnrefImage(const DrawImage& image) {
+void SoftwareImageDecodeCache::UnrefImage(const DrawImage& image) {
// When we unref the image, there are several situations we need to consider:
// 1. The ref did not reach 0, which means we have to keep the image locked.
// 2. The ref reached 0, we should unlock it.
@@ -311,8 +308,7 @@
// 2b. Unlock the image but keep it in list.
const ImageKey& key = ImageKey::FromDrawImage(image);
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::UnrefImage", "key",
- key.ToString());
+ "SoftwareImageDecodeCache::UnrefImage", "key", key.ToString());
base::AutoLock lock(lock_);
auto ref_count_it = decoded_images_ref_counts_.find(key);
@@ -336,9 +332,9 @@
SanityCheckState(__LINE__, true);
}
-void SoftwareImageDecodeController::DecodeImage(const ImageKey& key,
- const DrawImage& image) {
- TRACE_EVENT1("cc", "SoftwareImageDecodeController::DecodeImage", "key",
+void SoftwareImageDecodeCache::DecodeImage(const ImageKey& key,
+ const DrawImage& image) {
+ TRACE_EVENT1("cc", "SoftwareImageDecodeCache::DecodeImage", "key",
key.ToString());
base::AutoLock lock(lock_);
AutoRemoveKeyFromTaskMap remove_key_from_task_map(&pending_image_tasks_, key);
@@ -395,12 +391,11 @@
SanityCheckState(__LINE__, true);
}
-std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::DecodeImageInternal(
- const ImageKey& key,
- const DrawImage& draw_image) {
+std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
+SoftwareImageDecodeCache::DecodeImageInternal(const ImageKey& key,
+ const DrawImage& draw_image) {
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::DecodeImageInternal", "key",
+ "SoftwareImageDecodeCache::DecodeImageInternal", "key",
key.ToString());
sk_sp<const SkImage> image = draw_image.image();
if (!image)
@@ -421,11 +416,11 @@
}
}
-DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDraw(
+DecodedDrawImage SoftwareImageDecodeCache::GetDecodedImageForDraw(
const DrawImage& draw_image) {
ImageKey key = ImageKey::FromDrawImage(draw_image);
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::GetDecodedImageForDraw", "key",
+ "SoftwareImageDecodeCache::GetDecodedImageForDraw", "key",
key.ToString());
// If the target size is empty, we can skip this image draw.
if (key.target_size().IsEmpty())
@@ -434,11 +429,11 @@
return GetDecodedImageForDrawInternal(key, draw_image);
}
-DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDrawInternal(
+DecodedDrawImage SoftwareImageDecodeCache::GetDecodedImageForDrawInternal(
const ImageKey& key,
const DrawImage& draw_image) {
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::GetDecodedImageForDrawInternal",
+ "SoftwareImageDecodeCache::GetDecodedImageForDrawInternal",
"key", key.ToString());
base::AutoLock lock(lock_);
auto decoded_images_it = decoded_images_.Get(key);
@@ -530,15 +525,14 @@
return decoded_draw_image;
}
-std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::GetOriginalImageDecode(
- sk_sp<const SkImage> image) {
+std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
+SoftwareImageDecodeCache::GetOriginalImageDecode(sk_sp<const SkImage> image) {
SkImageInfo decoded_info =
CreateImageInfo(image->width(), image->height(), format_);
std::unique_ptr<base::DiscardableMemory> decoded_pixels;
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::GetOriginalImageDecode - "
+ "SoftwareImageDecodeCache::GetOriginalImageDecode - "
"allocate decoded pixels");
decoded_pixels =
base::DiscardableMemoryAllocator::GetInstance()
@@ -547,7 +541,7 @@
}
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::GetOriginalImageDecode - "
+ "SoftwareImageDecodeCache::GetOriginalImageDecode - "
"read pixels");
bool result = image->readPixels(decoded_info, decoded_pixels->data(),
decoded_info.minRowBytes(), 0, 0,
@@ -563,10 +557,9 @@
next_tracing_id_.GetNext());
}
-std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::GetSubrectImageDecode(
- const ImageKey& key,
- sk_sp<const SkImage> image) {
+std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
+SoftwareImageDecodeCache::GetSubrectImageDecode(const ImageKey& key,
+ sk_sp<const SkImage> image) {
// Construct a key to use in GetDecodedImageForDrawInternal().
// This allows us to reuse an image in any cache if available.
gfx::Rect full_image_rect(image->width(), image->height());
@@ -592,7 +585,7 @@
std::unique_ptr<base::DiscardableMemory> subrect_pixels;
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::GetSubrectImageDecode - "
+ "SoftwareImageDecodeCache::GetSubrectImageDecode - "
"allocate subrect pixels");
// TODO(vmpstr): This is using checked math to diagnose a problem reported
// in crbug.com/662217. If this is causing crashes, then it should be fixed
@@ -605,7 +598,7 @@
}
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::GetOriginalImageDecode - "
+ "SoftwareImageDecodeCache::GetOriginalImageDecode - "
"read pixels");
bool result = decoded_draw_image.image()->readPixels(
subrect_info, subrect_pixels->data(), subrect_info.minRowBytes(),
@@ -620,10 +613,9 @@
next_tracing_id_.GetNext()));
}
-std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::GetScaledImageDecode(
- const ImageKey& key,
- sk_sp<const SkImage> image) {
+std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
+SoftwareImageDecodeCache::GetScaledImageDecode(const ImageKey& key,
+ sk_sp<const SkImage> image) {
// Construct a key to use in GetDecodedImageForDrawInternal().
// This allows us to reuse an image in any cache if available.
gfx::Rect full_image_rect(image->width(), image->height());
@@ -660,7 +652,7 @@
{
TRACE_EVENT0(
TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::ScaleImage - allocate scaled pixels");
+ "SoftwareImageDecodeCache::ScaleImage - allocate scaled pixels");
scaled_pixels = base::DiscardableMemoryAllocator::GetInstance()
->AllocateLockedDiscardableMemory(
scaled_info.minRowBytes() * scaled_info.height());
@@ -671,7 +663,7 @@
key.filter_quality() == kMedium_SkFilterQuality);
{
TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::ScaleImage - scale pixels");
+ "SoftwareImageDecodeCache::ScaleImage - scale pixels");
bool result =
decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
DCHECK(result) << key.ToString();
@@ -683,11 +675,11 @@
next_tracing_id_.GetNext());
}
-void SoftwareImageDecodeController::DrawWithImageFinished(
+void SoftwareImageDecodeCache::DrawWithImageFinished(
const DrawImage& image,
const DecodedDrawImage& decoded_image) {
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::DrawWithImageFinished", "key",
+ "SoftwareImageDecodeCache::DrawWithImageFinished", "key",
ImageKey::FromDrawImage(image).ToString());
ImageKey key = ImageKey::FromDrawImage(image);
if (!decoded_image.image())
@@ -700,18 +692,18 @@
SanityCheckState(__LINE__, false);
}
-void SoftwareImageDecodeController::RefAtRasterImage(const ImageKey& key) {
+void SoftwareImageDecodeCache::RefAtRasterImage(const ImageKey& key) {
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::RefAtRasterImage", "key",
+ "SoftwareImageDecodeCache::RefAtRasterImage", "key",
key.ToString());
DCHECK(at_raster_decoded_images_.Peek(key) !=
at_raster_decoded_images_.end());
++at_raster_decoded_images_ref_counts_[key];
}
-void SoftwareImageDecodeController::UnrefAtRasterImage(const ImageKey& key) {
+void SoftwareImageDecodeCache::UnrefAtRasterImage(const ImageKey& key) {
TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
- "SoftwareImageDecodeController::UnrefAtRasterImage", "key",
+ "SoftwareImageDecodeCache::UnrefAtRasterImage", "key",
key.ToString());
base::AutoLock lock(lock_);
@@ -757,8 +749,8 @@
}
}
-void SoftwareImageDecodeController::ReduceCacheUsage() {
- TRACE_EVENT0("cc", "SoftwareImageDecodeController::ReduceCacheUsage");
+void SoftwareImageDecodeCache::ReduceCacheUsage() {
+ TRACE_EVENT0("cc", "SoftwareImageDecodeCache::ReduceCacheUsage");
base::AutoLock lock(lock_);
size_t num_to_remove = (decoded_images_.size() > max_items_in_cache_)
? (decoded_images_.size() - max_items_in_cache_)
@@ -775,20 +767,19 @@
}
}
-void SoftwareImageDecodeController::RemovePendingTask(const ImageKey& key) {
+void SoftwareImageDecodeCache::RemovePendingTask(const ImageKey& key) {
base::AutoLock lock(lock_);
pending_image_tasks_.erase(key);
}
-bool SoftwareImageDecodeController::OnMemoryDump(
+bool SoftwareImageDecodeCache::OnMemoryDump(
const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) {
base::AutoLock lock(lock_);
if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
- std::string dump_name =
- base::StringPrintf("cc/image_memory/controller_0x%" PRIXPTR,
- reinterpret_cast<uintptr_t>(this));
+ std::string dump_name = base::StringPrintf(
+ "cc/image_memory/cache_0x%" PRIXPTR, reinterpret_cast<uintptr_t>(this));
MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
locked_images_budget_.GetCurrentUsageSafe());
@@ -802,7 +793,7 @@
return true;
}
-void SoftwareImageDecodeController::DumpImageMemoryForCache(
+void SoftwareImageDecodeCache::DumpImageMemoryForCache(
const ImageMRUCache& cache,
const char* cache_name,
base::trace_event::ProcessMemoryDump* pmd) const {
@@ -810,7 +801,7 @@
for (const auto& image_pair : cache) {
std::string dump_name = base::StringPrintf(
- "cc/image_memory/controller_0x%" PRIXPTR "/%s/image_%" PRIu64 "_id_%d",
+ "cc/image_memory/cache_0x%" PRIXPTR "/%s/image_%" PRIu64 "_id_%d",
reinterpret_cast<uintptr_t>(this), cache_name,
image_pair.second->tracing_id(), image_pair.first.image_id());
// CreateMemoryAllocatorDump will automatically add tracking values for the
@@ -826,8 +817,7 @@
}
}
-void SoftwareImageDecodeController::SanityCheckState(int line,
- bool lock_acquired) {
+void SoftwareImageDecodeCache::SanityCheckState(int line, bool lock_acquired) {
#if DCHECK_IS_ON()
if (!lock_acquired) {
base::AutoLock lock(lock_);
@@ -856,9 +846,8 @@
#endif // DCHECK_IS_ON()
}
-// SoftwareImageDecodeControllerKey
-ImageDecodeControllerKey ImageDecodeControllerKey::FromDrawImage(
- const DrawImage& image) {
+// SoftwareImageDecodeCacheKey
+ImageDecodeCacheKey ImageDecodeCacheKey::FromDrawImage(const DrawImage& image) {
const SkSize& scale = image.scale();
// If the src_rect falls outside of the image, we need to clip it since
// otherwise we might end up with uninitialized memory in the decode process.
@@ -953,18 +942,17 @@
target_size.set_height(src_rect.height() * mip_target_size.height());
}
- return ImageDecodeControllerKey(image.image()->uniqueID(), src_rect,
- target_size, quality, can_use_original_decode,
- should_use_subrect);
+ return ImageDecodeCacheKey(image.image()->uniqueID(), src_rect, target_size,
+ quality, can_use_original_decode,
+ should_use_subrect);
}
-ImageDecodeControllerKey::ImageDecodeControllerKey(
- uint32_t image_id,
- const gfx::Rect& src_rect,
- const gfx::Size& target_size,
- SkFilterQuality filter_quality,
- bool can_use_original_decode,
- bool should_use_subrect)
+ImageDecodeCacheKey::ImageDecodeCacheKey(uint32_t image_id,
+ const gfx::Rect& src_rect,
+ const gfx::Size& target_size,
+ SkFilterQuality filter_quality,
+ bool can_use_original_decode,
+ bool should_use_subrect)
: image_id_(image_id),
src_rect_(src_rect),
target_size_(target_size),
@@ -989,10 +977,10 @@
}
}
-ImageDecodeControllerKey::ImageDecodeControllerKey(
- const ImageDecodeControllerKey& other) = default;
+ImageDecodeCacheKey::ImageDecodeCacheKey(const ImageDecodeCacheKey& other) =
+ default;
-std::string ImageDecodeControllerKey::ToString() const {
+std::string ImageDecodeCacheKey::ToString() const {
std::ostringstream str;
str << "id[" << image_id_ << "] src_rect[" << src_rect_.x() << ","
<< src_rect_.y() << " " << src_rect_.width() << "x" << src_rect_.height()
@@ -1005,7 +993,7 @@
}
// DecodedImage
-SoftwareImageDecodeController::DecodedImage::DecodedImage(
+SoftwareImageDecodeCache::DecodedImage::DecodedImage(
const SkImageInfo& info,
std::unique_ptr<base::DiscardableMemory> memory,
const SkSize& src_rect_offset,
@@ -1020,7 +1008,7 @@
pixmap, [](const void* pixels, void* context) {}, nullptr);
}
-SoftwareImageDecodeController::DecodedImage::~DecodedImage() {
+SoftwareImageDecodeCache::DecodedImage::~DecodedImage() {
DCHECK(!locked_);
// lock_count | used | last lock failed | result state
// ===========+=======+==================+==================
@@ -1063,7 +1051,7 @@
usage_stats_.first_lock_wasted);
}
-bool SoftwareImageDecodeController::DecodedImage::Lock() {
+bool SoftwareImageDecodeCache::DecodedImage::Lock() {
DCHECK(!locked_);
bool success = memory_->Lock();
if (!success) {
@@ -1075,7 +1063,7 @@
return true;
}
-void SoftwareImageDecodeController::DecodedImage::Unlock() {
+void SoftwareImageDecodeCache::DecodedImage::Unlock() {
DCHECK(locked_);
memory_->Unlock();
locked_ = false;
@@ -1084,35 +1072,32 @@
}
// MemoryBudget
-SoftwareImageDecodeController::MemoryBudget::MemoryBudget(size_t limit_bytes)
+SoftwareImageDecodeCache::MemoryBudget::MemoryBudget(size_t limit_bytes)
: limit_bytes_(limit_bytes), current_usage_bytes_(0u) {}
-size_t SoftwareImageDecodeController::MemoryBudget::AvailableMemoryBytes()
- const {
+size_t SoftwareImageDecodeCache::MemoryBudget::AvailableMemoryBytes() const {
size_t usage = GetCurrentUsageSafe();
return usage >= limit_bytes_ ? 0u : (limit_bytes_ - usage);
}
-void SoftwareImageDecodeController::MemoryBudget::AddUsage(size_t usage) {
+void SoftwareImageDecodeCache::MemoryBudget::AddUsage(size_t usage) {
current_usage_bytes_ += usage;
}
-void SoftwareImageDecodeController::MemoryBudget::SubtractUsage(size_t usage) {
+void SoftwareImageDecodeCache::MemoryBudget::SubtractUsage(size_t usage) {
DCHECK_GE(current_usage_bytes_.ValueOrDefault(0u), usage);
current_usage_bytes_ -= usage;
}
-void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
+void SoftwareImageDecodeCache::MemoryBudget::ResetUsage() {
current_usage_bytes_ = 0;
}
-size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
- const {
+size_t SoftwareImageDecodeCache::MemoryBudget::GetCurrentUsageSafe() const {
return current_usage_bytes_.ValueOrDie();
}
-void SoftwareImageDecodeController::OnMemoryStateChange(
- base::MemoryState state) {
+void SoftwareImageDecodeCache::OnMemoryStateChange(base::MemoryState state) {
{
base::AutoLock hold(lock_);
switch (state) {
diff --git a/cc/tiles/software_image_decode_controller.h b/cc/tiles/software_image_decode_cache.h
similarity index 85%
rename from cc/tiles/software_image_decode_controller.h
rename to cc/tiles/software_image_decode_cache.h
index f801ffc..9befb55 100644
--- a/cc/tiles/software_image_decode_controller.h
+++ b/cc/tiles/software_image_decode_cache.h
@@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
-#define CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
+#ifndef CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
+#define CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
#include <stdint.h>
@@ -24,23 +24,23 @@
#include "cc/playback/decoded_draw_image.h"
#include "cc/playback/draw_image.h"
#include "cc/resources/resource_format.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "ui/gfx/geometry/rect.h"
namespace cc {
-// ImageDecodeControllerKey is a class that gets a cache key out of a given draw
+// ImageDecodeCacheKey is a class that gets a cache key out of a given draw
// image. That is, this key uniquely identifies an image in the cache. Note that
// it's insufficient to use SkImage's unique id, since the same image can appear
// in the cache multiple times at different scales and filter qualities.
-class CC_EXPORT ImageDecodeControllerKey {
+class CC_EXPORT ImageDecodeCacheKey {
public:
- static ImageDecodeControllerKey FromDrawImage(const DrawImage& image);
+ static ImageDecodeCacheKey FromDrawImage(const DrawImage& image);
- ImageDecodeControllerKey(const ImageDecodeControllerKey& other);
+ ImageDecodeCacheKey(const ImageDecodeCacheKey& other);
- bool operator==(const ImageDecodeControllerKey& other) const {
+ bool operator==(const ImageDecodeCacheKey& other) const {
// The image_id always has to be the same. However, after that all original
// decodes are the same, so if we can use the original decode, return true.
// If not, then we have to compare every field.
@@ -52,7 +52,7 @@
filter_quality_ == other.filter_quality_));
}
- bool operator!=(const ImageDecodeControllerKey& other) const {
+ bool operator!=(const ImageDecodeCacheKey& other) const {
return !(*this == other);
}
@@ -78,12 +78,12 @@
std::string ToString() const;
private:
- ImageDecodeControllerKey(uint32_t image_id,
- const gfx::Rect& src_rect,
- const gfx::Size& size,
- SkFilterQuality filter_quality,
- bool can_use_original_decode,
- bool should_use_subrect);
+ ImageDecodeCacheKey(uint32_t image_id,
+ const gfx::Rect& src_rect,
+ const gfx::Size& size,
+ SkFilterQuality filter_quality,
+ bool can_use_original_decode,
+ bool should_use_subrect);
uint32_t image_id_;
gfx::Rect src_rect_;
@@ -94,26 +94,26 @@
size_t hash_;
};
-// Hash function for the above ImageDecodeControllerKey.
-struct ImageDecodeControllerKeyHash {
- size_t operator()(const ImageDecodeControllerKey& key) const {
+// Hash function for the above ImageDecodeCacheKey.
+struct ImageDecodeCacheKeyHash {
+ size_t operator()(const ImageDecodeCacheKey& key) const {
return key.get_hash();
}
};
-class CC_EXPORT SoftwareImageDecodeController
- : public ImageDecodeController,
+class CC_EXPORT SoftwareImageDecodeCache
+ : public ImageDecodeCache,
public base::trace_event::MemoryDumpProvider,
public base::MemoryCoordinatorClient {
public:
- using ImageKey = ImageDecodeControllerKey;
- using ImageKeyHash = ImageDecodeControllerKeyHash;
+ using ImageKey = ImageDecodeCacheKey;
+ using ImageKeyHash = ImageDecodeCacheKeyHash;
- SoftwareImageDecodeController(ResourceFormat format,
- size_t locked_memory_limit_bytes);
- ~SoftwareImageDecodeController() override;
+ SoftwareImageDecodeCache(ResourceFormat format,
+ size_t locked_memory_limit_bytes);
+ ~SoftwareImageDecodeCache() override;
- // ImageDecodeController overrides.
+ // ImageDecodeCache overrides.
bool GetTaskForImageAndRef(const DrawImage& image,
const TracingInfo& tracing_info,
scoped_refptr<TileTask>* task) override;
@@ -161,7 +161,7 @@
const base::DiscardableMemory* memory() const { return memory_.get(); }
// An ID which uniquely identifies this DecodedImage within the image decode
- // controller. Used in memory tracing.
+ // cache. Used in memory tracing.
uint64_t tracing_id() const { return tracing_id_; }
// Mark this image as being used in either a draw or as a source for a
// scaled image. Either case represents this decode as being valuable and
@@ -205,9 +205,8 @@
base::CheckedNumeric<size_t> current_usage_bytes_;
};
- using ImageMRUCache = base::HashingMRUCache<ImageKey,
- std::unique_ptr<DecodedImage>,
- ImageKeyHash>;
+ using ImageMRUCache = base::
+ HashingMRUCache<ImageKey, std::unique_ptr<DecodedImage>, ImageKeyHash>;
// Looks for the key in the cache and returns true if it was found and was
// successfully locked (or if it was already locked). Note that if this
@@ -295,4 +294,4 @@
} // namespace cc
-#endif // CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
+#endif // CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
diff --git a/cc/tiles/software_image_decode_controller_unittest.cc b/cc/tiles/software_image_decode_cache_unittest.cc
similarity index 72%
rename from cc/tiles/software_image_decode_controller_unittest.cc
rename to cc/tiles/software_image_decode_cache_unittest.cc
index cb5ef747..67855fb 100644
--- a/cc/tiles/software_image_decode_controller_unittest.cc
+++ b/cc/tiles/software_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/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
#include "cc/playback/draw_image.h"
#include "cc/resources/resource_format.h"
@@ -14,11 +14,11 @@
namespace {
size_t kLockedMemoryLimitBytes = 128 * 1024 * 1024;
-class TestSoftwareImageDecodeController : public SoftwareImageDecodeController {
+class TestSoftwareImageDecodeCache : public SoftwareImageDecodeCache {
public:
- TestSoftwareImageDecodeController()
- : SoftwareImageDecodeController(ResourceFormat::RGBA_8888,
- kLockedMemoryLimitBytes) {}
+ TestSoftwareImageDecodeCache()
+ : SoftwareImageDecodeCache(ResourceFormat::RGBA_8888,
+ kLockedMemoryLimitBytes) {}
};
sk_sp<SkImage> CreateImage(int width, int height) {
@@ -39,7 +39,7 @@
return matrix;
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyLowQuality) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyLowQuality) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality qualities[] = {kNone_SkFilterQuality, kLow_SkFilterQuality};
@@ -48,7 +48,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -60,7 +60,7 @@
}
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQuality) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQuality) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -69,7 +69,7 @@
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -78,8 +78,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyMediumQualityDropToLowIfEnlarging) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfEnlarging) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -88,7 +87,7 @@
quality,
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -97,8 +96,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyMediumQualityDropToLowIfIdentity) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityDropToLowIfIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -107,7 +105,7 @@
quality,
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -116,7 +114,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyMediumQualityDropToLowIfNearlyIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -126,7 +124,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -135,7 +133,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyMediumQualityDropToLowIfNearlyIdentity2) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -145,7 +143,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -154,7 +152,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyMediumQualityDropToLowIfNotDecomposable) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = false;
@@ -164,7 +162,7 @@
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -173,7 +171,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_5Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_5Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -182,7 +180,7 @@
quality,
CreateMatrix(SkSize::Make(1.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(500, key.target_size().width());
@@ -191,7 +189,7 @@
EXPECT_EQ(500u * 200u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt1_0cale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt1_0cale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -200,7 +198,7 @@
quality,
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(500, key.target_size().width());
@@ -209,7 +207,7 @@
EXPECT_EQ(500u * 200u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_75Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_75Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -218,7 +216,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.75f, 0.75f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(500, key.target_size().width());
@@ -227,7 +225,7 @@
EXPECT_EQ(500u * 200u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_5Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_5Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -236,7 +234,7 @@
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(250, key.target_size().width());
@@ -245,7 +243,7 @@
EXPECT_EQ(250u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_49Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_49Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -254,7 +252,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(250, key.target_size().width());
@@ -263,7 +261,7 @@
EXPECT_EQ(250u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_1Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_1Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -272,7 +270,7 @@
quality,
CreateMatrix(SkSize::Make(0.1f, 0.1f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(62, key.target_size().width());
@@ -281,7 +279,7 @@
EXPECT_EQ(62u * 25u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyMediumQualityAt0_01Scale) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyMediumQualityAt0_01Scale) {
sk_sp<SkImage> image = CreateImage(500, 200);
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -290,7 +288,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.01f, 0.01f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(7, key.target_size().width());
@@ -299,7 +297,7 @@
EXPECT_EQ(7u * 3u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyPartialDowscalesDropsHighQualityToMedium) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -309,7 +307,7 @@
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -318,7 +316,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyFullDowscalesDropsHighQualityToMedium) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -328,7 +326,7 @@
quality,
CreateMatrix(SkSize::Make(0.5f, 0.2f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(50, key.target_size().width());
@@ -337,7 +335,7 @@
EXPECT_EQ(50u * 50u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, ImageKeyDowscalesHighQuality) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyDowscalesHighQuality) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -346,7 +344,7 @@
quality,
CreateMatrix(SkSize::Make(2.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(quality, key.filter_quality());
EXPECT_EQ(250, key.target_size().width());
@@ -355,8 +353,7 @@
EXPECT_EQ(250u * 150u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyHighQualityDropToMediumIfTooLarge) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToMediumIfTooLarge) {
// Just over 64MB when scaled.
sk_sp<SkImage> image = CreateImage(4555, 2048);
bool is_decomposable = true;
@@ -368,7 +365,7 @@
quality,
CreateMatrix(SkSize::Make(0.9f, 2.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(4555, key.target_size().width());
@@ -377,7 +374,7 @@
EXPECT_EQ(4555u * 2048u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyHighQualityDropToLowIfNotDecomposable) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = false;
@@ -387,7 +384,7 @@
quality,
CreateMatrix(SkSize::Make(0.5f, 1.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -396,8 +393,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageKeyHighQualityDropToLowIfIdentity) {
+TEST(SoftwareImageDecodeCacheTest, ImageKeyHighQualityDropToLowIfIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -406,7 +402,7 @@
quality,
CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -415,7 +411,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyHighQualityDropToLowIfNearlyIdentity) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -425,7 +421,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(1.001f, 1.001f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -434,7 +430,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
ImageKeyHighQualityDropToLowIfNearlyIdentity2) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -444,7 +440,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.999f, 0.999f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -453,7 +449,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, OriginalDecodesAreEqual) {
+TEST(SoftwareImageDecodeCacheTest, OriginalDecodesAreEqual) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -462,7 +458,7 @@
quality,
CreateMatrix(SkSize::Make(0.5f, 0.5), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -474,8 +470,7 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(1.5f, 1.5), is_decomposable));
- auto another_key =
- ImageDecodeControllerKey::FromDrawImage(another_draw_image);
+ auto another_key = ImageDecodeCacheKey::FromDrawImage(another_draw_image);
EXPECT_EQ(image->uniqueID(), another_key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, another_key.filter_quality());
EXPECT_EQ(100, another_key.target_size().width());
@@ -486,7 +481,7 @@
EXPECT_TRUE(key == another_key);
}
-TEST(SoftwareImageDecodeControllerTest, ImageRectDoesNotContainSrcRect) {
+TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRect) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -495,7 +490,7 @@
image, SkIRect::MakeXYWH(25, 35, image->width(), image->height()),
quality, CreateMatrix(SkSize::Make(1.f, 1.f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kLow_SkFilterQuality, key.filter_quality());
EXPECT_EQ(100, key.target_size().width());
@@ -504,8 +499,7 @@
EXPECT_EQ(100u * 100u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest,
- ImageRectDoesNotContainSrcRectWithScale) {
+TEST(SoftwareImageDecodeCacheTest, ImageRectDoesNotContainSrcRectWithScale) {
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -514,7 +508,7 @@
image, SkIRect::MakeXYWH(20, 30, image->width(), image->height()),
quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
- auto key = ImageDecodeControllerKey::FromDrawImage(draw_image);
+ auto key = ImageDecodeCacheKey::FromDrawImage(draw_image);
EXPECT_EQ(image->uniqueID(), key.image_id());
EXPECT_EQ(kMedium_SkFilterQuality, key.filter_quality());
EXPECT_EQ(40, key.target_size().width());
@@ -523,8 +517,8 @@
EXPECT_EQ(40u * 35u * 4u, key.locked_bytes());
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImage) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImage) {
+ TestSoftwareImageDecodeCache cache;
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -533,8 +527,8 @@
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);
@@ -542,20 +536,19 @@
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.get());
- controller.UnrefImage(draw_image);
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
- GetTaskForImageSameImageDifferentQuality) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentQuality) {
+ TestSoftwareImageDecodeCache cache;
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
@@ -564,9 +557,9 @@
kHigh_SkFilterQuality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> high_quality_task;
- bool need_unref = controller.GetTaskForImageAndRef(
- high_quality_draw_image, ImageDecodeController::TracingInfo(),
- &high_quality_task);
+ bool need_unref = cache.GetTaskForImageAndRef(high_quality_draw_image,
+ ImageDecodeCache::TracingInfo(),
+ &high_quality_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(high_quality_task);
@@ -575,9 +568,9 @@
kLow_SkFilterQuality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> low_quality_task;
- need_unref = controller.GetTaskForImageAndRef(
- low_quality_draw_image, ImageDecodeController::TracingInfo(),
- &low_quality_task);
+ need_unref = cache.GetTaskForImageAndRef(low_quality_draw_image,
+ ImageDecodeCache::TracingInfo(),
+ &low_quality_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(low_quality_task);
EXPECT_TRUE(high_quality_task.get() != low_quality_task.get());
@@ -585,12 +578,12 @@
TestTileTaskRunner::ProcessTask(high_quality_task.get());
TestTileTaskRunner::ProcessTask(low_quality_task.get());
- controller.UnrefImage(high_quality_draw_image);
- controller.UnrefImage(low_quality_draw_image);
+ cache.UnrefImage(high_quality_draw_image);
+ cache.UnrefImage(low_quality_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageSameImageDifferentSize) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageSameImageDifferentSize) {
+ TestSoftwareImageDecodeCache cache;
sk_sp<SkImage> image = CreateImage(100, 100);
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -599,9 +592,8 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
scoped_refptr<TileTask> half_size_task;
- bool need_unref = controller.GetTaskForImageAndRef(
- half_size_draw_image, ImageDecodeController::TracingInfo(),
- &half_size_task);
+ bool need_unref = cache.GetTaskForImageAndRef(
+ half_size_draw_image, ImageDecodeCache::TracingInfo(), &half_size_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(half_size_task);
@@ -609,9 +601,9 @@
image, SkIRect::MakeWH(image->width(), image->height()), quality,
CreateMatrix(SkSize::Make(0.25f, 0.25f), is_decomposable));
scoped_refptr<TileTask> quarter_size_task;
- need_unref = controller.GetTaskForImageAndRef(
- quarter_size_draw_image, ImageDecodeController::TracingInfo(),
- &quarter_size_task);
+ need_unref = cache.GetTaskForImageAndRef(quarter_size_draw_image,
+ ImageDecodeCache::TracingInfo(),
+ &quarter_size_task);
EXPECT_TRUE(need_unref);
EXPECT_TRUE(quarter_size_task);
EXPECT_TRUE(half_size_task.get() != quarter_size_task.get());
@@ -619,12 +611,12 @@
TestTileTaskRunner::ProcessTask(half_size_task.get());
TestTileTaskRunner::ProcessTask(quarter_size_task.get());
- controller.UnrefImage(half_size_draw_image);
- controller.UnrefImage(quarter_size_draw_image);
+ cache.UnrefImage(half_size_draw_image);
+ cache.UnrefImage(quarter_size_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetTaskForImageDifferentImage) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageDifferentImage) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -633,8 +625,8 @@
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);
@@ -644,8 +636,8 @@
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());
@@ -653,12 +645,12 @@
TestTileTaskRunner::ProcessTask(first_task.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(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyDecoded) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyDecoded) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -667,8 +659,8 @@
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);
@@ -676,19 +668,19 @@
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(SoftwareImageDecodeControllerTest, GetTaskForImageAlreadyPrerolled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageAlreadyPrerolled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -697,8 +689,8 @@
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_TRUE(need_unref);
EXPECT_TRUE(task);
@@ -706,26 +698,26 @@
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());
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_FALSE(third_task);
- 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(SoftwareImageDecodeControllerTest, GetTaskForImageCanceledGetsNewTask) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetTaskForImageCanceledGetsNewTask) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -734,14 +726,14 @@
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);
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());
@@ -750,25 +742,25 @@
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());
TestTileTaskRunner::ProcessTask(third_task.get());
- controller.UnrefImage(draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetTaskForImageCanceledWhileReffedGetsNewTask) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -777,14 +769,14 @@
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);
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());
@@ -795,8 +787,8 @@
// 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());
@@ -804,13 +796,13 @@
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(SoftwareImageDecodeControllerTest, GetDecodedImageForDraw) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDraw) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -819,15 +811,15 @@
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.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -837,13 +829,13 @@
EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawWithNonContainedSrcRect) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -852,15 +844,15 @@
image, SkIRect::MakeXYWH(20, 30, 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);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(40, decoded_draw_image.image()->width());
EXPECT_EQ(35, decoded_draw_image.image()->height());
@@ -870,12 +862,12 @@
EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, GetDecodedImageForDrawAtRasterDecode) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, GetDecodedImageForDrawAtRasterDecode) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -885,7 +877,7 @@
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -895,12 +887,12 @@
EXPECT_FALSE(decoded_draw_image.is_scale_adjustment_identity());
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawAtRasterDecodeMultipleTimes) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -910,7 +902,7 @@
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -921,17 +913,17 @@
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
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(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawAtRasterDecodeDoesNotPreventTasks) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -941,7 +933,7 @@
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -952,15 +944,15 @@
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
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.get());
DecodedDrawImage another_decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
// This should get the new decoded/locked image, not the one we're using at
// raster.
// TODO(vmpstr): We can possibly optimize this so that the decode simply moves
@@ -969,14 +961,14 @@
another_decoded_draw_image.image()->uniqueID());
EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, another_decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
GetDecodedImageForDrawAtRasterDecodeIsUsedForLockedCache) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -986,7 +978,7 @@
CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable));
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
EXPECT_EQ(50, decoded_draw_image.image()->width());
EXPECT_EQ(50, decoded_draw_image.image()->height());
@@ -997,31 +989,31 @@
EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
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);
// If we finish the draw here, then we will use it for the locked decode
// instead of decoding again.
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage another_decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
// This should get the decoded/locked image which we originally decoded at
// raster time, since it's now in the locked cache.
EXPECT_EQ(decoded_draw_image.image()->uniqueID(),
another_decoded_draw_image.image()->uniqueID());
EXPECT_FALSE(another_decoded_draw_image.is_at_raster_decode());
- controller.DrawWithImageFinished(draw_image, another_decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, another_decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, ZeroSizedImagesAreSkipped) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, ZeroSizedImagesAreSkipped) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -1031,20 +1023,20 @@
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);
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(SoftwareImageDecodeControllerTest, NonOverlappingSrcRectImagesAreSkipped) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, NonOverlappingSrcRectImagesAreSkipped) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kHigh_SkFilterQuality;
@@ -1054,20 +1046,20 @@
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);
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(SoftwareImageDecodeControllerTest, LowQualityFilterIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, LowQualityFilterIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -1077,26 +1069,26 @@
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_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImage object.
EXPECT_TRUE(decoded_draw_image.image() != image);
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, LowQualityScaledSubrectIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, LowQualityScaledSubrectIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kLow_SkFilterQuality;
@@ -1105,15 +1097,15 @@
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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImage object.
@@ -1121,12 +1113,12 @@
EXPECT_EQ(kLow_SkFilterQuality, decoded_draw_image.filter_quality());
EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, NoneQualityScaledSubrectIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, NoneQualityScaledSubrectIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kNone_SkFilterQuality;
@@ -1135,15 +1127,15 @@
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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImage object.
@@ -1151,12 +1143,12 @@
EXPECT_EQ(kNone_SkFilterQuality, decoded_draw_image.filter_quality());
EXPECT_TRUE(decoded_draw_image.is_scale_adjustment_identity());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt01_5ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt01_5ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1166,15 +1158,15 @@
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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1183,12 +1175,12 @@
EXPECT_EQ(500, decoded_draw_image.image()->width());
EXPECT_EQ(200, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt1_0ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt1_0ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1198,15 +1190,15 @@
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_TRUE(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1215,12 +1207,12 @@
EXPECT_EQ(500, decoded_draw_image.image()->width());
EXPECT_EQ(200, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_75ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_75ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1230,15 +1222,15 @@
CreateMatrix(SkSize::Make(0.75f, 0.75f), 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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1247,12 +1239,12 @@
EXPECT_EQ(500, decoded_draw_image.image()->width());
EXPECT_EQ(200, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_5ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_5ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1262,15 +1254,15 @@
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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1279,12 +1271,12 @@
EXPECT_EQ(250, decoded_draw_image.image()->width());
EXPECT_EQ(100, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_49ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_49ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1294,15 +1286,15 @@
CreateMatrix(SkSize::Make(0.49f, 0.49f), 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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1311,12 +1303,12 @@
EXPECT_EQ(250, decoded_draw_image.image()->width());
EXPECT_EQ(100, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_1ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_1ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1326,15 +1318,15 @@
CreateMatrix(SkSize::Make(0.1f, 0.1f), 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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1343,12 +1335,12 @@
EXPECT_EQ(62, decoded_draw_image.image()->width());
EXPECT_EQ(25, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_01ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_01ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1358,15 +1350,15 @@
CreateMatrix(SkSize::Make(0.01f, 0.01f), 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(task);
EXPECT_TRUE(need_unref);
TestTileTaskRunner::ProcessTask(task.get());
DecodedDrawImage decoded_draw_image =
- controller.GetDecodedImageForDraw(draw_image);
+ cache.GetDecodedImageForDraw(draw_image);
EXPECT_TRUE(decoded_draw_image.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1375,12 +1367,12 @@
EXPECT_EQ(7, decoded_draw_image.image()->width());
EXPECT_EQ(3, decoded_draw_image.image()->height());
- controller.DrawWithImageFinished(draw_image, decoded_draw_image);
- controller.UnrefImage(draw_image);
+ cache.DrawWithImageFinished(draw_image, decoded_draw_image);
+ cache.UnrefImage(draw_image);
}
-TEST(SoftwareImageDecodeControllerTest, MediumQualityAt0_001ScaleIsHandled) {
- TestSoftwareImageDecodeController controller;
+TEST(SoftwareImageDecodeCacheTest, MediumQualityAt0_001ScaleIsHandled) {
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1390,21 +1382,21 @@
CreateMatrix(SkSize::Make(0.001f, 0.001f), 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);
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(SoftwareImageDecodeControllerTest,
+TEST(SoftwareImageDecodeCacheTest,
MediumQualityImagesAreTheSameAt0_5And0_49Scale) {
- TestSoftwareImageDecodeController controller;
+ TestSoftwareImageDecodeCache cache;
bool is_decomposable = true;
SkFilterQuality quality = kMedium_SkFilterQuality;
@@ -1417,23 +1409,23 @@
CreateMatrix(SkSize::Make(0.49f, 0.49f), is_decomposable));
scoped_refptr<TileTask> task_50;
- bool need_unref_50 = controller.GetTaskForImageAndRef(
- draw_image_50, ImageDecodeController::TracingInfo(), &task_50);
+ bool need_unref_50 = cache.GetTaskForImageAndRef(
+ draw_image_50, ImageDecodeCache::TracingInfo(), &task_50);
EXPECT_TRUE(task_50);
EXPECT_TRUE(need_unref_50);
scoped_refptr<TileTask> task_49;
- bool need_unref_49 = controller.GetTaskForImageAndRef(
- draw_image_49, ImageDecodeController::TracingInfo(), &task_49);
+ bool need_unref_49 = cache.GetTaskForImageAndRef(
+ draw_image_49, ImageDecodeCache::TracingInfo(), &task_49);
EXPECT_TRUE(task_49);
EXPECT_TRUE(need_unref_49);
TestTileTaskRunner::ProcessTask(task_49.get());
DecodedDrawImage decoded_draw_image_50 =
- controller.GetDecodedImageForDraw(draw_image_50);
+ cache.GetDecodedImageForDraw(draw_image_50);
EXPECT_TRUE(decoded_draw_image_50.image());
DecodedDrawImage decoded_draw_image_49 =
- controller.GetDecodedImageForDraw(draw_image_49);
+ cache.GetDecodedImageForDraw(draw_image_49);
EXPECT_TRUE(decoded_draw_image_49.image());
// If we decoded the image and cached it, it would be stored in a different
// SkImageObject.
@@ -1448,10 +1440,10 @@
EXPECT_EQ(decoded_draw_image_50.image(), decoded_draw_image_49.image());
- controller.DrawWithImageFinished(draw_image_50, decoded_draw_image_50);
- controller.UnrefImage(draw_image_50);
- controller.DrawWithImageFinished(draw_image_49, decoded_draw_image_49);
- controller.UnrefImage(draw_image_49);
+ cache.DrawWithImageFinished(draw_image_50, decoded_draw_image_50);
+ cache.UnrefImage(draw_image_50);
+ cache.DrawWithImageFinished(draw_image_49, decoded_draw_image_49);
+ cache.UnrefImage(draw_image_49);
}
} // namespace
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 71d8471..b9a9fc5 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -395,12 +395,12 @@
signals_check_notifier_.Cancel();
task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
- image_manager_.SetImageDecodeController(nullptr);
+ image_manager_.SetImageDecodeCache(nullptr);
locked_image_tasks_.clear();
}
void TileManager::SetResources(ResourcePool* resource_pool,
- ImageDecodeController* image_decode_controller,
+ ImageDecodeCache* image_decode_cache,
TaskGraphRunner* task_graph_runner,
RasterBufferProvider* raster_buffer_provider,
size_t scheduled_raster_task_limit,
@@ -411,7 +411,7 @@
use_gpu_rasterization_ = use_gpu_rasterization;
scheduled_raster_task_limit_ = scheduled_raster_task_limit;
resource_pool_ = resource_pool;
- image_manager_.SetImageDecodeController(image_decode_controller);
+ image_manager_.SetImageDecodeCache(image_decode_cache);
tile_task_manager_ = TileTaskManagerImpl::Create(task_graph_runner);
raster_buffer_provider_ = raster_buffer_provider;
}
@@ -892,8 +892,8 @@
// TODO(vmpstr): SOON is misleading here, but these images can come from
// several diffent tiles. Rethink what we actually want to trace here. Note
// that I'm using SOON, since it can't be NOW (these are prepaint).
- ImageDecodeController::TracingInfo tracing_info(prepare_tiles_count_,
- TilePriority::SOON);
+ ImageDecodeCache::TracingInfo tracing_info(prepare_tiles_count_,
+ TilePriority::SOON);
std::vector<scoped_refptr<TileTask>> new_locked_image_tasks =
image_manager_.SetPredecodeImages(std::move(new_locked_images),
tracing_info);
@@ -994,7 +994,7 @@
playback_settings.use_image_hijack_canvas = !images.empty();
// Get the tasks for the required images.
- ImageDecodeController::TracingInfo tracing_info(
+ ImageDecodeCache::TracingInfo tracing_info(
prepare_tiles_count_, prioritized_tile.priority().priority_bin);
image_manager_.GetTasksForImagesAndRef(&images, &decode_tasks, tracing_info);
@@ -1164,7 +1164,7 @@
// images since we're technically going idle here at least for this frame.
if (global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY) {
image_manager_.SetPredecodeImages(std::vector<DrawImage>(),
- ImageDecodeController::TracingInfo());
+ ImageDecodeCache::TracingInfo());
locked_image_tasks_.clear();
}
diff --git a/cc/tiles/tile_manager.h b/cc/tiles/tile_manager.h
index 732bc51..c65c27e 100644
--- a/cc/tiles/tile_manager.h
+++ b/cc/tiles/tile_manager.h
@@ -36,7 +36,7 @@
}
namespace cc {
-class ImageDecodeController;
+class ImageDecodeCache;
class CC_EXPORT TileManagerClient {
public:
@@ -119,7 +119,7 @@
// FinishTasksAndCleanUp must be called in between consecutive calls to
// SetResources.
void SetResources(ResourcePool* resource_pool,
- ImageDecodeController* image_decode_controller,
+ ImageDecodeCache* image_decode_cache,
TaskGraphRunner* task_graph_runner,
RasterBufferProvider* raster_buffer_provider,
size_t scheduled_raster_task_limit,
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index d33bc07..b8fff40e 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -67,10 +67,10 @@
#include "cc/resources/ui_resource_bitmap.h"
#include "cc/scheduler/delay_based_time_source.h"
#include "cc/tiles/eviction_tile_priority_queue.h"
-#include "cc/tiles/gpu_image_decode_controller.h"
+#include "cc/tiles/gpu_image_decode_cache.h"
#include "cc/tiles/picture_layer_tiling.h"
#include "cc/tiles/raster_tile_priority_queue.h"
-#include "cc/tiles/software_image_decode_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
#include "cc/trees/damage_tracker.h"
#include "cc/trees/draw_property_utils.h"
#include "cc/trees/latency_info_swap_promise_monitor.h"
@@ -286,7 +286,7 @@
DCHECK(!resource_provider_);
DCHECK(!resource_pool_);
DCHECK(!single_thread_synchronous_task_graph_runner_);
- DCHECK(!image_decode_controller_);
+ DCHECK(!image_decode_cache_);
if (input_handler_client_) {
input_handler_client_->WillShutdown();
@@ -1236,8 +1236,8 @@
// allow the image decode controller to retain resources. We handle the
// equal to 0 case in NotifyAllTileTasksComplete to avoid interrupting
// running work.
- if (image_decode_controller_)
- image_decode_controller_->SetShouldAggressivelyFreeResources(false);
+ if (image_decode_cache_)
+ image_decode_cache_->SetShouldAggressivelyFreeResources(false);
}
DCHECK(resource_pool_);
@@ -1320,8 +1320,8 @@
// contexts of visibility change. This ensures that the imaged decode
// controller has released all Skia refs at the time Skia's cleanup
// executes (within worker context's cleanup).
- if (image_decode_controller_)
- image_decode_controller_->SetShouldAggressivelyFreeResources(true);
+ if (image_decode_cache_)
+ image_decode_cache_->SetShouldAggressivelyFreeResources(true);
SetContextVisibility(false);
}
}
@@ -2106,12 +2106,12 @@
&resource_pool_);
if (use_gpu_rasterization_) {
- image_decode_controller_ = base::MakeUnique<GpuImageDecodeController>(
+ image_decode_cache_ = base::MakeUnique<GpuImageDecodeCache>(
compositor_frame_sink_->worker_context_provider(),
settings_.renderer_settings.preferred_tile_format,
settings_.gpu_decoded_image_budget_bytes);
} else {
- image_decode_controller_ = base::MakeUnique<SoftwareImageDecodeController>(
+ image_decode_cache_ = base::MakeUnique<SoftwareImageDecodeCache>(
settings_.renderer_settings.preferred_tile_format,
settings_.software_decoded_image_budget_bytes);
}
@@ -2127,12 +2127,12 @@
}
// TODO(vmpstr): Initialize tile task limit at ctor time.
- tile_manager_.SetResources(
- resource_pool_.get(), image_decode_controller_.get(), task_graph_runner,
- raster_buffer_provider_.get(),
- is_synchronous_single_threaded_ ? std::numeric_limits<size_t>::max()
- : settings_.scheduled_raster_task_limit,
- use_gpu_rasterization_);
+ tile_manager_.SetResources(resource_pool_.get(), image_decode_cache_.get(),
+ task_graph_runner, raster_buffer_provider_.get(),
+ is_synchronous_single_threaded_
+ ? std::numeric_limits<size_t>::max()
+ : settings_.scheduled_raster_task_limit,
+ use_gpu_rasterization_);
UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
}
@@ -2237,7 +2237,7 @@
tile_manager_.FinishTasksAndCleanUp();
resource_pool_ = nullptr;
single_thread_synchronous_task_graph_runner_ = nullptr;
- image_decode_controller_ = nullptr;
+ image_decode_cache_ = nullptr;
// We've potentially just freed a large number of resources on our various
// contexts. Flushing now helps ensure these are cleaned up quickly
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 725a182..2bbf782 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -36,7 +36,7 @@
#include "cc/scheduler/commit_earlyout_reason.h"
#include "cc/scheduler/draw_result.h"
#include "cc/scheduler/video_frame_controller.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
#include "cc/tiles/tile_manager.h"
#include "cc/trees/layer_tree_mutator.h"
#include "cc/trees/layer_tree_settings.h"
@@ -404,9 +404,7 @@
return settings_.create_low_res_tiling && !use_gpu_rasterization_;
}
ResourcePool* resource_pool() { return resource_pool_.get(); }
- ImageDecodeController* image_decode_controller() {
- return image_decode_controller_.get();
- }
+ ImageDecodeCache* image_decode_cache() { return image_decode_cache_.get(); }
virtual void WillBeginImplFrame(const BeginFrameArgs& args);
virtual void DidFinishImplFrame();
@@ -711,7 +709,7 @@
GpuRasterizationStatus gpu_rasterization_status_;
std::unique_ptr<RasterBufferProvider> raster_buffer_provider_;
std::unique_ptr<ResourcePool> resource_pool_;
- std::unique_ptr<ImageDecodeController> image_decode_controller_;
+ std::unique_ptr<ImageDecodeCache> image_decode_cache_;
GlobalStateThatImpactsTilePriority global_tile_state_;
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index edfd5b0a..3a475e1 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -1281,8 +1281,8 @@
return layer_tree_host_impl_->tile_manager();
}
-ImageDecodeController* LayerTreeImpl::image_decode_controller() const {
- return layer_tree_host_impl_->image_decode_controller();
+ImageDecodeCache* LayerTreeImpl::image_decode_cache() const {
+ return layer_tree_host_impl_->image_decode_cache();
}
FrameRateCounter* LayerTreeImpl::frame_rate_counter() const {
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index ad4edc3..27a41294 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -37,7 +37,7 @@
class DebugRectHistory;
class FrameRateCounter;
class HeadsUpDisplayLayerImpl;
-class ImageDecodeController;
+class ImageDecodeCache;
class LayerTreeDebugState;
class LayerTreeImpl;
class LayerTreeSettings;
@@ -77,7 +77,7 @@
ContextProvider* context_provider() const;
ResourceProvider* resource_provider() const;
TileManager* tile_manager() const;
- ImageDecodeController* image_decode_controller() const;
+ ImageDecodeCache* image_decode_cache() const;
FrameRateCounter* frame_rate_counter() const;
MemoryHistory* memory_history() const;
gfx::Size device_viewport_size() const;