From 27f890219b09e4774da75e6a11ec82849eadae5a Mon Sep 17 00:00:00 2001 From: "commit-bot@chromium.org" Date: Fri, 3 Jan 2014 16:32:45 +0000 Subject: [PATCH] Revert of https://codereview.chromium.org/110593003/ Reason for revert: SkImageRef_ashmem doesn't compile R=halcanary@google.com, scroggo@google.com TBR=halcanary@google.com, scroggo@google.com NOTREECHECKS=true NOTRY=true BUG= Author: reed@google.com Review URL: https://codereview.chromium.org/119753009 git-svn-id: http://skia.googlecode.com/svn/trunk@12884 2bbb7eff-a529-9590-31e7-b0007b416f81 --- include/core/SkBitmapDevice.h | 2 - include/core/SkMallocPixelRef.h | 10 +++-- include/core/SkPixelRef.h | 73 +++++++++-------------------------- include/gpu/SkGrPixelRef.h | 7 ++-- include/images/SkImageRef.h | 4 +- src/core/SkBitmapDevice.cpp | 35 +++++++++-------- src/core/SkMallocPixelRef.cpp | 16 ++++---- src/core/SkPixelRef.cpp | 79 ++++++++++++-------------------------- src/core/SkScaledImageCache.cpp | 23 ++++++----- src/gpu/SkGrPixelRef.cpp | 16 +++----- src/images/SkImageRef.cpp | 17 ++++---- src/lazy/SkCachingPixelRef.cpp | 19 ++++----- src/lazy/SkCachingPixelRef.h | 2 +- src/lazy/SkDiscardablePixelRef.cpp | 21 +++------- src/lazy/SkDiscardablePixelRef.h | 6 +-- 15 files changed, 119 insertions(+), 211 deletions(-) diff --git a/include/core/SkBitmapDevice.h b/include/core/SkBitmapDevice.h index f3d40d0..83f480c 100644 --- a/include/core/SkBitmapDevice.h +++ b/include/core/SkBitmapDevice.h @@ -258,8 +258,6 @@ private: friend class SkSurface_Raster; - void init(SkBitmap::Config config, int width, int height, bool isOpaque); - // used to change the backend's pixels (and possibly config/rowbytes) // but cannot change the width/height, so there should be no change to // any clip information. diff --git a/include/core/SkMallocPixelRef.h b/include/core/SkMallocPixelRef.h index c40afc4..272dc21 100644 --- a/include/core/SkMallocPixelRef.h +++ b/include/core/SkMallocPixelRef.h @@ -32,9 +32,11 @@ public: /** * Return a new SkMallocPixelRef, automatically allocating storage for the - * pixels. If rowBytes are 0, an optimal value will be chosen automatically. - * If rowBytes is > 0, then it will be respected, or NULL will be returned - * if rowBytes is invalid for the specified info. + * pixels. + * + * If rowBytes is 0, an optimal value will be chosen automatically. + * If rowBytes is > 0, then it will be used, unless it is invald for the + * specified info, in which case NULL will be returned (failure). * * This pixelref will ref() the specified colortable (if not NULL). * @@ -88,7 +90,7 @@ protected: SkMallocPixelRef(SkFlattenableReadBuffer& buffer); virtual ~SkMallocPixelRef(); - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; + virtual void* onLockPixels(SkColorTable**) SK_OVERRIDE; virtual void onUnlockPixels() SK_OVERRIDE; virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE; virtual size_t getAllocatedSizeInBytes() const SK_OVERRIDE; diff --git a/include/core/SkPixelRef.h b/include/core/SkPixelRef.h index a332b76..e611dc0 100644 --- a/include/core/SkPixelRef.h +++ b/include/core/SkPixelRef.h @@ -14,11 +14,8 @@ #include "SkRefCnt.h" #include "SkString.h" #include "SkFlattenable.h" -#include "SkImageInfo.h" #include "SkTDArray.h" -//#define SK_SUPPORT_LEGACY_ONLOCKPIXELS - #ifdef SK_DEBUG /** * Defining SK_IGNORE_PIXELREF_SETPRELOCKED will force all pixelref @@ -63,48 +60,23 @@ public: /** Return the pixel memory returned from lockPixels, or null if the lockCount is 0. */ - void* pixels() const { return fRec.fPixels; } + void* pixels() const { return fPixels; } /** Return the current colorTable (if any) if pixels are locked, or null. */ - SkColorTable* colorTable() const { return fRec.fColorTable; } + SkColorTable* colorTable() const { return fColorTable; } /** - * To access the actual pixels of a pixelref, it must be "locked". - * Calling lockPixels returns a LockRec struct (on success). - */ - struct LockRec { - void* fPixels; - SkColorTable* fColorTable; - size_t fRowBytes; - - void zero() { sk_bzero(this, sizeof(*this)); } - - bool isZero() const { - return NULL == fPixels && NULL == fColorTable && 0 == fRowBytes; - } - }; - - /** * Returns true if the lockcount > 0 */ bool isLocked() const { return fLockCount > 0; } SkDEBUGCODE(int getLockCount() const { return fLockCount; }) - /** - * Call to access the pixel memory. Return true on success. Balance this - * with a call to unlockPixels(). - */ - bool lockPixels(); - - /** - * Call to access the pixel memory. On success, return true and fill out - * the specified rec. On failure, return false and ignore the rec parameter. - * Balance this with a call to unlockPixels(). - */ - bool lockPixels(LockRec* rec); - + /** Call to access the pixel memory, which is returned. Balance with a call + to unlockPixels(). + */ + void lockPixels(); /** Call to balanace a previous call to lockPixels(). Returns the pixels (or null) after the unlock. NOTE: lock calls can be nested, but the matching number of unlock calls must be made in order to free the @@ -261,27 +233,18 @@ public: void addGenIDChangeListener(GenIDChangeListener* listener); protected: -#ifdef SK_SUPPORT_LEGACY_ONLOCKPIXELS - virtual void* onLockPixels(SkColorTable**); - virtual bool onNewLockPixels(LockRec*); -#else - /** - * On success, returns true and fills out the LockRec for the pixels. On - * failure returns false and ignores the LockRec parameter. - * - * The caller will have already acquired a mutex for thread safety, so this - * method need not do that. - */ - virtual bool onNewLockPixels(LockRec*) = 0; -#endif + /** Called when the lockCount goes from 0 to 1. The caller will have already + acquire a mutex for thread safety, so this method need not do that. + */ + virtual void* onLockPixels(SkColorTable**) = 0; /** - * Balancing the previous successful call to onNewLockPixels. The locked - * pixel address will no longer be referenced, so the subclass is free to - * move or discard that memory. + * Called when the lock count goes from 1 to 0. The caller will have + * already acquire a mutex for thread safety, so this method need not do + * that. * - * The caller will have already acquired a mutex for thread safety, so this - * method need not do that. + * If the previous call to onLockPixels failed (i.e. returned NULL), then + * the onUnlockPixels will NOT be called. */ virtual void onUnlockPixels() = 0; @@ -326,15 +289,15 @@ protected: // only call from constructor. Flags this to always be locked, removing // the need to grab the mutex and call onLockPixels/onUnlockPixels. // Performance tweak to avoid those calls (esp. in multi-thread use case). - void setPreLocked(void*, size_t rowBytes, SkColorTable*); + void setPreLocked(void* pixels, SkColorTable* ctable); private: SkBaseMutex* fMutex; // must remain in scope for the life of this object const SkImageInfo fInfo; - // LockRec is only valid if we're in a locked state (isLocked()) - LockRec fRec; + void* fPixels; + SkColorTable* fColorTable; // we do not track ownership, subclass does int fLockCount; mutable uint32_t fGenerationID; diff --git a/include/gpu/SkGrPixelRef.h b/include/gpu/SkGrPixelRef.h index 63e9756..d893372 100644 --- a/include/gpu/SkGrPixelRef.h +++ b/include/gpu/SkGrPixelRef.h @@ -24,9 +24,10 @@ public: virtual ~SkROLockPixelsPixelRef(); protected: - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; - virtual void onUnlockPixels() SK_OVERRIDE; - virtual bool onLockPixelsAreWritable() const SK_OVERRIDE; // return false; + // override from SkPixelRef + virtual void* onLockPixels(SkColorTable** ptr); + virtual void onUnlockPixels(); + virtual bool onLockPixelsAreWritable() const; // return false; private: SkBitmap fBitmap; diff --git a/include/images/SkImageRef.h b/include/images/SkImageRef.h index 36f95e6..30b1562 100644 --- a/include/images/SkImageRef.h +++ b/include/images/SkImageRef.h @@ -72,9 +72,9 @@ protected: When these are called, we will have already acquired the mutex! */ - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; + virtual void* onLockPixels(SkColorTable**); // override this in your subclass to clean up when we're unlocking pixels - virtual void onUnlockPixels() SK_OVERRIDE {} + virtual void onUnlockPixels() {} SkImageRef(SkFlattenableReadBuffer&, SkBaseMutex* mutex = NULL); virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE; diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp index 368c807..1668618 100644 --- a/src/core/SkBitmapDevice.cpp +++ b/src/core/SkBitmapDevice.cpp @@ -24,30 +24,31 @@ SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap, const SkDeviceProperties& , fBitmap(bitmap) { } -void SkBitmapDevice::init(SkBitmap::Config config, int width, int height, bool isOpaque) { +SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque) { fBitmap.setConfig(config, width, height, 0, isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType); - - if (SkBitmap::kNo_Config != config) { - if (!fBitmap.allocPixels()) { - // indicate failure by zeroing our bitmap - fBitmap.setConfig(config, 0, 0, 0, isOpaque ? - kOpaque_SkAlphaType : kPremul_SkAlphaType); - } else if (!isOpaque) { - fBitmap.eraseColor(SK_ColorTRANSPARENT); - } + if (!fBitmap.allocPixels()) { + fBitmap.setConfig(config, 0, 0, 0, isOpaque ? + kOpaque_SkAlphaType : kPremul_SkAlphaType); + } + if (!isOpaque) { + fBitmap.eraseColor(SK_ColorTRANSPARENT); } -} - -SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque) { - this->init(config, width, height, isOpaque); } SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque, const SkDeviceProperties& deviceProperties) - : SkBaseDevice(deviceProperties) -{ - this->init(config, width, height, isOpaque); + : SkBaseDevice(deviceProperties) { + + fBitmap.setConfig(config, width, height, 0, isOpaque ? + kOpaque_SkAlphaType : kPremul_SkAlphaType); + if (!fBitmap.allocPixels()) { + fBitmap.setConfig(config, 0, 0, 0, isOpaque ? + kOpaque_SkAlphaType : kPremul_SkAlphaType); + } + if (!isOpaque) { + fBitmap.eraseColor(SK_ColorTRANSPARENT); + } } SkBitmapDevice::~SkBitmapDevice() { diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp index c86d33b..c3e605c 100644 --- a/src/core/SkMallocPixelRef.cpp +++ b/src/core/SkMallocPixelRef.cpp @@ -152,7 +152,7 @@ SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage, fRB = rowBytes; SkSafeRef(ctable); - this->setPreLocked(fStorage, fRB, fCTable); + this->setPreLocked(fStorage, fCTable); } SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage, @@ -174,8 +174,8 @@ SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage, fCTable = ctable; fRB = rowBytes; SkSafeRef(ctable); - - this->setPreLocked(fStorage, fRB, fCTable); + + this->setPreLocked(fStorage, fCTable); } @@ -186,11 +186,9 @@ SkMallocPixelRef::~SkMallocPixelRef() { } } -bool SkMallocPixelRef::onNewLockPixels(LockRec* rec) { - rec->fPixels = fStorage; - rec->fRowBytes = fRB; - rec->fColorTable = fCTable; - return true; +void* SkMallocPixelRef::onLockPixels(SkColorTable** ctable) { + *ctable = fCTable; + return fStorage; } void SkMallocPixelRef::onUnlockPixels() { @@ -236,5 +234,5 @@ SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer) fCTable = NULL; } - this->setPreLocked(fStorage, fRB, fCTable); + this->setPreLocked(fStorage, fCTable); } diff --git a/src/core/SkPixelRef.cpp b/src/core/SkPixelRef.cpp index 7ec5929..fedbb5a 100644 --- a/src/core/SkPixelRef.cpp +++ b/src/core/SkPixelRef.cpp @@ -82,19 +82,20 @@ void SkPixelRef::setMutex(SkBaseMutex* mutex) { // just need a > 0 value, so pick a funny one to aid in debugging #define SKPIXELREF_PRELOCKED_LOCKCOUNT 123456789 -SkPixelRef::SkPixelRef(const SkImageInfo& info) : fInfo(info) { - this->setMutex(NULL); - fRec.zero(); +SkPixelRef::SkPixelRef(const SkImageInfo& info, SkBaseMutex* mutex) : fInfo(info) { + this->setMutex(mutex); + fPixels = NULL; + fColorTable = NULL; // we do not track ownership of this fLockCount = 0; this->needsNewGenID(); fIsImmutable = false; fPreLocked = false; } - -SkPixelRef::SkPixelRef(const SkImageInfo& info, SkBaseMutex* mutex) : fInfo(info) { - this->setMutex(mutex); - fRec.zero(); +SkPixelRef::SkPixelRef(const SkImageInfo& info) : fInfo(info) { + this->setMutex(NULL); + fPixels = NULL; + fColorTable = NULL; // we do not track ownership of this fLockCount = 0; this->needsNewGenID(); fIsImmutable = false; @@ -112,7 +113,8 @@ SkPixelRef::SkPixelRef(SkFlattenableReadBuffer& buffer, SkBaseMutex* mutex) , fInfo(read_info(buffer)) { this->setMutex(mutex); - fRec.zero(); + fPixels = NULL; + fColorTable = NULL; // we do not track ownership of this fLockCount = 0; fIsImmutable = buffer.readBool(); fGenerationID = buffer.readUInt(); @@ -136,13 +138,12 @@ void SkPixelRef::cloneGenID(const SkPixelRef& that) { that.fUniqueGenerationID = false; } -void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) { +void SkPixelRef::setPreLocked(void* pixels, SkColorTable* ctable) { #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED // only call me in your constructor, otherwise fLockCount tracking can get // out of sync. - fRec.fPixels = pixels; - fRec.fColorTable = ctable; - fRec.fRowBytes = rowBytes; + fPixels = pixels; + fColorTable = ctable; fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT; fPreLocked = true; #endif @@ -165,30 +166,20 @@ void SkPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const { } } -bool SkPixelRef::lockPixels(LockRec* rec) { +void SkPixelRef::lockPixels() { SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount); - + if (!fPreLocked) { SkAutoMutexAcquire ac(*fMutex); - - if (1 == ++fLockCount) { - SkASSERT(fRec.isZero()); - LockRec rec; - if (!this->onNewLockPixels(&rec)) { - return false; + if (1 == ++fLockCount) { + fPixels = this->onLockPixels(&fColorTable); + // If onLockPixels failed, it will return NULL + if (NULL == fPixels) { + fColorTable = NULL; } - SkASSERT(!rec.isZero()); // else why did onNewLock return true? - fRec = rec; } } - *rec = fRec; - return true; -} - -bool SkPixelRef::lockPixels() { - LockRec rec; - return this->lockPixels(&rec); } void SkPixelRef::unlockPixels() { @@ -200,11 +191,12 @@ void SkPixelRef::unlockPixels() { SkASSERT(fLockCount > 0); if (0 == --fLockCount) { // don't call onUnlockPixels unless onLockPixels succeeded - if (fRec.fPixels) { + if (fPixels) { this->onUnlockPixels(); - fRec.zero(); + fPixels = NULL; + fColorTable = NULL; } else { - SkASSERT(fRec.isZero()); + SkASSERT(NULL == fColorTable); } } } @@ -286,29 +278,6 @@ size_t SkPixelRef::getAllocatedSizeInBytes() const { /////////////////////////////////////////////////////////////////////////////// -#ifdef SK_SUPPORT_LEGACY_ONLOCKPIXELS - -void* SkPixelRef::onLockPixels(SkColorTable** ctable) { - return NULL; -} - -bool SkPixelRef::onNewLockPixels(LockRec* rec) { - SkColorTable* ctable; - void* pixels = this->onLockPixels(&ctable); - if (!pixels) { - return false; - } - - rec->fPixels = pixels; - rec->fColorTable = ctable; - rec->fRowBytes = 0; // callers don't currently need this (thank goodness) - return true; -} - -#endif - -/////////////////////////////////////////////////////////////////////////////// - #ifdef SK_BUILD_FOR_ANDROID void SkPixelRef::globalRef(void* data) { this->ref(); diff --git a/src/core/SkScaledImageCache.cpp b/src/core/SkScaledImageCache.cpp index 5a772a7..45a5684 100644 --- a/src/core/SkScaledImageCache.cpp +++ b/src/core/SkScaledImageCache.cpp @@ -199,11 +199,13 @@ public: SK_DECLARE_UNFLATTENABLE_OBJECT() protected: - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; + virtual void* onLockPixels(SkColorTable**) SK_OVERRIDE; virtual void onUnlockPixels() SK_OVERRIDE; virtual size_t getAllocatedSizeInBytes() const SK_OVERRIDE; private: + SkImageInfo fInfo; // remove when SkPixelRef gets this in baseclass + SkDiscardableMemory* fDM; size_t fRB; bool fFirstTime; @@ -218,6 +220,8 @@ SkOneShotDiscardablePixelRef::SkOneShotDiscardablePixelRef(const SkImageInfo& in , fDM(dm) , fRB(rowBytes) { + fInfo = info; // remove this redundant field when SkPixelRef has info + SkASSERT(dm->data()); fFirstTime = true; } @@ -226,31 +230,26 @@ SkOneShotDiscardablePixelRef::~SkOneShotDiscardablePixelRef() { SkDELETE(fDM); } -bool SkOneShotDiscardablePixelRef::onNewLockPixels(LockRec* rec) { +void* SkOneShotDiscardablePixelRef::onLockPixels(SkColorTable** ctable) { if (fFirstTime) { // we're already locked SkASSERT(fDM->data()); fFirstTime = false; - goto SUCCESS; + return fDM->data(); } // A previous call to onUnlock may have deleted our DM, so check for that if (NULL == fDM) { - return false; + return NULL; } if (!fDM->lock()) { // since it failed, we delete it now, to free-up the resource delete fDM; fDM = NULL; - return false; + return NULL; } - -SUCCESS: - rec->fPixels = fDM->data(); - rec->fColorTable = NULL; - rec->fRowBytes = fRB; - return true; + return fDM->data(); } void SkOneShotDiscardablePixelRef::onUnlockPixels() { @@ -259,7 +258,7 @@ void SkOneShotDiscardablePixelRef::onUnlockPixels() { } size_t SkOneShotDiscardablePixelRef::getAllocatedSizeInBytes() const { - return this->info().getSafeSize(fRB); + return fInfo.fHeight * fRB; } class SkScaledImageCacheDiscardableAllocator : public SkBitmap::Allocator { diff --git a/src/gpu/SkGrPixelRef.cpp b/src/gpu/SkGrPixelRef.cpp index 8a16437..a068d8d 100644 --- a/src/gpu/SkGrPixelRef.cpp +++ b/src/gpu/SkGrPixelRef.cpp @@ -23,22 +23,18 @@ SkROLockPixelsPixelRef::SkROLockPixelsPixelRef(const SkImageInfo& info) SkROLockPixelsPixelRef::~SkROLockPixelsPixelRef() {} -bool SkROLockPixelsPixelRef::onNewLockPixels(LockRec* rec) { +void* SkROLockPixelsPixelRef::onLockPixels(SkColorTable** ctable) { + if (ctable) { + *ctable = NULL; + } fBitmap.reset(); // SkDebugf("---------- calling readpixels in support of lockpixels\n"); if (!this->onReadPixels(&fBitmap, NULL)) { SkDebugf("SkROLockPixelsPixelRef::onLockPixels failed!\n"); - return false; + return NULL; } fBitmap.lockPixels(); - if (NULL == fBitmap.getPixels()) { - return false; - } - - rec->fPixels = fBitmap.getPixels(); - rec->fColorTable = NULL; - rec->fRowBytes = fBitmap.rowBytes(); - return true; + return fBitmap.getPixels(); } void SkROLockPixelsPixelRef::onUnlockPixels() { diff --git a/src/images/SkImageRef.cpp b/src/images/SkImageRef.cpp index 2c1ec38..843f4c0 100644 --- a/src/images/SkImageRef.cpp +++ b/src/images/SkImageRef.cpp @@ -15,12 +15,12 @@ //#define DUMP_IMAGEREF_LIFECYCLE + /////////////////////////////////////////////////////////////////////////////// SkImageRef::SkImageRef(const SkImageInfo& info, SkStreamRewindable* stream, int sampleSize, SkBaseMutex* mutex) - : INHERITED(info, mutex), fErrorInDecoding(false) -{ + : SkPixelRef(info, mutex), fErrorInDecoding(false) { SkASSERT(stream); stream->ref(); fStream = stream; @@ -39,7 +39,7 @@ SkImageRef::~SkImageRef() { #ifdef DUMP_IMAGEREF_LIFECYCLE SkDebugf("delete ImageRef %p [%d] data=%d\n", - this, this->info().fColorType, (int)fStream->getLength()); + this, fConfig, (int)fStream->getLength()); #endif fStream->unref(); @@ -134,18 +134,15 @@ bool SkImageRef::prepareBitmap(SkImageDecoder::Mode mode) { return false; } -bool SkImageRef::onNewLockPixels(LockRec* rec) { +void* SkImageRef::onLockPixels(SkColorTable** ct) { if (NULL == fBitmap.getPixels()) { (void)this->prepareBitmap(SkImageDecoder::kDecodePixels_Mode); } - if (NULL == fBitmap.getPixels()) { - return false; + if (ct) { + *ct = fBitmap.getColorTable(); } - rec->fPixels = fBitmap.getPixels(); - rec->fColorTable = NULL; - rec->fRowBytes = fBitmap.rowBytes(); - return true; + return fBitmap.getPixels(); } size_t SkImageRef::ramUsed() const { diff --git a/src/lazy/SkCachingPixelRef.cpp b/src/lazy/SkCachingPixelRef.cpp index 033a6b5..fb30d05 100644 --- a/src/lazy/SkCachingPixelRef.cpp +++ b/src/lazy/SkCachingPixelRef.cpp @@ -8,6 +8,7 @@ #include "SkCachingPixelRef.h" #include "SkScaledImageCache.h" + bool SkCachingPixelRef::Install(SkImageGenerator* generator, SkBitmap* dst) { SkImageInfo info; @@ -40,12 +41,12 @@ SkCachingPixelRef::~SkCachingPixelRef() { // Assert always unlock before unref. } -bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) { +void* SkCachingPixelRef::onLockPixels(SkColorTable**) { + const SkImageInfo& info = this->info(); + if (fErrorInDecoding) { - return false; // don't try again. + return NULL; // don't try again. } - - const SkImageInfo& info = this->info(); SkBitmap bitmap; SkASSERT(NULL == fScaledCacheId); fScaledCacheId = SkScaledImageCache::FindAndLock(this->getGenerationID(), @@ -56,12 +57,12 @@ bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) { // Cache has been purged, must re-decode. if ((!bitmap.setConfig(info, fRowBytes)) || !bitmap.allocPixels()) { fErrorInDecoding = true; - return false; + return NULL; } SkAutoLockPixels autoLockPixels(bitmap); if (!fImageGenerator->getPixels(info, bitmap.getPixels(), fRowBytes)) { fErrorInDecoding = true; - return false; + return NULL; } fScaledCacheId = SkScaledImageCache::AddAndLock(this->getGenerationID(), info.fWidth, @@ -75,7 +76,6 @@ bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) { SkAutoLockPixels autoLockPixels(bitmap); void* pixels = bitmap.getPixels(); SkASSERT(pixels != NULL); - // At this point, the autoLockPixels will unlockPixels() // to remove bitmap's lock on the pixels. We will then // destroy bitmap. The *only* guarantee that this pointer @@ -84,10 +84,7 @@ bool SkCachingPixelRef::onNewLockPixels(LockRec* rec) { // bitmap (SkScaledImageCache::Rec.fBitmap) that holds a // reference to the concrete PixelRef while this record is // locked. - rec->fPixels = pixels; - rec->fColorTable = NULL; - rec->fRowBytes = bitmap.rowBytes(); - return true; + return pixels; } void SkCachingPixelRef::onUnlockPixels() { diff --git a/src/lazy/SkCachingPixelRef.h b/src/lazy/SkCachingPixelRef.h index 905ee9b..b1f2fcd 100644 --- a/src/lazy/SkCachingPixelRef.h +++ b/src/lazy/SkCachingPixelRef.h @@ -40,7 +40,7 @@ public: protected: virtual ~SkCachingPixelRef(); - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; + virtual void* onLockPixels(SkColorTable** colorTable) SK_OVERRIDE; virtual void onUnlockPixels() SK_OVERRIDE; virtual bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; } diff --git a/src/lazy/SkDiscardablePixelRef.cpp b/src/lazy/SkDiscardablePixelRef.cpp index 3f960d3..2886156 100644 --- a/src/lazy/SkDiscardablePixelRef.cpp +++ b/src/lazy/SkDiscardablePixelRef.cpp @@ -36,18 +36,15 @@ SkDiscardablePixelRef::~SkDiscardablePixelRef() { SkDELETE(fGenerator); } -bool SkDiscardablePixelRef::onNewLockPixels(LockRec* rec) { +void* SkDiscardablePixelRef::onLockPixels(SkColorTable**) { if (fDiscardableMemory != NULL) { if (fDiscardableMemory->lock()) { - rec->fPixels = fDiscardableMemory->data(); - rec->fColorTable = NULL; - rec->fRowBytes = fRowBytes; - return true; + return fDiscardableMemory->data(); } SkDELETE(fDiscardableMemory); fDiscardableMemory = NULL; } - + const size_t size = this->info().getSafeSize(fRowBytes); if (fDMFactory != NULL) { @@ -56,23 +53,17 @@ bool SkDiscardablePixelRef::onNewLockPixels(LockRec* rec) { fDiscardableMemory = SkDiscardableMemory::Create(size); } if (NULL == fDiscardableMemory) { - return false; // Memory allocation failed. + return NULL; // Memory allocation failed. } - void* pixels = fDiscardableMemory->data(); if (!fGenerator->getPixels(this->info(), pixels, fRowBytes)) { fDiscardableMemory->unlock(); SkDELETE(fDiscardableMemory); fDiscardableMemory = NULL; - return false; + return NULL; } - - rec->fPixels = pixels; - rec->fColorTable = NULL; - rec->fRowBytes = fRowBytes; - return true; + return pixels; } - void SkDiscardablePixelRef::onUnlockPixels() { fDiscardableMemory->unlock(); } diff --git a/src/lazy/SkDiscardablePixelRef.h b/src/lazy/SkDiscardablePixelRef.h index 4a013fd..3367096 100644 --- a/src/lazy/SkDiscardablePixelRef.h +++ b/src/lazy/SkDiscardablePixelRef.h @@ -28,8 +28,7 @@ public: protected: ~SkDiscardablePixelRef(); - - virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE; + virtual void* onLockPixels(SkColorTable**) SK_OVERRIDE; virtual void onUnlockPixels() SK_OVERRIDE; virtual bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; } @@ -50,12 +49,9 @@ private: SkDiscardablePixelRef(const SkImageInfo&, SkImageGenerator*, size_t rowBytes, SkDiscardableMemory::Factory* factory); - friend bool SkInstallDiscardablePixelRef(SkImageGenerator*, SkBitmap*, SkDiscardableMemory::Factory*); - typedef SkPixelRef INHERITED; }; - #endif // SkDiscardablePixelRef_DEFINED -- 2.7.4