diff options
author | benjaminwagner <benjaminwagner@google.com> | 2015-09-23 11:53:36 -0700 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2015-09-23 11:53:37 -0700 |
commit | 60c73d51808b9d78f65381b83f628a3f523042fe (patch) | |
tree | d100633576080e72cc65dd20dab46bfc80af6038 | |
parent | a1a8a601ae5dd3d29406610f39945f6c17f34b50 (diff) |
Revert of remove unused SkCachingPixelRef (patchset #1 id:1 of https://codereview.chromium.org/1364743002/ )
Reason for revert:
Build failure: https://uberchromegw.corp.google.com/i/client.skia.compile/builders/Build-Ubuntu-GCC-Arm7-Debug-Android_FrameworkDefs/builds/1146
Original issue's description:
> remove unused SkCachingPixelRef
>
> BUG=skia:
> TBR=
>
> Committed: https://skia.googlesource.com/skia/+/70d58b7da535e32bcac35739d11ab8367e99f224
TBR=halcanary@google.com,reed@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:
Review URL: https://codereview.chromium.org/1359393004
-rw-r--r-- | gyp/core.gypi | 4 | ||||
-rw-r--r-- | src/lazy/SkCachingPixelRef.cpp | 74 | ||||
-rw-r--r-- | src/lazy/SkCachingPixelRef.h | 67 | ||||
-rw-r--r-- | tests/CachedDecodingPixelRefTest.cpp | 48 |
4 files changed, 184 insertions, 9 deletions
diff --git a/gyp/core.gypi b/gyp/core.gypi index 9e9727c66d..710a8e4378 100644 --- a/gyp/core.gypi +++ b/gyp/core.gypi @@ -343,6 +343,10 @@ '<(skia_include_path)/core/SkXfermode.h', '<(skia_include_path)/private/SkTemplates.h', + # Lazy decoding: + '<(skia_src_path)/lazy/SkCachingPixelRef.cpp', + '<(skia_src_path)/lazy/SkCachingPixelRef.h', + # Path ops '<(skia_include_path)/pathops/SkPathOps.h', diff --git a/src/lazy/SkCachingPixelRef.cpp b/src/lazy/SkCachingPixelRef.cpp new file mode 100644 index 0000000000..692e4ea3d6 --- /dev/null +++ b/src/lazy/SkCachingPixelRef.cpp @@ -0,0 +1,74 @@ +/* + * Copyright 2013 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "SkCachingPixelRef.h" +#include "SkBitmapCache.h" +#include "SkRect.h" + +bool SkCachingPixelRef::Install(SkImageGenerator* generator, + SkBitmap* dst) { + SkASSERT(dst != nullptr); + if (nullptr == generator) { + return false; + } + const SkImageInfo info = generator->getInfo(); + if (!dst->setInfo(info)) { + delete generator; + return false; + } + SkAutoTUnref<SkCachingPixelRef> ref(new SkCachingPixelRef(info, generator, dst->rowBytes())); + dst->setPixelRef(ref); + return true; +} + +SkCachingPixelRef::SkCachingPixelRef(const SkImageInfo& info, + SkImageGenerator* generator, + size_t rowBytes) + : INHERITED(info) + , fImageGenerator(generator) + , fErrorInDecoding(false) + , fRowBytes(rowBytes) { + SkASSERT(fImageGenerator != nullptr); +} +SkCachingPixelRef::~SkCachingPixelRef() { + delete fImageGenerator; + // Assert always unlock before unref. +} + +bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) { + if (fErrorInDecoding) { + return false; // don't try again. + } + + const SkImageInfo& info = this->info(); + if (!SkBitmapCache::Find( + this->getGenerationID(), info.bounds(), &fLockedBitmap)) { + // Cache has been purged, must re-decode. + if (!fLockedBitmap.tryAllocPixels(info, fRowBytes)) { + fErrorInDecoding = true; + return false; + } + if (!fImageGenerator->getPixels(info, fLockedBitmap.getPixels(), fRowBytes)) { + fErrorInDecoding = true; + return false; + } + fLockedBitmap.setImmutable(); + SkBitmapCache::Add(this, info.bounds(), fLockedBitmap); + } + + // Now bitmap should contain a concrete PixelRef of the decoded image. + void* pixels = fLockedBitmap.getPixels(); + SkASSERT(pixels != nullptr); + rec->fPixels = pixels; + rec->fColorTable = nullptr; + rec->fRowBytes = fLockedBitmap.rowBytes(); + return true; +} + +void SkCachingPixelRef::onUnlockPixels() { + fLockedBitmap.reset(); +} diff --git a/src/lazy/SkCachingPixelRef.h b/src/lazy/SkCachingPixelRef.h new file mode 100644 index 0000000000..1057441d5e --- /dev/null +++ b/src/lazy/SkCachingPixelRef.h @@ -0,0 +1,67 @@ +/* + * Copyright 2013 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkCachingPixelRef_DEFINED +#define SkCachingPixelRef_DEFINED + +#include "SkBitmapCache.h" +#include "SkImageInfo.h" +#include "SkImageGenerator.h" +#include "SkPixelRef.h" + +class SkColorTable; + +/** + * PixelRef which defers decoding until SkBitmap::lockPixels() is + * called. Caches the decoded images in the global + * SkScaledImageCache. When the pixels are unlocked, this cache may + * or be destroyed before the next lock. If so, onLockPixels will + * attempt to re-decode. + * + * Decoding is handled by the SkImageGenerator + */ +class SkCachingPixelRef : public SkPixelRef { +public: + + /** + * Takes ownership of SkImageGenerator. If this method fails for + * whatever reason, it will return false and immediatetely delete + * the generator. If it succeeds, it will modify destination + * bitmap. + * + * If Install fails or when the SkCachingPixelRef that is + * installed into destination is destroyed, it will call + * `delete` on the generator. Therefore, generator should be + * allocated with `new`. + */ + static bool Install(SkImageGenerator* gen, SkBitmap* dst); + +protected: + virtual ~SkCachingPixelRef(); + bool onNewLockPixels(LockRec*) override; + void onUnlockPixels() override; + bool onLockPixelsAreWritable() const override { return false; } + + SkData* onRefEncodedData() override { + return fImageGenerator->refEncodedData(); + } + + bool onIsLazyGenerated() const override { return true; } + +private: + SkImageGenerator* const fImageGenerator; + bool fErrorInDecoding; + const size_t fRowBytes; + + SkBitmap fLockedBitmap; + + SkCachingPixelRef(const SkImageInfo&, SkImageGenerator*, size_t rowBytes); + + typedef SkPixelRef INHERITED; +}; + +#endif // SkCachingPixelRef_DEFINED diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp index c14fb0052c..b58880b10d 100644 --- a/tests/CachedDecodingPixelRefTest.cpp +++ b/tests/CachedDecodingPixelRefTest.cpp @@ -6,6 +6,7 @@ */ #include "SkBitmap.h" +#include "SkCachingPixelRef.h" #include "SkCanvas.h" #include "SkData.h" #include "SkDiscardableMemoryPool.h" @@ -140,6 +141,9 @@ static void test_three_encodings(skiatest::Reporter* reporter, } //////////////////////////////////////////////////////////////////////////////// +static bool install_skCachingPixelRef(SkData* encoded, SkBitmap* dst) { + return SkCachingPixelRef::Install(SkImageGenerator::NewFromEncoded(encoded), dst); +} static bool install_skDiscardablePixelRef(SkData* encoded, SkBitmap* dst) { // Use system-default discardable memory. return SkInstallDiscardablePixelRef(encoded, dst); @@ -147,10 +151,12 @@ static bool install_skDiscardablePixelRef(SkData* encoded, SkBitmap* dst) { //////////////////////////////////////////////////////////////////////////////// /** - * This checks to see that SkDiscardablePixelRef works as advertised with a + * This checks to see that a SkCachingPixelRef and a + * SkDiscardablePixelRef works as advertised with a * SkDecodingImageGenerator. */ DEF_TEST(DecodingImageGenerator, reporter) { + test_three_encodings(reporter, install_skCachingPixelRef); test_three_encodings(reporter, install_skDiscardablePixelRef); } @@ -222,14 +228,27 @@ static void check_test_image_generator_bitmap(skiatest::Reporter* reporter, REPORTER_ASSERT(reporter, 0 == errors); } +enum PixelRefType { + kSkCaching_PixelRefType, + kSkDiscardable_PixelRefType, + kLast_PixelRefType = kSkDiscardable_PixelRefType +}; + static void check_pixelref(TestImageGenerator::TestType type, skiatest::Reporter* reporter, + PixelRefType pixelRefType, SkDiscardableMemory::Factory* factory) { + SkASSERT((pixelRefType >= 0) && (pixelRefType <= kLast_PixelRefType)); SkAutoTDelete<SkImageGenerator> gen(new TestImageGenerator(type, reporter)); REPORTER_ASSERT(reporter, gen.get() != nullptr); SkBitmap lazy; - bool success = SkInstallDiscardablePixelRef(gen.detach(), nullptr, &lazy, factory); - + bool success; + if (kSkCaching_PixelRefType == pixelRefType) { + // Ignore factory; use global cache. + success = SkCachingPixelRef::Install(gen.detach(), &lazy); + } else { + success = SkInstallDiscardablePixelRef(gen.detach(), nullptr, &lazy, factory); + } REPORTER_ASSERT(reporter, success); if (TestImageGenerator::kSucceedGetPixels_TestType == type) { check_test_image_generator_bitmap(reporter, lazy); @@ -258,23 +277,34 @@ static void test_newlockdelete(skiatest::Reporter* reporter) { DEF_TEST(DiscardableAndCachingPixelRef, reporter) { test_newlockdelete(reporter); - check_pixelref(TestImageGenerator::kFailGetPixels_TestType, reporter, nullptr); - check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType, reporter, nullptr); + check_pixelref(TestImageGenerator::kFailGetPixels_TestType, + reporter, kSkCaching_PixelRefType, nullptr); + check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType, + reporter, kSkCaching_PixelRefType, nullptr); + + check_pixelref(TestImageGenerator::kFailGetPixels_TestType, + reporter, kSkDiscardable_PixelRefType, nullptr); + check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType, + reporter, kSkDiscardable_PixelRefType, nullptr); SkAutoTUnref<SkDiscardableMemoryPool> pool( SkDiscardableMemoryPool::Create(1, nullptr)); REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed()); - check_pixelref(TestImageGenerator::kFailGetPixels_TestType, reporter, pool); + check_pixelref(TestImageGenerator::kFailGetPixels_TestType, + reporter, kSkDiscardable_PixelRefType, pool); REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed()); - check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType, reporter, pool); + check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType, + reporter, kSkDiscardable_PixelRefType, pool); REPORTER_ASSERT(reporter, 0 == pool->getRAMUsed()); SkDiscardableMemoryPool* globalPool = SkGetGlobalDiscardableMemoryPool(); // Only acts differently from nullptr on a platform that has a // default discardable memory implementation that differs from the // global DM pool. - check_pixelref(TestImageGenerator::kFailGetPixels_TestType, reporter, globalPool); - check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType, reporter, globalPool); + check_pixelref(TestImageGenerator::kFailGetPixels_TestType, + reporter, kSkDiscardable_PixelRefType, globalPool); + check_pixelref(TestImageGenerator::kSucceedGetPixels_TestType, + reporter, kSkDiscardable_PixelRefType, globalPool); } //////////////////////////////////////////////////////////////////////////////// |