static bool lazy_decode_bitmap(const void* src, size_t size, SkBitmap* dst) {
SkAutoTUnref<SkData> encoded(SkData::NewWithCopy(src, size));
- return encoded && SkInstallDiscardablePixelRef(encoded, dst);
+ return encoded && SkDEPRECATED_InstallDiscardablePixelRef(encoded, dst);
}
namespace DM {
// bitmap is unlocked.
SkAutoTUnref<SkDiscardableMemoryPool> pool(
SkDiscardableMemoryPool::Create(1));
- SkAssertResult(SkInstallDiscardablePixelRef(SkImageGenerator::NewFromEncoded(data),
+ SkAssertResult(SkDEPRECATED_InstallDiscardablePixelRef(
+ SkImageGenerator::NewFromEncoded(data),
nullptr, &fBitmap, pool));
}
}
*
* @return true iff successful.
*/
-SK_API bool SkInstallDiscardablePixelRef(SkImageGenerator*, SkBitmap* destination);
+SK_API bool SkDEPRECATED_InstallDiscardablePixelRef(SkImageGenerator*, SkBitmap* destination);
/**
* On success, installs a discardable pixelref into destination, based on encoded data.
* Regardless of success or failure, the caller must still balance their ownership of encoded.
*/
-SK_API bool SkInstallDiscardablePixelRef(SkData* encoded, SkBitmap* destination);
+SK_API bool SkDEPRECATED_InstallDiscardablePixelRef(SkData* encoded, SkBitmap* destination);
/**
* An interface that allows a purgeable PixelRef (such as a
*
* @return true iff successful.
*/
-bool SkInstallDiscardablePixelRef(SkImageGenerator*, const SkIRect* subset, SkBitmap* destination,
- SkDiscardableMemory::Factory* factory);
+bool SkDEPRECATED_InstallDiscardablePixelRef(SkImageGenerator*, const SkIRect* subset,
+ SkBitmap* destination,
+ SkDiscardableMemory::Factory* factory);
#endif
tileMatrix.setRectToRect(fTile, SkRect::MakeIWH(tileSize.width(), tileSize.height()),
SkMatrix::kFill_ScaleToFit);
SkBitmap bm;
- if (!SkInstallDiscardablePixelRef(
+ if (!SkDEPRECATED_InstallDiscardablePixelRef(
SkImageGenerator::NewFromPicture(tileSize, fPicture, &tileMatrix, nullptr), &bm)) {
return nullptr;
}
fDiscardableMemoryIsLocked = false;
}
-bool SkInstallDiscardablePixelRef(SkImageGenerator* generator, const SkIRect* subset, SkBitmap* dst,
- SkDiscardableMemory::Factory* factory) {
+bool SkDEPRECATED_InstallDiscardablePixelRef(SkImageGenerator* generator, const SkIRect* subset,
+ SkBitmap* dst, SkDiscardableMemory::Factory* factory) {
SkAutoTDelete<SkImageGenerator> autoGenerator(generator);
if (nullptr == autoGenerator.get()) {
return false;
// These are the public API
-bool SkInstallDiscardablePixelRef(SkImageGenerator* generator, SkBitmap* dst) {
- return SkInstallDiscardablePixelRef(generator, nullptr, dst, nullptr);
+bool SkDEPRECATED_InstallDiscardablePixelRef(SkImageGenerator* generator, SkBitmap* dst) {
+ return SkDEPRECATED_InstallDiscardablePixelRef(generator, nullptr, dst, nullptr);
}
-bool SkInstallDiscardablePixelRef(SkData* encoded, SkBitmap* dst) {
+bool SkDEPRECATED_InstallDiscardablePixelRef(SkData* encoded, SkBitmap* dst) {
SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded);
- return generator ? SkInstallDiscardablePixelRef(generator, nullptr, dst, nullptr) : false;
+ return generator ?
+ SkDEPRECATED_InstallDiscardablePixelRef(generator, nullptr, dst, nullptr) : false;
}
return fGenerator->getYUV8Planes(sizes, planes, rowBytes, colorSpace);
}
- friend bool SkInstallDiscardablePixelRef(SkImageGenerator*, const SkIRect*, SkBitmap*,
+ friend bool SkDEPRECATED_InstallDiscardablePixelRef(SkImageGenerator*, const SkIRect*, SkBitmap*,
SkDiscardableMemory::Factory*);
typedef SkPixelRef INHERITED;
////////////////////////////////////////////////////////////////////////////////
static bool install_skDiscardablePixelRef(SkData* encoded, SkBitmap* dst) {
// Use system-default discardable memory.
- return SkInstallDiscardablePixelRef(encoded, dst);
+ return SkDEPRECATED_InstallDiscardablePixelRef(encoded, dst);
}
////////////////////////////////////////////////////////////////////////////////
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 = SkDEPRECATED_InstallDiscardablePixelRef(gen.detach(), nullptr, &lazy, factory);
REPORTER_ASSERT(reporter, success);
if (TestImageGenerator::kSucceedGetPixels_TestType == type) {
}
bool installDiscardablePixelRefSuccess =
- SkInstallDiscardablePixelRef(fileData, &etcBitmap);
+ SkDEPRECATED_InstallDiscardablePixelRef(fileData, &etcBitmap);
REPORTER_ASSERT(reporter, installDiscardablePixelRefSuccess);
// Write the bitmap out to a KTX file.
static SkBitmap bitmap_from_data(SkData* data) {
SkASSERT(data);
SkBitmap bm;
- SkInstallDiscardablePixelRef(data, &bm);
+ SkDEPRECATED_InstallDiscardablePixelRef(data, &bm);
return bm;
}
SkAutoDataUnref data(wStream.copyToData());
SkBitmap bm;
- bool installSuccess = SkInstallDiscardablePixelRef(data, &bm);
+ bool installSuccess = SkDEPRECATED_InstallDiscardablePixelRef(data, &bm);
REPORTER_ASSERT(reporter, installSuccess);
// Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
// Only meaningful if platform has a default discardable
// memory implementation that differs from the global DM pool.
}
- return SkInstallDiscardablePixelRef(gen.detach(), nullptr, dst, pool);
+ return SkDEPRECATED_InstallDiscardablePixelRef(gen.detach(), nullptr, dst, pool);
}
static bool lazy_decode_bitmap(const void* src, size_t size, SkBitmap* dst) {
SkAutoTUnref<SkData> encoded(SkData::NewWithCopy(src, size));
- return encoded && SkInstallDiscardablePixelRef(encoded, dst);
+ return encoded && SkDEPRECATED_InstallDiscardablePixelRef(encoded, dst);
}
int main(int argc, char** argv) {