Revert of Remove SK_SUPPORT_LEGACY_DEEPFLATTENING. (patchset #1 id:1 of https://codereview.chromium.org/769953002/)
Reason for revert:
Breaks canary builds. Will reland after the Chromium change lands.
Original issue's description:
> Remove SK_SUPPORT_LEGACY_DEEPFLATTENING.
>
> This was needed for pictures before v33, and we're now requiring v35+.
>
> Will follow up with the same for skia/ext/pixel_ref_utils_unittest.cc
>
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/52c293547b973f7fb5de3c83f5062b07d759ab88
TBR=reed@google.com,mtklein@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=skia:
Review URL: https://codereview.chromium.org/768183002
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index f01d559..1a451fd 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -39,6 +39,15 @@
fTileModeY = (uint8_t)tmy;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkBitmapProcShader::SkBitmapProcShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ buffer.readBitmap(&fRawBitmap);
+ fRawBitmap.setImmutable();
+ fTileModeX = buffer.readUInt();
+ fTileModeY = buffer.readUInt();
+}
+#endif
+
SkShader::BitmapType SkBitmapProcShader::asABitmap(SkBitmap* texture,
SkMatrix* texM,
TileMode xy[]) const {
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index e6ff1af..17bb83b 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -56,6 +56,9 @@
};
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkBitmapProcShader(SkReadBuffer& );
+#endif
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index ba260ad..f4669d5 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -714,6 +714,15 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Sk3DShader)
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ Sk3DShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fProxy = buffer.readShader();
+ // Leaving this here until we bump the picture version, though this
+ // shader should never be recorded.
+ buffer.readColor();
+ }
+#endif
+
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
buffer.writeFlattenable(fProxy);
}
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index 3c6623d..3c5b55a 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -26,6 +26,20 @@
SkSafeRef(mode);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkComposeShader::SkComposeShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fShaderA = buffer.readShader();
+ if (NULL == fShaderA) {
+ fShaderA = SkNEW_ARGS(SkColorShader, ((SkColor)0));
+ }
+ fShaderB = buffer.readShader();
+ if (NULL == fShaderB) {
+ fShaderB = SkNEW_ARGS(SkColorShader, ((SkColor)0));
+ }
+ fMode = buffer.readXfermode();
+}
+#endif
+
SkComposeShader::~SkComposeShader() {
SkSafeUnref(fMode);
fShaderB->unref();
diff --git a/src/core/SkEmptyShader.h b/src/core/SkEmptyShader.h
index b7fefbe..250e37a 100644
--- a/src/core/SkEmptyShader.h
+++ b/src/core/SkEmptyShader.h
@@ -30,6 +30,10 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmptyShader)
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkEmptyShader(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#endif
+
virtual SkShader::Context* onCreateContext(const ContextRec&, void*) const SK_OVERRIDE {
return NULL;
}
diff --git a/src/core/SkFilterShader.cpp b/src/core/SkFilterShader.cpp
index 48c4b8b..cb042e6 100644
--- a/src/core/SkFilterShader.cpp
+++ b/src/core/SkFilterShader.cpp
@@ -21,6 +21,13 @@
filter->ref();
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkFilterShader::SkFilterShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fShader = buffer.readShader();
+ fFilter = buffer.readColorFilter();
+}
+#endif
+
SkFilterShader::~SkFilterShader() {
fFilter->unref();
fShader->unref();
diff --git a/src/core/SkFilterShader.h b/src/core/SkFilterShader.h
index 44c2632..b98fc83 100644
--- a/src/core/SkFilterShader.h
+++ b/src/core/SkFilterShader.h
@@ -45,6 +45,9 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkFilterShader)
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkFilterShader(SkReadBuffer&);
+#endif
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
diff --git a/src/core/SkFlattenable.cpp b/src/core/SkFlattenable.cpp
index 27efe7e..f8fdd4f 100644
--- a/src/core/SkFlattenable.cpp
+++ b/src/core/SkFlattenable.cpp
@@ -9,6 +9,16 @@
#include "SkPtrRecorder.h"
#include "SkReadBuffer.h"
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+bool SkFlattenable::NeedsDeepUnflatten(const SkReadBuffer& buffer) {
+ return false; // TODO: looks like all this can go away too now?
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
SkNamedFactorySet::SkNamedFactorySet() : fNextAddedFactory(0) {}
uint32_t SkNamedFactorySet::find(SkFlattenable::Factory factory) {
@@ -47,6 +57,8 @@
}
///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
#define MAX_ENTRY_COUNT 1024
diff --git a/src/core/SkLocalMatrixShader.cpp b/src/core/SkLocalMatrixShader.cpp
index 544ad2f..62d5e36 100644
--- a/src/core/SkLocalMatrixShader.cpp
+++ b/src/core/SkLocalMatrixShader.cpp
@@ -7,6 +7,15 @@
#include "SkLocalMatrixShader.h"
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLocalMatrixShader::SkLocalMatrixShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fProxyShader.reset(buffer.readShader());
+ if (NULL == fProxyShader.get()) {
+ sk_throw();
+ }
+}
+#endif
+
SkFlattenable* SkLocalMatrixShader::CreateProc(SkReadBuffer& buffer) {
SkMatrix lm;
buffer.readMatrix(&lm);
diff --git a/src/core/SkLocalMatrixShader.h b/src/core/SkLocalMatrixShader.h
index aad5668..b8e4714 100644
--- a/src/core/SkLocalMatrixShader.h
+++ b/src/core/SkLocalMatrixShader.h
@@ -33,7 +33,7 @@
}
#if SK_SUPPORT_GPU
-
+
virtual bool asFragmentProcessor(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* grColor,
GrFragmentProcessor** fp) const SK_OVERRIDE {
@@ -43,17 +43,17 @@
}
return fProxyShader->asFragmentProcessor(context, paint, &tmp, grColor, fp);
}
-
-#else
-
+
+#else
+
virtual bool asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix*, GrColor*,
GrFragmentProcessor**) const SK_OVERRIDE {
SkDEBUGFAIL("Should not call in GPU-less build");
return false;
}
-
+
#endif
-
+
virtual SkShader* refAsALocalMatrixShader(SkMatrix* localMatrix) const SK_OVERRIDE {
if (localMatrix) {
*localMatrix = this->getLocalMatrix();
@@ -65,6 +65,9 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLocalMatrixShader)
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkLocalMatrixShader(SkReadBuffer&);
+#endif
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual Context* onCreateContext(const ContextRec&, void*) const SK_OVERRIDE;
diff --git a/src/core/SkPathEffect.cpp b/src/core/SkPathEffect.cpp
index 7338789..d074867 100644
--- a/src/core/SkPathEffect.cpp
+++ b/src/core/SkPathEffect.cpp
@@ -49,6 +49,14 @@
buffer.writeFlattenable(fPE1);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPairPathEffect::SkPairPathEffect(SkReadBuffer& buffer) {
+ fPE0 = buffer.readPathEffect();
+ fPE1 = buffer.readPathEffect();
+ // either of these may fail, so we have to check for nulls later on
+}
+#endif
+
///////////////////////////////////////////////////////////////////////////////
SkFlattenable* SkComposePathEffect::CreateProc(SkReadBuffer& buffer) {
diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp
index 5fded93..1f32a7e 100644
--- a/src/core/SkPictureShader.cpp
+++ b/src/core/SkPictureShader.cpp
@@ -100,6 +100,15 @@
, fTmy(tmy) {
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPictureShader::SkPictureShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fTmx = static_cast<SkShader::TileMode>(buffer.read32());
+ fTmy = static_cast<SkShader::TileMode>(buffer.read32());
+ buffer.readRect(&fTile);
+ fPicture = SkPicture::CreateFromBuffer(buffer);
+}
+#endif
+
SkPictureShader::~SkPictureShader() {
fPicture->unref();
}
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 816d6fd..39e8ed3 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -46,6 +46,17 @@
}
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkShader::SkShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ inc_shader_counter();
+ if (buffer.readBool()) {
+ buffer.readMatrix(&fLocalMatrix);
+ } else {
+ fLocalMatrix.reset();
+ }
+}
+#endif
+
SkShader::~SkShader() {
dec_shader_counter();
}
@@ -260,6 +271,12 @@
return SkColorGetA(fColor) == 255;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkColorShader::SkColorShader(SkReadBuffer& b) : INHERITED(b) {
+ fColor = b.readColor();
+}
+#endif
+
SkFlattenable* SkColorShader::CreateProc(SkReadBuffer& buffer) {
return SkNEW_ARGS(SkColorShader, (buffer.readColor()));
}
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index e0abb4e..4a3ec39 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -1237,6 +1237,23 @@
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkProcCoeffXfermode::SkProcCoeffXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
+ uint32_t mode32 = buffer.read32() % SK_ARRAY_COUNT(gProcCoeffs);
+ if (mode32 >= SK_ARRAY_COUNT(gProcCoeffs)) {
+ // out of range, just set to something harmless
+ mode32 = SkXfermode::kSrcOut_Mode;
+ }
+ fMode = (SkXfermode::Mode)mode32;
+
+ const ProcCoeff& rec = gProcCoeffs[fMode];
+ fProc = rec.fProc;
+ // these may be valid, or may be CANNOT_USE_COEFF
+ fSrcCoeff = rec.fSC;
+ fDstCoeff = rec.fDC;
+}
+#endif
+
SkFlattenable* SkProcCoeffXfermode::CreateProc(SkReadBuffer& buffer) {
uint32_t mode32 = buffer.read32();
if (!buffer.validate(mode32 < SK_ARRAY_COUNT(gProcCoeffs))) {
@@ -1426,6 +1443,9 @@
private:
SkClearXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kClear_Mode) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkClearXfermode(SkReadBuffer& buffer) : SkProcCoeffXfermode(buffer) {}
+#endif
typedef SkProcCoeffXfermode INHERITED;
};
@@ -1488,6 +1508,9 @@
private:
SkSrcXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kSrc_Mode) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkSrcXfermode(SkReadBuffer& buffer) : SkProcCoeffXfermode(buffer) {}
+#endif
typedef SkProcCoeffXfermode INHERITED;
};
@@ -1553,6 +1576,9 @@
private:
SkDstInXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kDstIn_Mode) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkDstInXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#endif
typedef SkProcCoeffXfermode INHERITED;
};
@@ -1597,6 +1623,9 @@
private:
SkDstOutXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kDstOut_Mode) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkDstOutXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#endif
typedef SkProcCoeffXfermode INHERITED;
};
diff --git a/src/core/SkXfermode_proccoeff.h b/src/core/SkXfermode_proccoeff.h
index d7b4704..f3b9b24 100644
--- a/src/core/SkXfermode_proccoeff.h
+++ b/src/core/SkXfermode_proccoeff.h
@@ -22,7 +22,7 @@
fSrcCoeff = rec.fSC;
fDstCoeff = rec.fDC;
}
-
+
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
const SkAlpha aa[]) const SK_OVERRIDE;
virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
@@ -43,6 +43,10 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkProcCoeffXfermode)
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkProcCoeffXfermode(SkReadBuffer& buffer);
+#endif
+
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
Mode getMode() const { return fMode; }
diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp
index 83f684e..47824fd 100644
--- a/src/effects/Sk1DPathEffect.cpp
+++ b/src/effects/Sk1DPathEffect.cpp
@@ -147,6 +147,22 @@
}
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPath1DPathEffect::SkPath1DPathEffect(SkReadBuffer& buffer) {
+ fAdvance = buffer.readScalar();
+ if (fAdvance > 0) {
+ buffer.readPath(&fPath);
+ fInitialOffset = buffer.readScalar();
+ fStyle = (Style) buffer.readUInt();
+ } else {
+ SkDEBUGF(("SkPath1DPathEffect can't use advance <= 0\n"));
+ // Make Coverity happy.
+ fInitialOffset = 0;
+ fStyle = kStyleCount;
+ }
+}
+#endif
+
SkScalar SkPath1DPathEffect::begin(SkScalar contourLength) const {
return fInitialOffset;
}
diff --git a/src/effects/Sk2DPathEffect.cpp b/src/effects/Sk2DPathEffect.cpp
index 2ad202a..cef2266 100644
--- a/src/effects/Sk2DPathEffect.cpp
+++ b/src/effects/Sk2DPathEffect.cpp
@@ -73,6 +73,13 @@
buffer.writeMatrix(fMatrix);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+Sk2DPathEffect::Sk2DPathEffect(SkReadBuffer& buffer) {
+ buffer.readMatrix(&fMatrix);
+ fMatrixIsInvertible = fMatrix.invert(&fInverse);
+}
+#endif
+
///////////////////////////////////////////////////////////////////////////////
bool SkLine2DPathEffect::filterPath(SkPath* dst, const SkPath& src,
@@ -97,6 +104,12 @@
}
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLine2DPathEffect::SkLine2DPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fWidth = buffer.readScalar();
+}
+#endif
+
SkFlattenable* SkLine2DPathEffect::CreateProc(SkReadBuffer& buffer) {
SkMatrix matrix;
buffer.readMatrix(&matrix);
@@ -115,6 +128,12 @@
: INHERITED(m), fPath(p) {
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPath2DPathEffect::SkPath2DPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
+ buffer.readPath(&fPath);
+}
+#endif
+
SkFlattenable* SkPath2DPathEffect::CreateProc(SkReadBuffer& buffer) {
SkMatrix matrix;
buffer.readMatrix(&matrix);
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index ffdba32..e181675 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -19,6 +19,9 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAlphaThresholdFilterImpl)
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ explicit SkAlphaThresholdFilterImpl(SkReadBuffer& buffer);
+#endif
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
@@ -235,6 +238,15 @@
#endif
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ fInnerThreshold = buffer.readScalar();
+ fOuterThreshold = buffer.readScalar();
+ buffer.readRegion(&fRegion);
+}
+#endif
+
SkFlattenable* SkAlphaThresholdFilterImpl::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkScalar inner = buffer.readScalar();
diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp
index d1e7472..6fb5241 100644
--- a/src/effects/SkArithmeticMode.cpp
+++ b/src/effects/SkArithmeticMode.cpp
@@ -49,6 +49,16 @@
fEnforcePMColor = enforcePMColor;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkArithmeticMode_scalar(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fK[0] = buffer.readScalar();
+ fK[1] = buffer.readScalar();
+ fK[2] = buffer.readScalar();
+ fK[3] = buffer.readScalar();
+ fEnforcePMColor = buffer.readBool();
+ }
+#endif
+
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
buffer.writeScalar(fK[0]);
buffer.writeScalar(fK[1]);
diff --git a/src/effects/SkAvoidXfermode.cpp b/src/effects/SkAvoidXfermode.cpp
index 41c4e96..b596bfd 100644
--- a/src/effects/SkAvoidXfermode.cpp
+++ b/src/effects/SkAvoidXfermode.cpp
@@ -21,6 +21,14 @@
fMode = mode;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkAvoidXfermode::SkAvoidXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fOpColor = buffer.readColor();
+ fDistMul = buffer.readUInt();
+ fMode = (Mode)buffer.readUInt();
+}
+#endif
+
SkFlattenable* SkAvoidXfermode::CreateProc(SkReadBuffer& buffer) {
const SkColor color = buffer.readColor();
const unsigned tolerance = buffer.readUInt();
diff --git a/src/effects/SkBitmapSource.cpp b/src/effects/SkBitmapSource.cpp
index ff76ab4..4da77a9 100644
--- a/src/effects/SkBitmapSource.cpp
+++ b/src/effects/SkBitmapSource.cpp
@@ -26,6 +26,15 @@
, fSrcRect(srcRect)
, fDstRect(dstRect) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkBitmapSource::SkBitmapSource(SkReadBuffer& buffer) : INHERITED(0, buffer) {
+ buffer.readBitmap(&fBitmap);
+ buffer.readRect(&fSrcRect);
+ buffer.readRect(&fDstRect);
+ buffer.validate(buffer.isValid() && SkIsValidRect(fSrcRect) && SkIsValidRect(fDstRect));
+}
+#endif
+
SkFlattenable* SkBitmapSource::CreateProc(SkReadBuffer& buffer) {
SkRect src, dst;
buffer.readRect(&src);
diff --git a/src/effects/SkBlurDrawLooper.cpp b/src/effects/SkBlurDrawLooper.cpp
index b3094d6..fc9e47b 100644
--- a/src/effects/SkBlurDrawLooper.cpp
+++ b/src/effects/SkBlurDrawLooper.cpp
@@ -62,6 +62,19 @@
this->initEffects();
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkBlurDrawLooper::SkBlurDrawLooper(SkReadBuffer& buffer) : INHERITED(buffer) {
+
+ fSigma = buffer.readScalar();
+ fDx = buffer.readScalar();
+ fDy = buffer.readScalar();
+ fBlurColor = buffer.readColor();
+ fBlurFlags = buffer.readUInt() & kAll_BlurFlag;
+
+ this->initEffects();
+}
+#endif
+
SkFlattenable* SkBlurDrawLooper::CreateProc(SkReadBuffer& buffer) {
const SkColor color = buffer.readColor();
const SkScalar sigma = buffer.readScalar();
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index e5bb8c1..4166d20 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -31,6 +31,18 @@
return sigma;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkBlurImageFilter::SkBlurImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ fSigma.fWidth = buffer.readScalar();
+ fSigma.fHeight = buffer.readScalar();
+ buffer.validate(SkScalarIsFinite(fSigma.fWidth) &&
+ SkScalarIsFinite(fSigma.fHeight) &&
+ (fSigma.fWidth >= 0) &&
+ (fSigma.fHeight >= 0));
+}
+#endif
+
SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX,
SkScalar sigmaY,
SkImageFilter* input,
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index b5bcc3c..5b0e60a 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -585,6 +585,16 @@
src.fRight + pad, src.fBottom + pad);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkReadBuffer& buffer) : SkMaskFilter(buffer) {
+ fSigma = buffer.readScalar();
+ fBlurStyle = (SkBlurStyle)buffer.readInt();
+ fBlurFlags = buffer.readUInt() & SkBlurMaskFilter::kAll_BlurFlag;
+ SkASSERT(fSigma > 0);
+ SkASSERT((unsigned)fBlurStyle <= kLastEnum_SkBlurStyle);
+}
+#endif
+
SkFlattenable* SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) {
const SkScalar sigma = buffer.readScalar();
const unsigned style = buffer.readUInt();
diff --git a/src/effects/SkColorCubeFilter.cpp b/src/effects/SkColorCubeFilter.cpp
index 30641c3..18c5b56 100644
--- a/src/effects/SkColorCubeFilter.cpp
+++ b/src/effects/SkColorCubeFilter.cpp
@@ -161,6 +161,15 @@
}
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkColorCubeFilter::SkColorCubeFilter(SkReadBuffer& buffer)
+ : fCache(buffer.readInt()) {
+ fCubeData.reset(buffer.readByteArrayAsData());
+ buffer.validate(is_valid_3D_lut(fCubeData, fCache.cubeDimension()));
+ fUniqueID = SkNextColorCubeUniqueID();
+}
+#endif
+
SkFlattenable* SkColorCubeFilter::CreateProc(SkReadBuffer& buffer) {
int cubeDimension = buffer.readInt();
SkAutoDataUnref cubeData(buffer.readByteArrayAsData());
diff --git a/src/effects/SkColorFilterImageFilter.cpp b/src/effects/SkColorFilterImageFilter.cpp
index 10976d7..012f132 100755
--- a/src/effects/SkColorFilterImageFilter.cpp
+++ b/src/effects/SkColorFilterImageFilter.cpp
@@ -84,6 +84,21 @@
: INHERITED(1, &input, cropRect, uniqueID), fColorFilter(SkRef(cf)) {
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkColorFilterImageFilter::SkColorFilterImageFilter(SkReadBuffer& buffer) : INHERITED(1, buffer) {
+ fColorFilter = buffer.readColorFilter();
+ // we aren't prepared for this to be NULL, and it can't ever be when we're NOT supporting
+ // SK_SUPPORT_LEGACY_DEEPFLATTENING, as we always go through a factory which can detect
+ // NULL. However, since here we're in the legacy code, we assign a dummy filter so we
+ // don't crash with a null-ptr.
+ if (NULL == fColorFilter) {
+ // colormatrix identity is effectively a no-op
+ fColorFilter = SkColorMatrixFilter::Create(SkColorMatrix());
+ SkASSERT(fColorFilter);
+ }
+}
+#endif
+
SkFlattenable* SkColorFilterImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkAutoTUnref<SkColorFilter> cf(buffer.readColorFilter());
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index 92e6f43..e085281 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -84,6 +84,17 @@
buffer.writeUInt(fMode);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkModeColorFilter(SkReadBuffer& buffer) {
+ fColor = buffer.readColor();
+ fMode = (SkXfermode::Mode)buffer.readUInt();
+ if (buffer.isValid()) {
+ this->updateCache();
+ buffer.validate(SkIsValidMode(fMode));
+ }
+ }
+#endif
+
private:
SkColor fColor;
SkXfermode::Mode fMode;
diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index 27231b1..2070292 100644
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -307,6 +307,15 @@
buffer.writeScalarArray(fMatrix.fMat, 20);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkColorMatrixFilter::SkColorMatrixFilter(SkReadBuffer& buffer) : INHERITED(buffer) {
+ SkASSERT(buffer.getArrayCount() == 20);
+ if (buffer.readScalarArray(fMatrix.fMat, 20)) {
+ this->initState(fMatrix.fMat);
+ }
+}
+#endif
+
SkFlattenable* SkColorMatrixFilter::CreateProc(SkReadBuffer& buffer) {
SkColorMatrix matrix;
if (buffer.readScalarArray(matrix.fMat, 20)) {
diff --git a/src/effects/SkComposeImageFilter.cpp b/src/effects/SkComposeImageFilter.cpp
index 9bec500..c055674 100644
--- a/src/effects/SkComposeImageFilter.cpp
+++ b/src/effects/SkComposeImageFilter.cpp
@@ -40,3 +40,9 @@
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
return SkComposeImageFilter::Create(common.getInput(0), common.getInput(1));
}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkComposeImageFilter::SkComposeImageFilter(SkReadBuffer& buffer)
+ : INHERITED(2, buffer) {
+}
+#endif
diff --git a/src/effects/SkCornerPathEffect.cpp b/src/effects/SkCornerPathEffect.cpp
index 8dc506a..0655882 100644
--- a/src/effects/SkCornerPathEffect.cpp
+++ b/src/effects/SkCornerPathEffect.cpp
@@ -135,3 +135,9 @@
void SkCornerPathEffect::flatten(SkWriteBuffer& buffer) const {
buffer.writeScalar(fRadius);
}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkCornerPathEffect::SkCornerPathEffect(SkReadBuffer& buffer) {
+ fRadius = buffer.readScalar();
+}
+#endif
diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp
index f866ea0..f31d883 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -369,3 +369,28 @@
}
return NULL;
}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer)
+ : INHERITED(buffer)
+ , fPhase(0)
+ , fInitialDashLength(0)
+ , fInitialDashIndex(0)
+ , fIntervalLength(0) {
+ 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;
+ }
+
+ // 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);
+}
+#endif
+
diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp
index 8aa0e22..e8cc6a2 100644
--- a/src/effects/SkDiscretePathEffect.cpp
+++ b/src/effects/SkDiscretePathEffect.cpp
@@ -87,3 +87,12 @@
buffer.writeScalar(fPerterb);
buffer.writeUInt(fSeedAssist);
}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkDiscretePathEffect::SkDiscretePathEffect(SkReadBuffer& buffer) {
+ fSegLength = buffer.readScalar();
+ fPerterb = buffer.readScalar();
+ fSeedAssist = buffer.readUInt();
+}
+#endif
+
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index d39240e..edae044 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -192,6 +192,19 @@
SkDisplacementMapEffect::~SkDisplacementMapEffect() {
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkDisplacementMapEffect::SkDisplacementMapEffect(SkReadBuffer& buffer)
+ : INHERITED(2, buffer)
+{
+ fXChannelSelector = (SkDisplacementMapEffect::ChannelSelectorType) buffer.readInt();
+ fYChannelSelector = (SkDisplacementMapEffect::ChannelSelectorType) buffer.readInt();
+ fScale = buffer.readScalar();
+ buffer.validate(channel_selector_type_is_valid(fXChannelSelector) &&
+ channel_selector_type_is_valid(fYChannelSelector) &&
+ SkScalarIsFinite(fScale));
+}
+#endif
+
SkFlattenable* SkDisplacementMapEffect::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
ChannelSelectorType xsel = (ChannelSelectorType)buffer.readInt();
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index 5bbb958..0ba8b23 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -29,6 +29,24 @@
{
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkDropShadowImageFilter::SkDropShadowImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ fDx = buffer.readScalar();
+ fDy = buffer.readScalar();
+ fSigmaX = buffer.readScalar();
+ fSigmaY = buffer.readScalar();
+ fColor = buffer.readColor();
+ fShadowMode = buffer.isVersionLT(SkReadBuffer::kDropShadowMode_Version) ?
+ kDrawShadowAndForeground_ShadowMode :
+ static_cast<ShadowMode>(buffer.readInt());
+ buffer.validate(SkScalarIsFinite(fDx) &&
+ SkScalarIsFinite(fDy) &&
+ SkScalarIsFinite(fSigmaX) &&
+ SkScalarIsFinite(fSigmaY));
+}
+#endif
+
SkFlattenable* SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkScalar dx = buffer.readScalar();
diff --git a/src/effects/SkEmbossMaskFilter.cpp b/src/effects/SkEmbossMaskFilter.cpp
index 8fcd272..4841b92 100644
--- a/src/effects/SkEmbossMaskFilter.cpp
+++ b/src/effects/SkEmbossMaskFilter.cpp
@@ -124,6 +124,15 @@
return true;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkEmbossMaskFilter::SkEmbossMaskFilter(SkReadBuffer& buffer) : SkMaskFilter(buffer) {
+ SkASSERT(buffer.getArrayCount() == sizeof(Light));
+ buffer.readByteArray(&fLight, sizeof(Light));
+ SkASSERT(fLight.fPad == 0); // for the font-cache lookup to be clean
+ fBlurSigma = buffer.readScalar();
+}
+#endif
+
SkFlattenable* SkEmbossMaskFilter::CreateProc(SkReadBuffer& buffer) {
Light light;
if (buffer.readByteArray(&light, sizeof(Light))) {
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index d3e112c..b331a03 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -148,13 +148,18 @@
return true;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLayerRasterizer::SkLayerRasterizer(SkReadBuffer& buffer)
+ : SkRasterizer(buffer), fLayers(ReadLayers(buffer)) {}
+#endif
+
SkFlattenable* SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) {
return SkNEW_ARGS(SkLayerRasterizer, (ReadLayers(buffer)));
}
SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) {
int count = buffer.readInt();
-
+
SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)));
for (int i = 0; i < count; i++) {
SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)layers->push_back();
diff --git a/src/effects/SkLerpXfermode.cpp b/src/effects/SkLerpXfermode.cpp
index 76c97ef..0376a57 100644
--- a/src/effects/SkLerpXfermode.cpp
+++ b/src/effects/SkLerpXfermode.cpp
@@ -23,6 +23,12 @@
SkLerpXfermode::SkLerpXfermode(unsigned scale256) : fScale256(scale256) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLerpXfermode::SkLerpXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fScale256 = buffer.readUInt();
+}
+#endif
+
void SkLerpXfermode::flatten(SkWriteBuffer& buffer) const {
buffer.writeUInt(fScale256);
}
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 740ad02..bf9877e 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -290,6 +290,9 @@
SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
SkScalar kd, SkImageFilter* input, const CropRect* cropRect,
uint32_t uniqueID);
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ explicit SkDiffuseLightingImageFilter(SkReadBuffer& buffer);
+#endif
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
@@ -319,6 +322,9 @@
SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks,
SkScalar shininess, SkImageFilter* input, const CropRect*,
uint32_t uniqueID);
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ explicit SkSpecularLightingImageFilter(SkReadBuffer& buffer);
+#endif
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
@@ -936,6 +942,15 @@
SkLightingImageFilter::~SkLightingImageFilter() {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLightingImageFilter::SkLightingImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ fLight.reset(SkLight::UnflattenLight(buffer));
+ fSurfaceScale = buffer.readScalar();
+ buffer.validate(SkScalarIsFinite(fSurfaceScale));
+}
+#endif
+
void SkLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
fLight->flattenLight(buffer);
@@ -966,6 +981,15 @@
{
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkReadBuffer& buffer)
+ : INHERITED(buffer)
+{
+ fKD = buffer.readScalar();
+ buffer.validate(SkScalarIsFinite(fKD) && (fKD >= 0));
+}
+#endif
+
SkFlattenable* SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer));
@@ -1072,6 +1096,17 @@
{
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkReadBuffer& buffer)
+ : INHERITED(buffer)
+{
+ fKS = buffer.readScalar();
+ fShininess = buffer.readScalar();
+ buffer.validate(SkScalarIsFinite(fKS) && (fKS >= 0) &&
+ SkScalarIsFinite(fShininess));
+}
+#endif
+
SkFlattenable* SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer));
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index 9ad5797..2b57cb1 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -44,6 +44,10 @@
SkLumaColorFilter::SkLumaColorFilter() : INHERITED() {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLumaColorFilter::SkLumaColorFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#endif
+
SkFlattenable* SkLumaColorFilter::CreateProc(SkReadBuffer&) {
return SkNEW(SkLumaColorFilter);
}
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 973ac66..e0826ef 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -235,7 +235,7 @@
SkImageFilter* SkMagnifierImageFilter::Create(const SkRect& srcRect, SkScalar inset,
SkImageFilter* input) {
-
+
if (!SkScalarIsFinite(inset) || !SkIsValidRect(srcRect)) {
return NULL;
}
@@ -247,6 +247,22 @@
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkMagnifierImageFilter::SkMagnifierImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ float x = buffer.readScalar();
+ float y = buffer.readScalar();
+ float width = buffer.readScalar();
+ float height = buffer.readScalar();
+ fSrcRect = SkRect::MakeXYWH(x, y, width, height);
+ fInset = buffer.readScalar();
+
+ buffer.validate(SkScalarIsFinite(fInset) && SkIsValidRect(fSrcRect) &&
+ // Negative numbers in src rect are not supported
+ (fSrcRect.fLeft >= 0) && (fSrcRect.fTop >= 0));
+}
+#endif
+
SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset,
SkImageFilter* input)
: INHERITED(1, &input), fSrcRect(srcRect), fInset(inset) {
diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp
index 045f6a9..cdcf66f 100644
--- a/src/effects/SkMatrixConvolutionImageFilter.cpp
+++ b/src/effects/SkMatrixConvolutionImageFilter.cpp
@@ -76,6 +76,50 @@
input, cropRect, uniqueID));
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+static bool tile_mode_is_valid(SkMatrixConvolutionImageFilter::TileMode tileMode) {
+ switch (tileMode) {
+ case SkMatrixConvolutionImageFilter::kClamp_TileMode:
+ case SkMatrixConvolutionImageFilter::kRepeat_TileMode:
+ case SkMatrixConvolutionImageFilter::kClampToBlack_TileMode:
+ return true;
+ default:
+ break;
+ }
+ return false;
+}
+
+SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ fKernelSize.fWidth = buffer.readInt();
+ fKernelSize.fHeight = buffer.readInt();
+ if ((fKernelSize.fWidth >= 1) && (fKernelSize.fHeight >= 1) &&
+ // Make sure size won't be larger than a signed int,
+ // which would still be extremely large for a kernel,
+ // but we don't impose a hard limit for kernel size
+ (gMaxKernelSize / fKernelSize.fWidth >= fKernelSize.fHeight)) {
+ size_t size = fKernelSize.fWidth * fKernelSize.fHeight;
+ fKernel = SkNEW_ARRAY(SkScalar, size);
+ SkDEBUGCODE(bool success =) buffer.readScalarArray(fKernel, size);
+ SkASSERT(success);
+ } else {
+ fKernel = 0;
+ }
+ fGain = buffer.readScalar();
+ fBias = buffer.readScalar();
+ fKernelOffset.fX = buffer.readInt();
+ fKernelOffset.fY = buffer.readInt();
+ fTileMode = (TileMode) buffer.readInt();
+ fConvolveAlpha = buffer.readBool();
+ buffer.validate((fKernel != 0) &&
+ SkScalarIsFinite(fGain) &&
+ SkScalarIsFinite(fBias) &&
+ tile_mode_is_valid(fTileMode) &&
+ (fKernelOffset.fX >= 0) && (fKernelOffset.fX < fKernelSize.fWidth) &&
+ (fKernelOffset.fY >= 0) && (fKernelOffset.fY < fKernelSize.fHeight));
+}
+#endif
+
SkFlattenable* SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkISize kernelSize;
diff --git a/src/effects/SkMatrixImageFilter.cpp b/src/effects/SkMatrixImageFilter.cpp
index 919dff3..8b07dd4 100644
--- a/src/effects/SkMatrixImageFilter.cpp
+++ b/src/effects/SkMatrixImageFilter.cpp
@@ -31,6 +31,14 @@
return SkNEW_ARGS(SkMatrixImageFilter, (transform, filterLevel, input, uniqueID));
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkMatrixImageFilter::SkMatrixImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ buffer.readMatrix(&fTransform);
+ fFilterLevel = static_cast<SkPaint::FilterLevel>(buffer.readInt());
+}
+#endif
+
SkFlattenable* SkMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkMatrix matrix;
diff --git a/src/effects/SkMergeImageFilter.cpp b/src/effects/SkMergeImageFilter.cpp
index d932d3c..9e7f4e5 100755
--- a/src/effects/SkMergeImageFilter.cpp
+++ b/src/effects/SkMergeImageFilter.cpp
@@ -140,3 +140,24 @@
buffer.writeByteArray(fModes, countInputs() * sizeof(fModes[0]));
}
}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkMergeImageFilter::SkMergeImageFilter(SkReadBuffer& buffer)
+ : INHERITED(-1, buffer) {
+ bool hasModes = buffer.readBool();
+ if (hasModes) {
+ this->initAllocModes();
+ int nbInputs = countInputs();
+ size_t size = nbInputs * sizeof(fModes[0]);
+ SkASSERT(buffer.getArrayCount() == size);
+ if (buffer.validate(buffer.getArrayCount() == size) &&
+ buffer.readByteArray(fModes, size)) {
+ for (int i = 0; i < nbInputs; ++i) {
+ buffer.validate(SkIsValidMode((SkXfermode::Mode)fModes[i]));
+ }
+ }
+ } else {
+ fModes = 0;
+ }
+}
+#endif
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 3d27d10..9c97c35 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -22,6 +22,16 @@
#include "effects/Gr1DKernelEffect.h"
#endif
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkMorphologyImageFilter::SkMorphologyImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ fRadius.fWidth = buffer.readInt();
+ fRadius.fHeight = buffer.readInt();
+ buffer.validate((fRadius.fWidth >= 0) &&
+ (fRadius.fHeight >= 0));
+}
+#endif
+
SkMorphologyImageFilter::SkMorphologyImageFilter(int radiusX,
int radiusY,
SkImageFilter* input,
diff --git a/src/effects/SkOffsetImageFilter.cpp b/src/effects/SkOffsetImageFilter.cpp
index b7ded08..90528c6 100644
--- a/src/effects/SkOffsetImageFilter.cpp
+++ b/src/effects/SkOffsetImageFilter.cpp
@@ -108,3 +108,12 @@
: INHERITED(1, &input, cropRect, uniqueID) {
fOffset.set(dx, dy);
}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkOffsetImageFilter::SkOffsetImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ buffer.readPoint(&fOffset);
+ buffer.validate(SkScalarIsFinite(fOffset.fX) &&
+ SkScalarIsFinite(fOffset.fY));
+}
+#endif
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index 8c608fa..0192589 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -51,6 +51,11 @@
return SkScalarMul(SkScalarSquare(t), SK_Scalar3 - 2 * t);
}
+bool perlin_noise_type_is_valid(SkPerlinNoiseShader::Type type) {
+ return (SkPerlinNoiseShader::kFractalNoise_Type == type) ||
+ (SkPerlinNoiseShader::kTurbulence_Type == type);
+}
+
} // end namespace
struct SkPerlinNoiseShader::StitchData {
@@ -283,6 +288,22 @@
SkASSERT(numOctaves >= 0 && numOctaves < 256);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fType = (SkPerlinNoiseShader::Type) buffer.readInt();
+ fBaseFrequencyX = buffer.readScalar();
+ fBaseFrequencyY = buffer.readScalar();
+ fNumOctaves = buffer.readInt();
+ fSeed = buffer.readScalar();
+ fStitchTiles = buffer.readBool();
+ fTileSize.fWidth = buffer.readInt();
+ fTileSize.fHeight = buffer.readInt();
+ buffer.validate(perlin_noise_type_is_valid(fType) &&
+ (fNumOctaves >= 0) && (fNumOctaves <= 255) &&
+ (fStitchTiles != fTileSize.isEmpty()));
+}
+#endif
+
SkPerlinNoiseShader::~SkPerlinNoiseShader() {
}
@@ -943,7 +964,7 @@
const SkMatrix* externalLocalMatrix,
GrColor* paintColor, GrFragmentProcessor** fp) const {
SkASSERT(context);
-
+
*paintColor = SkColor2GrColorJustAlpha(paint.getColor());
SkMatrix localMatrix = this->getLocalMatrix();
diff --git a/src/effects/SkPictureImageFilter.cpp b/src/effects/SkPictureImageFilter.cpp
index 5399ea7..da5597d 100644
--- a/src/effects/SkPictureImageFilter.cpp
+++ b/src/effects/SkPictureImageFilter.cpp
@@ -30,6 +30,21 @@
SkSafeUnref(fPicture);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPictureImageFilter::SkPictureImageFilter(SkReadBuffer& buffer)
+ : INHERITED(0, buffer),
+ fPicture(NULL) {
+ if (!buffer.isCrossProcess()) {
+ if (buffer.readBool()) {
+ fPicture = SkPicture::CreateFromBuffer(buffer);
+ }
+ } else {
+ buffer.validate(!buffer.readBool());
+ }
+ buffer.readRect(&fCropRect);
+}
+#endif
+
SkFlattenable* SkPictureImageFilter::CreateProc(SkReadBuffer& buffer) {
SkAutoTUnref<SkPicture> picture;
SkRect cropRect;
diff --git a/src/effects/SkPixelXorXfermode.cpp b/src/effects/SkPixelXorXfermode.cpp
index 2a6ac47..68b5306 100644
--- a/src/effects/SkPixelXorXfermode.cpp
+++ b/src/effects/SkPixelXorXfermode.cpp
@@ -25,6 +25,12 @@
wb.writeColor(fOpColor);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPixelXorXfermode::SkPixelXorXfermode(SkReadBuffer& rb) : INHERITED(rb) {
+ fOpColor = rb.readColor();
+}
+#endif
+
SkFlattenable* SkPixelXorXfermode::CreateProc(SkReadBuffer& buffer) {
return Create(buffer.readColor());
}
diff --git a/src/effects/SkRectShaderImageFilter.cpp b/src/effects/SkRectShaderImageFilter.cpp
index 91a127e..09417c8 100644
--- a/src/effects/SkRectShaderImageFilter.cpp
+++ b/src/effects/SkRectShaderImageFilter.cpp
@@ -34,6 +34,13 @@
, fShader(SkRef(s)) {
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkRectShaderImageFilter::SkRectShaderImageFilter(SkReadBuffer& buffer)
+ : INHERITED(0, buffer) {
+ fShader = buffer.readShader();
+}
+#endif
+
SkFlattenable* SkRectShaderImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 0);
SkAutoTUnref<SkShader> shader(buffer.readShader());
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 7cd628f..c3c2ba0 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -61,6 +61,9 @@
};
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkTable_ColorFilter(SkReadBuffer& buffer);
+#endif
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
@@ -224,6 +227,27 @@
return SkTableColorFilter::CreateARGB(a, r, g, b);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkTable_ColorFilter::SkTable_ColorFilter(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fBitmap = NULL;
+
+ uint8_t storage[5*256];
+
+ fFlags = buffer.readInt();
+
+ size_t size = buffer.getArrayCount();
+ SkASSERT(size <= sizeof(storage));
+ buffer.validate(size <= sizeof(storage));
+ buffer.readByteArray(storage, size);
+
+ SkDEBUGCODE(size_t raw = ) SkPackBits::Unpack8(storage, size, fStorage);
+
+ SkASSERT(raw <= sizeof(fStorage));
+ SkDEBUGCODE(size_t count = gCountNibBits[fFlags & 0xF]);
+ SkASSERT(raw == count * 256);
+}
+#endif
+
bool SkTable_ColorFilter::asComponentTable(SkBitmap* table) const {
if (table) {
if (NULL == fBitmap) {
@@ -288,7 +312,7 @@
GrTextureAccess fTextureAccess;
// currently not used in shader code, just to assist onComputeInvariantOutput().
- unsigned fFlags;
+ unsigned fFlags;
GrTextureStripAtlas* fAtlas;
int fRow;
@@ -334,7 +358,7 @@
rgbaYValues[3] = 0.125;
rgbaYValues[0] = 0.375;
rgbaYValues[1] = 0.625;
- rgbaYValues[2] = 0.875;
+ rgbaYValues[2] = 0.875;
}
pdm.set4fv(fRGBAYValuesUni, 1, rgbaYValues);
}
diff --git a/src/effects/SkTableMaskFilter.cpp b/src/effects/SkTableMaskFilter.cpp
index dc9b335..42b4ab6 100644
--- a/src/effects/SkTableMaskFilter.cpp
+++ b/src/effects/SkTableMaskFilter.cpp
@@ -82,6 +82,13 @@
return Create(table);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkTableMaskFilter::SkTableMaskFilter(SkReadBuffer& rb) : INHERITED(rb) {
+ SkASSERT(256 == rb.getArrayCount());
+ rb.readByteArray(fTable, 256);
+}
+#endif
+
///////////////////////////////////////////////////////////////////////////////
void SkTableMaskFilter::MakeGammaTable(uint8_t table[256], SkScalar gamma) {
diff --git a/src/effects/SkTestImageFilters.cpp b/src/effects/SkTestImageFilters.cpp
index be991f6..a414c92 100755
--- a/src/effects/SkTestImageFilters.cpp
+++ b/src/effects/SkTestImageFilters.cpp
@@ -80,3 +80,11 @@
this->INHERITED::flatten(buffer);
buffer.writeScalar(fScale);
}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkDownSampleImageFilter::SkDownSampleImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ fScale = buffer.readScalar();
+ buffer.validate(SkScalarIsFinite(fScale));
+}
+#endif
diff --git a/src/effects/SkTileImageFilter.cpp b/src/effects/SkTileImageFilter.cpp
index d640ac7..04c62d0 100644
--- a/src/effects/SkTileImageFilter.cpp
+++ b/src/effects/SkTileImageFilter.cpp
@@ -93,6 +93,15 @@
return true;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkTileImageFilter::SkTileImageFilter(SkReadBuffer& buffer)
+ : INHERITED(1, buffer) {
+ buffer.readRect(&fSrcRect);
+ buffer.readRect(&fDstRect);
+ buffer.validate(buffer.isValid() && SkIsValidRect(fSrcRect) && SkIsValidRect(fDstRect));
+}
+#endif
+
SkFlattenable* SkTileImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
SkRect src, dst;
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index 1618b64..379d6d8 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -32,6 +32,13 @@
SkSafeUnref(fMode);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkXfermodeImageFilter::SkXfermodeImageFilter(SkReadBuffer& buffer)
+ : INHERITED(2, buffer) {
+ fMode = buffer.readXfermode();
+}
+#endif
+
SkFlattenable* SkXfermodeImageFilter::CreateProc(SkReadBuffer& buffer) {
SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
SkAutoTUnref<SkXfermode> mode(buffer.readXfermode());
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index e70be04..d7b5144 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -199,6 +199,56 @@
this->initCommon();
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+static SkShader::TileMode unpack_mode(uint32_t packed) {
+ return (SkShader::TileMode)(packed & 0xF);
+}
+
+static uint32_t unpack_flags(uint32_t packed) {
+ return packed >> 4;
+}
+
+SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buffer) {
+ 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();
+}
+#endif
+
SkGradientShaderBase::~SkGradientShaderBase() {
if (fOrigColors != fStorage) {
sk_free(fOrigColors);
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 1faca5e..3ab7219 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -60,6 +60,14 @@
pts_to_unit_matrix(pts, &fPtsToUnit);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLinearGradient::SkLinearGradient(SkReadBuffer& buffer)
+ : INHERITED(buffer)
+ , fStart(buffer.readPoint())
+ , fEnd(buffer.readPoint()) {
+}
+#endif
+
SkFlattenable* SkLinearGradient::CreateProc(SkReadBuffer& buffer) {
DescriptorScope desc;
if (!desc.unflatten(buffer)) {
@@ -560,7 +568,7 @@
const SkMatrix* localMatrix, GrColor* paintColor,
GrFragmentProcessor** fp) const {
SkASSERT(context);
-
+
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
return false;
@@ -573,10 +581,10 @@
matrix.postConcat(inv);
}
matrix.postConcat(fPtsToUnit);
-
+
*paintColor = SkColor2GrColorJustAlpha(paint.getColor());
*fp = GrLinearGradient::Create(context, *this, matrix, fTileMode);
-
+
return true;
}
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index 7c0e8f6..99531d9 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -252,6 +252,14 @@
return kRadial_GradientType;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkRadialGradient::SkRadialGradient(SkReadBuffer& buffer)
+ : INHERITED(buffer),
+ fCenter(buffer.readPoint()),
+ fRadius(buffer.readScalar()) {
+}
+#endif
+
SkFlattenable* SkRadialGradient::CreateProc(SkReadBuffer& buffer) {
DescriptorScope desc;
if (!desc.unflatten(buffer)) {
@@ -570,7 +578,7 @@
const SkMatrix* localMatrix, GrColor* paintColor,
GrFragmentProcessor** fp) const {
SkASSERT(context);
-
+
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
return false;
@@ -583,10 +591,10 @@
matrix.postConcat(inv);
}
matrix.postConcat(fPtsToUnit);
-
+
*paintColor = SkColor2GrColorJustAlpha(paint.getColor());
*fp = GrRadialGradient::Create(context, *this, matrix, fTileMode);
-
+
return true;
}
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index 1637006..d080ec5 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -41,6 +41,13 @@
return kSweep_GradientType;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkSweepGradient::SkSweepGradient(SkReadBuffer& buffer)
+ : INHERITED(buffer),
+ fCenter(buffer.readPoint()) {
+}
+#endif
+
SkFlattenable* SkSweepGradient::CreateProc(SkReadBuffer& buffer) {
DescriptorScope desc;
if (!desc.unflatten(buffer)) {
@@ -287,7 +294,7 @@
bool SkSweepGradient::asFragmentProcessor(GrContext* context, const SkPaint& paint,
const SkMatrix* localMatrix, GrColor* paintColor,
GrFragmentProcessor** effect) const {
-
+
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
return false;
@@ -300,10 +307,10 @@
matrix.postConcat(inv);
}
matrix.postConcat(fPtsToUnit);
-
+
*effect = GrSweepGradient::Create(context, *this, matrix);
*paintColor = SkColor2GrColorJustAlpha(paint.getColor());
-
+
return true;
}
diff --git a/src/effects/gradients/SkSweepGradient.h b/src/effects/gradients/SkSweepGradient.h
index 2ca4a62..d816295 100644
--- a/src/effects/gradients/SkSweepGradient.h
+++ b/src/effects/gradients/SkSweepGradient.h
@@ -41,6 +41,9 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSweepGradient)
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkSweepGradient(SkReadBuffer& buffer);
+#endif
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
virtual Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index 2fc848e..5410f6a 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -343,6 +343,19 @@
return kConical_GradientType;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkTwoPointConicalGradient::SkTwoPointConicalGradient(
+ SkReadBuffer& buffer)
+ : INHERITED(buffer)
+ , fCenter1(buffer.readPoint())
+ , fCenter2(buffer.readPoint())
+ , fRadius1(buffer.readScalar())
+ , fRadius2(buffer.readScalar())
+ , fFlippedGrad(buffer.readBool()) {
+ this->init();
+}
+#endif
+
SkFlattenable* SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) {
DescriptorScope desc;
if (!desc.unflatten(buffer)) {
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp
index 8ce3f43..3e40044 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.cpp
+++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp
@@ -343,6 +343,17 @@
}
#endif
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkTwoPointRadialGradient::SkTwoPointRadialGradient(SkReadBuffer& buffer)
+ : INHERITED(buffer),
+ fCenter1(buffer.readPoint()),
+ fCenter2(buffer.readPoint()),
+ fRadius1(buffer.readScalar()),
+ fRadius2(buffer.readScalar()) {
+ init();
+};
+#endif
+
SkFlattenable* SkTwoPointRadialGradient::CreateProc(SkReadBuffer& buffer) {
DescriptorScope desc;
if (!desc.unflatten(buffer)) {
@@ -675,7 +686,7 @@
const SkMatrix* localMatrix, GrColor* paintColor,
GrFragmentProcessor** fp) const {
SkASSERT(context);
-
+
// invert the localM, translate to center1 (fPtsToUni), rotate so center2 is on x axis.
SkMatrix matrix;
if (!this->getLocalMatrix().invert(&matrix)) {
@@ -701,7 +712,7 @@
*paintColor = SkColor2GrColorJustAlpha(paint.getColor());
*fp = GrRadial2Gradient::Create(context, *this, matrix, fTileMode);
-
+
return true;
}
diff --git a/src/opts/SkXfermode_opts_SSE2.cpp b/src/opts/SkXfermode_opts_SSE2.cpp
index fccf665..02ca038 100644
--- a/src/opts/SkXfermode_opts_SSE2.cpp
+++ b/src/opts/SkXfermode_opts_SSE2.cpp
@@ -641,6 +641,13 @@
extern SkXfermodeProcSIMD gSSE2XfermodeProcs[];
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkSSE2ProcCoeffXfermode::SkSSE2ProcCoeffXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fProcSIMD = reinterpret_cast<void*>(gSSE2XfermodeProcs[this->getMode()]);
+ buffer.validate(fProcSIMD != NULL);
+}
+#endif
+
void SkSSE2ProcCoeffXfermode::xfer32(SkPMColor dst[], const SkPMColor src[],
int count, const SkAlpha aa[]) const {
SkASSERT(dst && src && count >= 0);
diff --git a/src/opts/SkXfermode_opts_SSE2.h b/src/opts/SkXfermode_opts_SSE2.h
index 7ccce48..8512aee 100644
--- a/src/opts/SkXfermode_opts_SSE2.h
+++ b/src/opts/SkXfermode_opts_SSE2.h
@@ -25,6 +25,10 @@
SK_TO_STRING_OVERRIDE()
private:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkSSE2ProcCoeffXfermode(SkReadBuffer& buffer);
+#endif
+
void* fProcSIMD;
typedef SkProcCoeffXfermode INHERITED;
};
diff --git a/src/opts/SkXfermode_opts_arm_neon.cpp b/src/opts/SkXfermode_opts_arm_neon.cpp
index 7534c98..dca58eb 100644
--- a/src/opts/SkXfermode_opts_arm_neon.cpp
+++ b/src/opts/SkXfermode_opts_arm_neon.cpp
@@ -743,6 +743,12 @@
extern SkXfermodeProcSIMD gNEONXfermodeProcs[];
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkNEONProcCoeffXfermode::SkNEONProcCoeffXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
+ fProcSIMD = reinterpret_cast<void*>(gNEONXfermodeProcs[this->getMode()]);
+}
+#endif
+
void SkNEONProcCoeffXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
const SkPMColor* SK_RESTRICT src, int count,
const SkAlpha* SK_RESTRICT aa) const {
diff --git a/src/opts/SkXfermode_opts_arm_neon.h b/src/opts/SkXfermode_opts_arm_neon.h
index f091432..745bfe2 100644
--- a/src/opts/SkXfermode_opts_arm_neon.h
+++ b/src/opts/SkXfermode_opts_arm_neon.h
@@ -17,6 +17,10 @@
SK_TO_STRING_OVERRIDE()
private:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+ SkNEONProcCoeffXfermode(SkReadBuffer& buffer);
+#endif
+
// void* is used to avoid pulling arm_neon.h in the core and having to build
// it with -mfpu=neon.
void* fProcSIMD;