bool
SkFontManager::addNewFont( uint32_t fontIndex )
{
if( fontIndex >= mSearchFonts.numFonts() )
goto ERROR0;
else
{
SkFontData * newFont = SkNEW( SkFontData );
if( newFont )
{
if( copyFont( newFont, mSearchFonts.getFont( fontIndex ) ) == false )
goto ERROR1;
if( mDownloadFonts.addFonts( newFont ) == false )
goto ERROR1;
setPermission( newFont );
//
newFont->loadFont();
return true;
}
ERROR1:
if( newFont )
SkDELETE( newFont );
goto ERROR0;
}
ERROR0:
return false;
}
bool
SkFontManager::openPreDataRead( SkStream ** preData )
{
SkStream * stream = openReadStream( SYSTEM_DL_PREDATA_FILE );
if( !stream )
{
if( permission_denied() )
goto SKIP_ERROR0;
if( !no_such_file() )
goto ERROR0;
goto SKIP_ERROR0;
}
*preData = stream;
return true;
SKIP_ERROR0:
return false;
ERROR0:
if( stream )
SkDELETE( stream );
return false;
}
// overrides
virtual SkStream* openStream()
{
SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str()));
// check for failure
if (stream->getLength() <= 0) {
SkDELETE(stream);
// maybe MMAP isn't supported. try FILE
stream = SkNEW_ARGS(SkFILEStream, (fPath.c_str()));
if (stream->getLength() <= 0) {
SkDELETE(stream);
stream = NULL;
}
}
return stream;
}
static void bench_record(SkPicture* src, const char* name, SkBBHFactory* bbhFactory) {
BenchTimer timer;
timer.start();
const int width = src ? src->width() : FLAGS_nullSize;
const int height = src ? src->height() : FLAGS_nullSize;
for (int i = 0; i < FLAGS_loops; i++) {
if (FLAGS_skr) {
EXPERIMENTAL::SkRecording recording(width, height);
if (NULL != src) {
src->draw(recording.canvas());
}
// Release and delete the SkPlayback so that recording optimizes its SkRecord.
SkDELETE(recording.releasePlayback());
} else {
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(width, height, bbhFactory, FLAGS_flags);
if (NULL != src) {
src->draw(canvas);
}
if (FLAGS_endRecording) {
SkAutoTUnref<SkPicture> dst(recorder.endRecording());
}
}
}
timer.end();
const double msPerLoop = timer.fCpu / (double)FLAGS_loops;
printf("%f\t%s\n", scale_time(msPerLoop), name);
}
SkScalerContext::~SkScalerContext() {
SkDELETE(fNextContext);
fPathEffect->safeUnref();
fMaskFilter->safeUnref();
fRasterizer->safeUnref();
}
SkScalerContext::~SkScalerContext() {
SkDELETE(fNextContext);
SkSafeUnref(fPathEffect);
SkSafeUnref(fMaskFilter);
SkSafeUnref(fRasterizer);
}
void SkTLS::Delete(CreateProc createProc) {
if (NULL == createProc) {
return;
}
void* ptr = SkTLS::PlatformGetSpecific(false);
SkTLSRec* curr = (SkTLSRec*)ptr;
SkTLSRec* prev = NULL;
while (curr) {
SkTLSRec* next = curr->fNext;
if (curr->fCreateProc == createProc) {
if (prev) {
prev->fNext = next;
} else {
// we have a new head of our chain
SkTLS::PlatformSetSpecific(next);
}
SkDELETE(curr);
break;
}
prev = curr;
curr = next;
}
}
void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
SkPicturePlayback* playback = fPlayback;
if (NULL == playback && fRecord) {
playback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
}
SkPictInfo info;
info.fVersion = PICTURE_VERSION;
info.fWidth = fWidth;
info.fHeight = fHeight;
info.fFlags = SkPictInfo::kCrossProcess_Flag;
#ifdef SK_SCALAR_IS_FLOAT
info.fFlags |= SkPictInfo::kScalarIsFloat_Flag;
#endif
if (8 == sizeof(void*)) {
info.fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
}
stream->write(&info, sizeof(info));
if (playback) {
stream->writeBool(true);
playback->serialize(stream, encoder);
// delete playback if it is a local version (i.e. cons'd up just now)
if (playback != fPlayback) {
SkDELETE(playback);
}
} else {
stream->writeBool(false);
}
}
~DeviceCM() {
if (NULL != fDevice) {
fDevice->unlockPixels();
fDevice->unref();
}
SkDELETE(fPaint);
}
SkCanvas* SkPicture::beginRecording(int width, int height,
uint32_t recordingFlags) {
if (fPlayback) {
SkDELETE(fPlayback);
fPlayback = NULL;
}
if (NULL != fRecord) {
fRecord->unref();
fRecord = NULL;
}
SkBitmap bm;
bm.setConfig(SkBitmap::kNo_Config, width, height);
SkAutoTUnref<SkDevice> dev(SkNEW_ARGS(SkDevice, (bm)));
// Must be set before calling createBBoxHierarchy
fWidth = width;
fHeight = height;
if (recordingFlags & kOptimizeForClippedPlayback_RecordingFlag) {
SkBBoxHierarchy* tree = this->createBBoxHierarchy();
SkASSERT(NULL != tree);
fRecord = SkNEW_ARGS(SkBBoxHierarchyRecord, (recordingFlags, tree, dev));
tree->unref();
} else {
fRecord = SkNEW_ARGS(SkPictureRecord, (recordingFlags, dev));
}
fRecord->beginRecording();
return fRecord;
}
void SkPicture::clone(SkPicture* pictures, int count) const {
SkPictCopyInfo copyInfo;
for (int i = 0; i < count; i++) {
SkPicture* clone = &pictures[i];
clone->fWidth = fWidth;
clone->fHeight = fHeight;
clone->fRecord = NULL;
if (NULL != clone->fRecord) {
clone->fRecord->unref();
clone->fRecord = NULL;
}
SkDELETE(clone->fPlayback);
/* We want to copy the src's playback. However, if that hasn't been built
yet, we need to fake a call to endRecording() without actually calling
it (since it is destructive, and we don't want to change src).
*/
if (fPlayback) {
clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fPlayback, ©Info));
} else if (fRecord) {
// here we do a fake src.endRecording()
clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fRecord, true));
} else {
clone->fPlayback = NULL;
}
}
}
// Remove the specified atlas from the cache
void GrTextureStripAtlas::CleanUp(const GrContext*, void* info) {
SkASSERT(NULL != info);
AtlasEntry* entry = static_cast<AtlasEntry*>(info);
// remove the cache entry
GetCache()->remove(entry->fKey, entry);
// remove the actual entry
SkDELETE(entry);
if (0 == GetCache()->count()) {
SkDELETE(gAtlasCache);
gAtlasCache = NULL;
}
}
void GrContext::initMockContext() {
SkASSERT(NULL == fGpu);
fGpu = SkNEW_ARGS(MockGpu, (this));
SkASSERT(fGpu);
this->initCommon();
// We delete these because we want to test the cache starting with zero resources. Also, none of
// these objects are required for any of tests that use this context. TODO: make stop allocating
// resources in the buffer pools.
SkDELETE(fDrawBuffer);
SkDELETE(fDrawBufferVBAllocPool);
SkDELETE(fDrawBufferIBAllocPool);
fDrawBuffer = NULL;
fDrawBufferVBAllocPool = NULL;
fDrawBufferIBAllocPool = NULL;
}
void GrGpuGL::ProgramCache::abandon() {
for (int i = 0; i < fCount; ++i) {
SkASSERT(fEntries[i]->fProgram.get());
fEntries[i]->fProgram->abandon();
SkDELETE(fEntries[i]);
}
fCount = 0;
}
Sk3DView::~Sk3DView() {
Rec* rec = fRec;
while (rec != &fInitialRec) {
Rec* next = rec->fNext;
SkDELETE(rec);
rec = next;
}
}
void SkPixelRef::addGenIDChangeListener(GenIDChangeListener* listener) {
if (NULL == listener || !fUniqueGenerationID) {
// No point in tracking this if we're not going to call it.
SkDELETE(listener);
return;
}
*fGenIDChangeListeners.append() = listener;
}
void Sk3DView::restore() {
fMutex.acquire();
SkASSERT(fRec != &fInitialRec);
Rec* next = fRec->fNext;
SkDELETE(fRec);
fRec = next;
fMutex.release();
}
void
SkFontData::deleteTypeface()
{
if( mTypeface )
{
SkDELETE( mTypeface );
}
}
void SkAnimator::initialize() {
SkDELETE(fMaker);
fMaker = SkNEW_ARGS(SkAnimateMaker, (this, NULL, NULL));
decodeMemory(gMathPrimer, sizeof(gMathPrimer)-1);
#ifdef ANDROID
InitializeSkExtraPathEffects(this);
#endif
}
void SkTLS::Destructor(void* ptr) {
SkTLSRec* rec = (SkTLSRec*)ptr;
do {
SkTLSRec* next = rec->fNext;
SkDELETE(rec);
rec = next;
} while (NULL != rec);
}
void GpuTask::run(GrContextFactory& factory) {
if (FLAGS_gpu && !this->shouldSkip()) {
this->start();
if (!FLAGS_dryRun) this->draw(&factory);
this->finish();
}
SkDELETE(this);
}
SkLayerDrawLooper::~SkLayerDrawLooper() {
Rec* rec = fRecs;
while (rec) {
Rec* next = rec->fNext;
SkDELETE(rec);
rec = next;
}
}
void CpuTask::run() {
if (FLAGS_cpu && !this->shouldSkip()) {
this->start();
if (!FLAGS_dryRun) this->draw();
this->finish();
}
SkDELETE(this);
}
void SkGlyphCache::invokeAndRemoveAuxProcs() {
AuxProcRec* rec = fAuxProcList;
while (rec) {
rec->fProc(rec->fData);
AuxProcRec* next = rec->fNext;
SkDELETE(rec);
rec = next;
}
}
void GrGpuResource::notifyIsPurgeable() const {
if (this->wasDestroyed()) {
// We've already been removed from the cache. Goodbye cruel world!
SkDELETE(this);
} else {
GrGpuResource* mutableThis = const_cast<GrGpuResource*>(this);
get_resource_cache(fGpu)->resourceAccess().notifyPurgeable(mutableThis);
}
}
void SkMultiPictureDraw::reset() {
for (int i = 0; i < fDrawData.count(); ++i) {
fDrawData[i].picture->unref();
fDrawData[i].canvas->unref();
SkDELETE(fDrawData[i].paint);
}
fDrawData.rewind();
}
// Helper function to call destructors on SkPaints held by layers and delete layers.
static void clean_up_layers(SkDeque* layers) {
SkDeque::F2BIter iter(*layers);
SkLayerRasterizer_Rec* rec;
while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
rec->fPaint.~SkPaint();
SkDELETE(layers);
}
static void test_newraster(skiatest::Reporter* reporter) {
SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
const size_t minRowBytes = info.minRowBytes();
const size_t size = info.getSafeSize(minRowBytes);
SkAutoMalloc storage(size);
SkPMColor* baseAddr = static_cast<SkPMColor*>(storage.get());
sk_bzero(baseAddr, size);
SkCanvas* canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
REPORTER_ASSERT(reporter, canvas);
SkImageInfo info2;
size_t rowBytes;
const SkPMColor* addr = (const SkPMColor*)canvas->peekPixels(&info2, &rowBytes);
REPORTER_ASSERT(reporter, addr);
REPORTER_ASSERT(reporter, info == info2);
REPORTER_ASSERT(reporter, minRowBytes == rowBytes);
for (int y = 0; y < info.height(); ++y) {
for (int x = 0; x < info.width(); ++x) {
REPORTER_ASSERT(reporter, 0 == addr[x]);
}
addr = (const SkPMColor*)((const char*)addr + rowBytes);
}
SkDELETE(canvas);
// now try a deliberately bad info
info = info.makeWH(-1, info.height());
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
// too big
info = info.makeWH(1 << 30, 1 << 30);
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
// not a valid pixel type
info = SkImageInfo::Make(10, 10, kUnknown_SkColorType, info.alphaType());
REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes));
// We should succeed with a zero-sized valid info
info = SkImageInfo::MakeN32Premul(0, 0);
canvas = SkCanvas::NewRasterDirect(info, baseAddr, minRowBytes);
REPORTER_ASSERT(reporter, canvas);
SkDELETE(canvas);
}
void CpuTask::run() {
// If the task says skip, or if we're starting a top-level CPU task and we don't want to, skip.
const bool skip = this->shouldSkip() || (this->depth() == 0 && !FLAGS_cpu);
if (!skip) {
this->start();
if (!FLAGS_dryRun) this->draw();
this->finish();
}
SkDELETE(this);
}
GrContext::~GrContext() {
if (!fGpu) {
return;
}
this->flush();
for (int i = 0; i < fCleanUpData.count(); ++i) {
(*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
}
SkDELETE(fResourceProvider);
SkDELETE(fResourceCache);
SkDELETE(fBatchFontCache);
fGpu->unref();
SkSafeUnref(fPathRendererChain);
SkSafeUnref(fSoftwarePathRenderer);
}
