Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(941)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: tests/CachedDecodingPixelRefTest.cpp

Issue 54203006: Break up SkLazyPixelRef functionally into class hierarchy. (Closed) Base URL: https://skia.googlecode.com/svn/trunk
Patch Set: lint nits Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« src/lazy/SkCachingPixelRef.h ('K') | « src/lazy/SkLazyCachingPixelRef.cpp ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: tests/CachedDecodingPixelRefTest.cpp
diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index e3b249923eb98386d474734e395c38f4c55aa0fb..68de2733fe0838243b841c669d017c25ffcf93e7 100644
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -11,10 +11,13 @@
#include "SkForceLinking.h"
#include "SkImageDecoder.h"
#include "SkImagePriv.h"
+#include "SkLazyCachingPixelRef.h"
#include "SkLazyPixelRef.h"
#include "SkScaledImageCache.h"
#include "SkStream.h"
+
#include "Test.h"
+#include "TestClassDef.h"
__SK_FORCE_IMAGE_DECODER_LINKING;
@@ -92,6 +95,7 @@ static void compare_bitmaps(skiatest::Reporter* reporter,
if (!pixelPerfect) {
return;
}
+
int pixelErrors = 0;
for (int y = 0; y < b2.height(); ++y) {
for (int x = 0; x < b2.width(); ++x) {
@@ -103,101 +107,159 @@ static void compare_bitmaps(skiatest::Reporter* reporter,
REPORTER_ASSERT(reporter, 0 == pixelErrors);
}
+
+typedef void(*CompareEncodedToOriginal)(skiatest::Reporter* reporter,
+ SkData* encoded,
+ const SkBitmap& original,
+ bool pixelPerfect);
/**
- * This checks to see that a SkLazyPixelRef works as advertized.
- */
-#include "TestClassDef.h"
-DEF_TEST(CachedDecodingPixelRefTest, reporter) {
+ this function tests three differently encoded images against the
+ origianl bitmap */
+void testThreeEncodings(skiatest::Reporter* reporter,
scroggo 2013/11/01 15:48:00 This function should be static. Also, static func
hal.canary 2013/11/01 16:31:09 Done.
+ CompareEncodedToOriginal comp) {
SkBitmap original;
make_test_image(&original);
- const size_t bitmapSize = original.getSize();
- const size_t oldByteLimit = SkScaledImageCache::GetByteLimit();
- REPORTER_ASSERT(reporter, (!(original.empty())) && (!(original.isNull())));
-
+ REPORTER_ASSERT(reporter, !original.empty());
+ REPORTER_ASSERT(reporter, !original.isNull());
+ if (original.empty() || original.isNull()) {
+ return;
+ }
static const SkImageEncoder::Type types[] = {
SkImageEncoder::kPNG_Type,
SkImageEncoder::kJPEG_Type,
SkImageEncoder::kWEBP_Type
};
-
for (size_t i = 0; i < SK_ARRAY_COUNT(types); i++) {
SkImageEncoder::Type type = types[i];
SkAutoDataUnref encoded(create_data_from_bitmap(original, type));
REPORTER_ASSERT(reporter, encoded.get() != NULL);
- if (NULL == encoded.get()) {
- continue;
+ if (NULL != encoded.get()) {
+ bool comparePixels = (SkImageEncoder::kPNG_Type == type);
+ comp(reporter, encoded, original, comparePixels);
}
- SkBitmap lazy;
- static const SkBitmapFactory::DecodeProc decoder =
- &(SkImageDecoder::DecodeMemoryToTarget);
- bool success = simple_bitmap_factory(decoder, encoded.get(), &lazy);
+ }
+}
- REPORTER_ASSERT(reporter, success);
+/**
+ * This checks to see that a SkLazyPixelRef works as advertised.
+ */
+void compareWithSkLazyPixelRef(skiatest::Reporter* reporter,
scroggo 2013/11/01 15:48:00 ditto
hal.canary 2013/11/01 16:31:09 Done.
+ SkData* encoded,
+ const SkBitmap& original,
+ bool comparePixels) {
+ SkBitmap lazy;
+ static const SkBitmapFactory::DecodeProc decoder =
+ &(SkImageDecoder::DecodeMemoryToTarget);
+ bool success = simple_bitmap_factory(decoder, encoded, &lazy);
+ REPORTER_ASSERT(reporter, success);
- size_t bytesUsed = SkScaledImageCache::GetBytesUsed();
+ REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+ {
+ SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
+ REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+ }
+ // pixels should be gone!
+ REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+ {
+ SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
+ REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+ }
+ compare_bitmaps(reporter, original, lazy, comparePixels);
+}
+DEF_TEST(CachedDecodingPixelRefTest, reporter) {
+ testThreeEncodings(reporter, compareWithSkLazyPixelRef);
+}
- if (oldByteLimit < bitmapSize) {
- SkScaledImageCache::SetByteLimit(bitmapSize + oldByteLimit);
- }
- void* lazyPixels = NULL;
-
- // Since this is lazy, it shouldn't have fPixels yet!
- REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
- {
- SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
- lazyPixels = lazy.getPixels();
- REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
- // first time we lock pixels, we should get bump in the size
- // of the cache by exactly bitmapSize.
- REPORTER_ASSERT(reporter, bytesUsed + bitmapSize
- == SkScaledImageCache::GetBytesUsed());
- bytesUsed = SkScaledImageCache::GetBytesUsed();
- }
- // pixels should be gone!
- REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
- {
- SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
- REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
-
- // verify that the same pixels are used this time.
- REPORTER_ASSERT(reporter, lazy.getPixels() == lazyPixels);
- }
- bool comparePixels = (SkImageEncoder::kPNG_Type == type);
- // Only PNG is pixel-perfect.
- compare_bitmaps(reporter, original, lazy, comparePixels);
-
- // force the cache to clear by making it too small.
- SkScaledImageCache::SetByteLimit(bitmapSize / 2);
- compare_bitmaps(reporter, original, lazy, comparePixels);
-
- // I'm pretty sure that the logic of the cache should mean
- // that it will clear to zero, regardless of where it started.
- REPORTER_ASSERT(reporter, SkScaledImageCache::GetBytesUsed() == 0);
- // TODO(someone) - write a custom allocator that can verify
- // that the memory where those pixels were cached really did
- // get freed.
-
- ////////////////////////////////////////////////////////////////////////
- // The following commented-out code happens to work on my
- // machine, and indicates to me that the SkLazyPixelRef is
- // behaving as designed. But I don't know an easy way to
- // guarantee that a second allocation of the same size will
- // give a different address.
- ////////////////////////////////////////////////////////////////////////
- // {
- // // confuse the heap allocation system
- // SkAutoMalloc autoMalloc(bitmapSize);
- // REPORTER_ASSERT(reporter, autoMalloc.get() == lazyPixels);
- // {
- // SkAutoLockPixels autoLockPixels(lazy);
- // // verify that *different* pixels are used this time.
- // REPORTER_ASSERT(reporter, lazy.getPixels() != lazyPixels);
- // compare_bitmaps(reporter, original, lazy, comparePixels);
- // }
- // }
-
- // restore cache size
- SkScaledImageCache::SetByteLimit(oldByteLimit);
+
+/**
+ * This checks to see that a SkLazyCachedPixelRef works as advertised.
+ */
+
+void compareWithLazyCachedPixelRef(skiatest::Reporter* reporter,
scroggo 2013/11/01 15:48:00 ditto
hal.canary 2013/11/01 16:31:09 Done.
+ SkData* encoded,
+ const SkBitmap& original,
+ bool comparePixels) {
+ const size_t bitmapSize = original.getSize();
+ // By using a non-global cache, our unit tests won't collide with
+ // other unit tests. Unit tests can be run in separate threads.
+ // TODO(halcanary): Find a way to robustly test the global
+ // instance of SkScaledImageCache.
+ SkScaledImageCache cache(2000000, NULL);
+ const size_t oldByteLimit = cache.getByteLimit();
+ SkBitmap lazy;
+ static const SkBitmapFactory::DecodeProc decoder =
+ &(SkImageDecoder::DecodeMemoryToTarget);
+
+ bool success = SkLazyCachingPixelRef::Install(decoder, encoded,
+ &lazy, &cache);
+ REPORTER_ASSERT(reporter, success);
+
+ size_t bytesUsed = cache.getBytesUsed();
+
+ if (oldByteLimit < bitmapSize) {
+ cache.setByteLimit(bitmapSize + oldByteLimit);
}
+ void* lazyPixels = NULL;
+
+ // Since this is lazy, it shouldn't have fPixels yet!
+ REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+ {
+ SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
+ lazyPixels = lazy.getPixels();
+ REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+ // first time we lock pixels, we should get bump in the size
+ // of the cache by exactly bitmapSize.
+ REPORTER_ASSERT(reporter, bytesUsed + bitmapSize
+ == cache.getBytesUsed());
+ bytesUsed = cache.getBytesUsed();
+ }
+ // pixels should be gone!
+ REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+ {
+ SkAutoLockPixels autoLockPixels(lazy); // now pixels are good.
+ REPORTER_ASSERT(reporter, NULL != lazy.getPixels());
+
+ // verify that the same pixels are used this time.
+ REPORTER_ASSERT(reporter, lazy.getPixels() == lazyPixels);
+ }
+
+ // Only PNG is pixel-perfect.
+ compare_bitmaps(reporter, original, lazy, comparePixels);
+
+ // force the cache to clear by making it too small.
+ cache.setByteLimit(bitmapSize / 2);
+
+ compare_bitmaps(reporter, original, lazy, comparePixels);
+
+ // I'm pretty sure that the logic of the cache should mean
+ // that it will clear to zero, regardless of where it started.
+ REPORTER_ASSERT(reporter, NULL == lazy.getPixels());
+ REPORTER_ASSERT(reporter, cache.getBytesUsed() == 0);
+ // TODO(someone) - write a custom allocator that can verify
+ // that the memory where those pixels were cached really did
+ // get freed.
+
+ ////////////////////////////////////////////////////////////////////////
+ // The following commented-out code happens to work on my
+ // machine, and indicates to me that the SkLazyPixelRef is
+ // behaving as designed. But I don't know an easy way to
+ // guarantee that a second allocation of the same size will
+ // give a different address.
+ ////////////////////////////////////////////////////////////////////////
+ // {
+ // // confuse the heap allocation system
+ // SkAutoMalloc autoMalloc(bitmapSize);
+ // REPORTER_ASSERT(reporter, autoMalloc.get() == lazyPixels);
+ // {
+ // SkAutoLockPixels autoLockPixels(lazy);
+ // // verify that *different* pixels are used this time.
+ // REPORTER_ASSERT(reporter, lazy.getPixels() != lazyPixels);
+ // compare_bitmaps(reporter, original, lazy, comparePixels);
+ // }
+ // }
}
+DEF_TEST(LazyCachedPixelRefTest, reporter) {
+ testThreeEncodings(reporter, compareWithLazyCachedPixelRef);
+}
+
« src/lazy/SkCachingPixelRef.h ('K') | « src/lazy/SkLazyCachingPixelRef.cpp ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698