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); }