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