bool SkImageRef_ashmem::onDecode(SkImageDecoder* codec, SkStreamRewindable* stream,
SkBitmap* bitmap, SkBitmap::Config config,
SkImageDecoder::Mode mode) {
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
return this->INHERITED::onDecode(codec, stream, bitmap, config, mode);
}
// Ashmem memory is guaranteed to be initialized to 0.
codec->setSkipWritingZeroes(true);
AshmemAllocator alloc(&fRec, this->getURI());
codec->setAllocator(&alloc);
bool success = this->INHERITED::onDecode(codec, stream, bitmap, config,
mode);
// remove the allocator, since its on the stack
codec->setAllocator(NULL);
if (success) {
// remember the colortable (if any)
SkRefCnt_SafeAssign(fCT, bitmap->getColorTable());
return true;
} else {
if (fRec.fPinned) {
ashmem_unpin_region(fRec.fFD, 0, 0);
fRec.fPinned = false;
}
this->closeFD();
return false;
}
}
void SkWriteBuffer::setBitmapHeap(SkBitmapHeap* bitmapHeap) {
SkRefCnt_SafeAssign(fBitmapHeap, bitmapHeap);
if (bitmapHeap != NULL) {
SkASSERT(NULL == fPixelSerializer);
fPixelSerializer.reset(NULL);
}
}
SkNamedFactorySet* SkOrderedWriteBuffer::setNamedFactoryRecorder(SkNamedFactorySet* rec) {
SkRefCnt_SafeAssign(fNamedFactorySet, rec);
if (fFactorySet != NULL) {
fFactorySet->unref();
fFactorySet = NULL;
}
return rec;
}
void doPreDraw(SkColorFilter* colorFilters[], int nFilters) {
// Create a chain of ImageFilters from colorFilters
fImageFilter = nullptr;
for(int i = nFilters; i --> 0;) {
SkAutoTUnref<SkImageFilter> filter(
SkColorFilterImageFilter::Create(colorFilters[i], fImageFilter, nullptr)
);
SkRefCnt_SafeAssign(fImageFilter, filter.get());
}
}
void GrRenderTarget::setLastDrawTarget(GrDrawTarget* dt) {
if (fLastDrawTarget) {
// The non-MDB world never closes so we can't check this condition
#ifdef ENABLE_MDB
SkASSERT(fLastDrawTarget->isClosed());
#endif
fLastDrawTarget->clearRT();
}
SkRefCnt_SafeAssign(fLastDrawTarget, dt);
}
SkListSource* SkGridView::setListSource(SkListSource* src)
{
if (fSource != src)
{
SkRefCnt_SafeAssign(fSource, src);
// this->dirtyStrCache();
this->ensureSelectionIsVisible();
this->inval(NULL);
}
return src;
}
void SkDebugger::loadPicture(SkPicture* picture) {
fPictureWidth = picture->width();
fPictureHeight = picture->height();
delete fDebugCanvas;
fDebugCanvas = new SkDebugCanvas(fPictureWidth, fPictureHeight);
fDebugCanvas->setBounds(fPictureWidth, fPictureHeight);
fDebugCanvas->setPicture(picture);
picture->draw(fDebugCanvas);
fDebugCanvas->setPicture(NULL);
fIndex = fDebugCanvas->getSize() - 1;
SkRefCnt_SafeAssign(fPicture, picture);
}
SkListSource* SkListView::setListSource(SkListSource* src)
{
if (fSource != src)
{
SkRefCnt_SafeAssign(fSource, src);
this->ensureSelectionIsVisible();
this->inval(NULL);
if (fScrollBar)
fScrollBar->setTotal(fSource->countRecords());
}
return src;
}
FontPlatformData& FontPlatformData::operator=(const FontPlatformData& src)
{
SkRefCnt_SafeAssign(m_typeface, src.m_typeface);
m_family = src.m_family;
m_textSize = src.m_textSize;
m_fakeBold = src.m_fakeBold;
m_fakeItalic = src.m_fakeItalic;
m_harfbuzzFace = src.m_harfbuzzFace;
m_orientation = src.m_orientation;
m_textOrientation = src.m_textOrientation;
m_style = src.m_style;
m_emSizeInFontUnits = src.m_emSizeInFontUnits;
return *this;
}
SkView::Artist* SkView::setArtist(Artist* obj)
{
if (obj == NULL)
{
this->removeTagList(kViewArtist_SkTagList);
}
else // add/replace
{
Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList);
if (rec)
SkRefCnt_SafeAssign(rec->fArtist, obj);
else
this->addTagList(new Artist_SkTagList(obj));
}
return obj;
}
FontPlatformData& FontPlatformData::operator=(const FontPlatformData& data)
{
if (this != &data) {
m_font = data.m_font;
m_size = data.m_size;
SkRefCnt_SafeAssign(m_typeface, data.m_typeface);
m_lfQuality = data.m_lfQuality;
// The following fields will get re-computed if necessary.
ScriptFreeCache(&m_scriptCache);
m_scriptCache = 0;
delete m_scriptFontProperties;
m_scriptFontProperties = 0;
}
return *this;
}
SkView::Layout* SkView::setLayout(Layout* obj, bool invokeLayoutNow)
{
if (obj == NULL)
{
this->removeTagList(kViewLayout_SkTagList);
}
else // add/replace
{
Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList);
if (rec)
SkRefCnt_SafeAssign(rec->fLayout, obj);
else
this->addTagList(new Layout_SkTagList(obj));
}
if (invokeLayoutNow)
this->invokeLayout();
return obj;
}
SkBitmap::Allocator* SkImageDecoder::setAllocator(SkBitmap::Allocator* alloc) {
SkRefCnt_SafeAssign(fAllocator, alloc);
return alloc;
}
SkImageDecoder::Chooser* SkImageDecoder::setChooser(Chooser* chooser) {
SkRefCnt_SafeAssign(fChooser, chooser);
return chooser;
}
SkImageDecoder::Peeker* SkImageDecoder::setPeeker(Peeker* peeker) {
SkRefCnt_SafeAssign(fPeeker, peeker);
return peeker;
}
SkImageDecoderFactory* SkImageRef::setDecoderFactory(
SkImageDecoderFactory* fact) {
SkRefCnt_SafeAssign(fFactory, fact);
return fact;
}
void PlatformContextSkia::setDrawLooper(SkDrawLooper* dl)
{
SkRefCnt_SafeAssign(m_state->m_looper, dl);
}
void setSharedHeap(SkBitmapHeap* heap) {
SkASSERT(!shouldFlattenBitmaps(fFlags) || NULL == heap);
SkRefCnt_SafeAssign(fSharedHeap, heap);
this->updateReader();
}
SkFactoryRecorder* SkFlattenableWriteBuffer::setFactoryRecorder(
SkFactoryRecorder* rec) {
SkRefCnt_SafeAssign(fFactoryRecorder, rec);
return rec;
}
void DeferredLayerUpdater::setPaint(const SkPaint* paint) {
OpenGLRenderer::getAlphaAndModeDirect(paint, &mAlpha, &mMode);
SkColorFilter* colorFilter = (paint) ? paint->getColorFilter() : NULL;
SkRefCnt_SafeAssign(mColorFilter, colorFilter);
}
void Layer::setColorFilter(SkColorFilter* filter) {
SkRefCnt_SafeAssign(colorFilter, filter);
}
void SkDeferredCanvas::DeferredDevice::setDeviceContext(
DeviceContext* deviceContext) {
SkRefCnt_SafeAssign(fDeviceContext, deviceContext);
}
SkTextStyle* SkTextLayout::setDefaultStyle(SkTextStyle* style) {
SkRefCnt_SafeAssign(fDefaultStyle, style);
return style;
}
void SkProxyCanvas::setProxy(SkCanvas* proxy) {
SkRefCnt_SafeAssign(fProxy, proxy);
}
SkRefCntRecorder* SkFlattenableWriteBuffer::setTypefaceRecorder(
SkRefCntRecorder* rec) {
SkRefCnt_SafeAssign(fTFRecorder, rec);
return rec;
}
SkRefCntSet* SkFlattenableWriteBuffer::setRefCntRecorder(SkRefCntSet* rec) {
SkRefCnt_SafeAssign(fRCSet, rec);
return rec;
}
SkFactorySet* SkBinaryWriteBuffer::setFactoryRecorder(SkFactorySet* rec) {
SkRefCnt_SafeAssign(fFactorySet, rec);
return rec;
}
SkRefCntSet* SkBinaryWriteBuffer::setTypefaceRecorder(SkRefCntSet* rec) {
SkRefCnt_SafeAssign(fTFSet, rec);
return rec;
}
Draw* setDraw(Draw* d) {
SkRefCnt_SafeAssign(fDraw, d);
return d;
}
void setUnrefWhenDestroyed(TestResource* resource) {
SkRefCnt_SafeAssign(fToDelete, resource);
}
