sk_sp<SkFlattenable> SkPictureImageFilter::CreateProc(SkReadBuffer& buffer) { sk_sp<SkPicture> picture; SkRect cropRect; if (buffer.isCrossProcess() && SkPicture::PictureIOSecurityPrecautionsEnabled()) { buffer.validate(!buffer.readBool()); } else { if (buffer.readBool()) { picture = SkPicture::MakeFromBuffer(buffer); } } buffer.readRect(&cropRect); PictureResolution pictureResolution; if (buffer.isVersionLT(SkReadBuffer::kPictureImageFilterResolution_Version)) { pictureResolution = kDeviceSpace_PictureResolution; } else { pictureResolution = (PictureResolution)buffer.readInt(); } if (kLocalSpace_PictureResolution == pictureResolution) { //filterLevel is only serialized if pictureResolution is LocalSpace SkFilterQuality filterQuality; if (buffer.isVersionLT(SkReadBuffer::kPictureImageFilterLevel_Version)) { filterQuality = kLow_SkFilterQuality; } else { filterQuality = (SkFilterQuality)buffer.readInt(); } return MakeForLocalSpace(picture, cropRect, filterQuality); } return Make(picture, cropRect); }
bool SkImageFilter::Common::unflatten(SkReadBuffer& buffer, int expectedCount) { const int count = buffer.readInt(); if (!buffer.validate(count >= 0)) { return false; } if (!buffer.validate(expectedCount < 0 || count == expectedCount)) { return false; } this->allocInputs(count); for (int i = 0; i < count; i++) { if (buffer.readBool()) { fInputs[i] = buffer.readImageFilter(); } if (!buffer.isValid()) { return false; } } SkRect rect; buffer.readRect(&rect); if (!buffer.isValid() || !buffer.validate(SkIsValidRect(rect))) { return false; } uint32_t flags = buffer.readUInt(); fCropRect = CropRect(rect, flags); if (buffer.isVersionLT(SkReadBuffer::kImageFilterNoUniqueID_Version)) { (void) buffer.readUInt(); } return buffer.isValid(); }
SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) { bool useOldPic = buffer.isVersionLT(SkReadBuffer::kDashWritesPhaseIntervals_Version); if (useOldPic) { fInitialDashIndex = buffer.readInt(); fInitialDashLength = buffer.readScalar(); fIntervalLength = buffer.readScalar(); buffer.readBool(); // Dummy for old ScalarToFit field } else { fPhase = buffer.readScalar(); } fCount = buffer.getArrayCount(); size_t allocSize = sizeof(SkScalar) * fCount; if (buffer.validateAvailable(allocSize)) { fIntervals = (SkScalar*)sk_malloc_throw(allocSize); buffer.readScalarArray(fIntervals, fCount); } else { fIntervals = NULL; } if (useOldPic) { fPhase = 0; if (fInitialDashLength != -1) { // Signal for bad dash interval for (int i = 0; i < fInitialDashIndex; ++i) { fPhase += fIntervals[i]; } fPhase += fIntervals[fInitialDashIndex] - fInitialDashLength; } } else { this->setInternalMembers(fPhase); } }
SkColorTable::SkColorTable(SkReadBuffer& buffer) { if (buffer.isVersionLT(SkReadBuffer::kRemoveColorTableAlpha_Version)) { /*fAlphaType = */buffer.readUInt(); } fCount = buffer.getArrayCount(); size_t allocSize = fCount * sizeof(SkPMColor); SkDEBUGCODE(bool success = false;) if (buffer.validateAvailable(allocSize)) {
SkLocalMatrixShader::SkLocalMatrixShader(SkReadBuffer& buffer) : INHERITED(buffer) { if (buffer.isVersionLT(SkReadBuffer::kSimplifyLocalMatrix_Version)) { buffer.readMatrix(&(INHERITED::fLocalMatrix)); } fProxyShader.reset(buffer.readShader()); if (NULL == fProxyShader.get()) { sk_throw(); } }
SkColorShader::SkColorShader(SkReadBuffer& b) : INHERITED(b) { // V25_COMPATIBILITY_CODE We had a boolean to make the color shader inherit the paint's // color. We don't support that any more. if (b.isVersionLT(SkReadBuffer::kColorShaderNoBool_Version)) { if (b.readBool()) { SkDEBUGFAIL("We shouldn't have pictures that recorded the inherited case."); fColor = SK_ColorWHITE; return; } } fColor = b.readColor(); }
sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) { SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); SkScalar dx = buffer.readScalar(); SkScalar dy = buffer.readScalar(); SkScalar sigmaX = buffer.readScalar(); SkScalar sigmaY = buffer.readScalar(); SkColor color = buffer.readColor(); ShadowMode shadowMode = buffer.isVersionLT(SkReadBuffer::kDropShadowMode_Version) ? kDrawShadowAndForeground_ShadowMode : static_cast<ShadowMode>(buffer.readInt()); return Make(dx, dy, sigmaX, sigmaY, color, shadowMode, common.getInput(0), &common.cropRect()); }
sk_sp<SkFlattenable> SkComposeShader::CreateProc(SkReadBuffer& buffer) { sk_sp<SkShader> shaderA(buffer.readShader()); sk_sp<SkShader> shaderB(buffer.readShader()); SkBlendMode mode; if (buffer.isVersionLT(SkReadBuffer::kXfermodeToBlendMode2_Version)) { sk_sp<SkXfermode> xfer = buffer.readXfermode(); mode = xfer ? xfer->blend() : SkBlendMode::kSrcOver; } else { mode = (SkBlendMode)buffer.read32(); } if (!shaderA || !shaderB) { return nullptr; } return sk_make_sp<SkComposeShader>(std::move(shaderA), std::move(shaderB), mode); }
SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buffer) { if (buffer.isVersionLT(SkReadBuffer::kNoUnitMappers_Version)) { // skip the old SkUnitMapper slot buffer.skipFlattenable(); } int colorCount = fColorCount = buffer.getArrayCount(); if (colorCount > kColorStorageCount) { size_t allocSize = (sizeof(SkColor) + sizeof(SkScalar) + sizeof(Rec)) * colorCount; if (buffer.validateAvailable(allocSize)) { fOrigColors = reinterpret_cast<SkColor*>(sk_malloc_throw(allocSize)); } else { fOrigColors = NULL; colorCount = fColorCount = 0; } } else { fOrigColors = fStorage; } buffer.readColorArray(fOrigColors, colorCount); fOrigPos = (SkScalar*)(fOrigColors + colorCount); { uint32_t packed = buffer.readUInt(); fGradFlags = SkToU8(unpack_flags(packed)); fTileMode = unpack_mode(packed); } fTileProc = gTileProcs[fTileMode]; fRecs = (Rec*)(fOrigPos + colorCount); if (colorCount > 2) { Rec* recs = fRecs; recs[0].fPos = 0; fOrigPos[0] = 0; for (int i = 1; i < colorCount; i++) { recs[i].fPos = buffer.readInt(); recs[i].fScale = buffer.readUInt(); fOrigPos[i] = SkFixedToScalar(recs[i].fPos); } } else { fOrigPos = NULL; } buffer.readMatrix(&fPtsToUnit); this->initCommon(); }
SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) , fPhase(0) , fInitialDashLength(0) , fInitialDashIndex(0) , fIntervalLength(0) { bool useOldPic = buffer.isVersionLT(SkReadBuffer::kDashWritesPhaseIntervals_Version); if (useOldPic) { fInitialDashIndex = buffer.readInt(); fInitialDashLength = buffer.readScalar(); fIntervalLength = buffer.readScalar(); buffer.readBool(); // Dummy for old ScalarToFit field } else { fPhase = buffer.readScalar(); } fCount = buffer.getArrayCount(); size_t allocSize = sizeof(SkScalar) * fCount; if (buffer.validateAvailable(allocSize)) { fIntervals = (SkScalar*)sk_malloc_throw(allocSize); buffer.readScalarArray(fIntervals, fCount); } else { fIntervals = NULL; } if (useOldPic) { fPhase = 0; if (fInitialDashLength != -1) { // Signal for bad dash interval for (int i = 0; i < fInitialDashIndex; ++i) { fPhase += fIntervals[i]; } fPhase += fIntervals[fInitialDashIndex] - fInitialDashLength; } } else { // set the internal data members, fPhase should have been between 0 and intervalLength // when written to buffer so no need to adjust it SkDashPath::CalcDashParameters(fPhase, fIntervals, fCount, &fInitialDashLength, &fInitialDashIndex, &fIntervalLength); } }