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 /src | |
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
Diffstat (limited to 'src')
-rw-r--r-- | src/lazy/SkCachingPixelRef.cpp | 74 | ||||
-rw-r--r-- | src/lazy/SkCachingPixelRef.h | 67 |
2 files changed, 141 insertions, 0 deletions
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 |