Simplify flattening to just write enough to call the factory/public-constructor for the class. We want to *not* rely on private constructors, and not rely on calling through the inheritance hierarchy for either flattening or unflattening(CreateProc).
Refactoring pattern:
1. guard the existing constructor(readbuffer) with the legacy build-flag
2. If you are a instancable subclass, implement CreateProc(readbuffer) to create a new instances from the buffer params (or return NULL).
If you're a shader subclass
1. You must read/write the local matrix if your class accepts that in its factory/constructor, else ignore it.
R=robertphillips@google.com, mtklein@google.com, senorblanco@google.com, senorblanco@chromium.org, sugoi@chromium.org
Author: reed@google.com
Review URL: https://codereview.chromium.org/395603002
diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp
index 7354cda..47824fd 100644
--- a/src/effects/Sk1DPathEffect.cpp
+++ b/src/effects/Sk1DPathEffect.cpp
@@ -147,6 +147,7 @@
}
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkPath1DPathEffect::SkPath1DPathEffect(SkReadBuffer& buffer) {
fAdvance = buffer.readScalar();
if (fAdvance > 0) {
@@ -160,13 +161,25 @@
fStyle = kStyleCount;
}
}
+#endif
SkScalar SkPath1DPathEffect::begin(SkScalar contourLength) const {
return fInitialOffset;
}
+SkFlattenable* SkPath1DPathEffect::CreateProc(SkReadBuffer& buffer) {
+ SkScalar advance = buffer.readScalar();
+ if (advance > 0) {
+ SkPath path;
+ buffer.readPath(&path);
+ SkScalar phase = buffer.readScalar();
+ Style style = (Style)buffer.readUInt();
+ return SkPath1DPathEffect::Create(path, advance, phase, style);
+ }
+ return NULL;
+}
+
void SkPath1DPathEffect::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
buffer.writeScalar(fAdvance);
if (fAdvance > 0) {
buffer.writePath(fPath);
diff --git a/src/effects/Sk2DPathEffect.cpp b/src/effects/Sk2DPathEffect.cpp
index 252866c..cef2266 100644
--- a/src/effects/Sk2DPathEffect.cpp
+++ b/src/effects/Sk2DPathEffect.cpp
@@ -73,10 +73,12 @@
buffer.writeMatrix(fMatrix);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
Sk2DPathEffect::Sk2DPathEffect(SkReadBuffer& buffer) {
buffer.readMatrix(&fMatrix);
fMatrixIsInvertible = fMatrix.invert(&fInverse);
}
+#endif
///////////////////////////////////////////////////////////////////////////////
@@ -102,12 +104,21 @@
}
}
+#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);
+ SkScalar width = buffer.readScalar();
+ return SkLine2DPathEffect::Create(width, matrix);
+}
void SkLine2DPathEffect::flatten(SkWriteBuffer &buffer) const {
- this->INHERITED::flatten(buffer);
+ buffer.writeMatrix(this->getMatrix());
buffer.writeScalar(fWidth);
}
@@ -117,13 +128,22 @@
: INHERITED(m), fPath(p) {
}
-SkPath2DPathEffect::SkPath2DPathEffect(SkReadBuffer& buffer)
- : INHERITED(buffer) {
+#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);
+ SkPath path;
+ buffer.readPath(&path);
+ return SkPath2DPathEffect::Create(matrix, path);
+}
void SkPath2DPathEffect::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
+ buffer.writeMatrix(this->getMatrix());
buffer.writePath(fPath);
}
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 39a319b..9c59347 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -19,7 +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&,
@@ -233,12 +235,23 @@
#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();
+ SkScalar outer = buffer.readScalar();
+ SkRegion rgn;
+ buffer.readRegion(&rgn);
+ return SkAlphaThresholdFilter::Create(rgn, inner, outer, common.getInput(0));
+}
SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(const SkRegion& region,
SkScalar innerThreshold,
diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp
index 7d9997a..d3be826 100644
--- a/src/effects/SkArithmeticMode.cpp
+++ b/src/effects/SkArithmeticMode.cpp
@@ -47,6 +47,7 @@
fEnforcePMColor = enforcePMColor;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkArithmeticMode_scalar(SkReadBuffer& buffer) : INHERITED(buffer) {
fK[0] = buffer.readScalar();
fK[1] = buffer.readScalar();
@@ -54,9 +55,9 @@
fK[3] = buffer.readScalar();
fEnforcePMColor = buffer.readBool();
}
+#endif
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
- INHERITED::flatten(buffer);
buffer.writeScalar(fK[0]);
buffer.writeScalar(fK[1]);
buffer.writeScalar(fK[2]);
@@ -66,9 +67,20 @@
SkScalar fK[4];
bool fEnforcePMColor;
+ friend class SkArithmeticMode;
+
typedef SkXfermode INHERITED;
};
+SkFlattenable* SkArithmeticMode_scalar::CreateProc(SkReadBuffer& buffer) {
+ const SkScalar k1 = buffer.readScalar();
+ const SkScalar k2 = buffer.readScalar();
+ const SkScalar k3 = buffer.readScalar();
+ const SkScalar k4 = buffer.readScalar();
+ const bool enforcePMColor = buffer.readBool();
+ return Create(k1, k2, k3, k4, enforcePMColor);
+}
+
static int pinToByte(int value) {
if (value < 0) {
value = 0;
diff --git a/src/effects/SkAvoidXfermode.cpp b/src/effects/SkAvoidXfermode.cpp
index ffe6a21..aae6ba5 100644
--- a/src/effects/SkAvoidXfermode.cpp
+++ b/src/effects/SkAvoidXfermode.cpp
@@ -15,24 +15,30 @@
if (tolerance > 255) {
tolerance = 255;
}
-
+ fTolerance = SkToU8(tolerance);
fOpColor = opColor;
fDistMul = (256 << 14) / (tolerance + 1);
fMode = mode;
}
-SkAvoidXfermode::SkAvoidXfermode(SkReadBuffer& buffer)
- : INHERITED(buffer) {
+#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();
+ const unsigned mode = buffer.readUInt();
+ return Create(color, tolerance, (Mode)mode);
+}
void SkAvoidXfermode::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
-
buffer.writeColor(fOpColor);
- buffer.writeUInt(fDistMul);
+ buffer.writeUInt(fTolerance);
buffer.writeUInt(fMode);
}
diff --git a/src/effects/SkBitmapSource.cpp b/src/effects/SkBitmapSource.cpp
index d8d4329..aee4a36 100644
--- a/src/effects/SkBitmapSource.cpp
+++ b/src/effects/SkBitmapSource.cpp
@@ -13,12 +13,12 @@
#include "SkValidationUtils.h"
SkBitmapSource::SkBitmapSource(const SkBitmap& bitmap)
- : INHERITED(0, 0),
- fBitmap(bitmap),
- fSrcRect(SkRect::MakeWH(SkIntToScalar(bitmap.width()),
- SkIntToScalar(bitmap.height()))),
- fDstRect(fSrcRect) {
-}
+ : INHERITED(0, 0)
+ , fBitmap(bitmap)
+ , fSrcRect(SkRect::MakeWH(SkIntToScalar(bitmap.width()),
+ SkIntToScalar(bitmap.height())))
+ , fDstRect(fSrcRect)
+{}
SkBitmapSource::SkBitmapSource(const SkBitmap& bitmap, const SkRect& srcRect, const SkRect& dstRect)
: INHERITED(0, 0)
@@ -26,6 +26,7 @@
, fSrcRect(srcRect)
, fDstRect(dstRect) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkBitmapSource::SkBitmapSource(SkReadBuffer& buffer) : INHERITED(0, buffer) {
if (buffer.isVersionLT(SkReadBuffer::kNoMoreBitmapFlatten_Version)) {
fBitmap.legacyUnflatten(buffer);
@@ -36,12 +37,23 @@
buffer.readRect(&fDstRect);
buffer.validate(buffer.isValid() && SkIsValidRect(fSrcRect) && SkIsValidRect(fDstRect));
}
+#endif
+
+SkFlattenable* SkBitmapSource::CreateProc(SkReadBuffer& buffer) {
+ SkRect src, dst;
+ buffer.readRect(&src);
+ buffer.readRect(&dst);
+ SkBitmap bitmap;
+ if (!buffer.readBitmap(&bitmap)) {
+ return NULL;
+ }
+ return SkBitmapSource::Create(bitmap, src, dst);
+}
void SkBitmapSource::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
- buffer.writeBitmap(fBitmap);
buffer.writeRect(fSrcRect);
buffer.writeRect(fDstRect);
+ buffer.writeBitmap(fBitmap);
}
bool SkBitmapSource::onFilterImage(Proxy* proxy, const SkBitmap&, const Context& ctx,
diff --git a/src/effects/SkBlurDrawLooper.cpp b/src/effects/SkBlurDrawLooper.cpp
index c3b843f..fc9e47b 100644
--- a/src/effects/SkBlurDrawLooper.cpp
+++ b/src/effects/SkBlurDrawLooper.cpp
@@ -62,6 +62,7 @@
this->initEffects();
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkBlurDrawLooper::SkBlurDrawLooper(SkReadBuffer& buffer) : INHERITED(buffer) {
fSigma = buffer.readScalar();
@@ -72,13 +73,22 @@
this->initEffects();
}
+#endif
+
+SkFlattenable* SkBlurDrawLooper::CreateProc(SkReadBuffer& buffer) {
+ const SkColor color = buffer.readColor();
+ const SkScalar sigma = buffer.readScalar();
+ const SkScalar dx = buffer.readScalar();
+ const SkScalar dy = buffer.readScalar();
+ const uint32_t flags = buffer.read32();
+ return Create(color, sigma, dx, dy, flags);
+}
void SkBlurDrawLooper::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
+ buffer.writeColor(fBlurColor);
buffer.writeScalar(fSigma);
buffer.writeScalar(fDx);
buffer.writeScalar(fDy);
- buffer.writeColor(fBlurColor);
buffer.write32(fBlurFlags);
}
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index 5c3ff49..71bc811 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -23,6 +23,7 @@
// raster paths.
#define MAX_SIGMA SkIntToScalar(532)
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkBlurImageFilter::SkBlurImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fSigma.fWidth = buffer.readScalar();
@@ -32,6 +33,7 @@
(fSigma.fWidth >= 0) &&
(fSigma.fHeight >= 0));
}
+#endif
SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX,
SkScalar sigmaY,
@@ -41,6 +43,13 @@
SkASSERT(sigmaX >= 0 && sigmaY >= 0);
}
+SkFlattenable* SkBlurImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
+ SkScalar sigmaX = buffer.readScalar();
+ SkScalar sigmaY = buffer.readScalar();
+ return Create(sigmaX, sigmaY, common.getInput(0), &common.cropRect());
+}
+
void SkBlurImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fSigma.fWidth);
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 9330c59..4e469bc 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -108,6 +108,8 @@
return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
}
+ friend class SkBlurMaskFilter;
+
typedef SkMaskFilter INHERITED;
};
@@ -522,19 +524,29 @@
src.fRight + pad, src.fBottom + pad);
}
-SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkReadBuffer& buffer)
- : SkMaskFilter(buffer) {
+#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();
+ const unsigned flags = buffer.readUInt();
+ if (style <= kLastEnum_SkBlurStyle) {
+ return SkBlurMaskFilter::Create((SkBlurStyle)style, sigma, flags);
+ }
+ return NULL;
+}
void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
buffer.writeScalar(fSigma);
- buffer.writeInt(fBlurStyle);
+ buffer.writeUInt(fBlurStyle);
buffer.writeUInt(fBlurFlags);
}
diff --git a/src/effects/SkColorFilterImageFilter.cpp b/src/effects/SkColorFilterImageFilter.cpp
index 2c37067..2a7cc31 100755
--- a/src/effects/SkColorFilterImageFilter.cpp
+++ b/src/effects/SkColorFilterImageFilter.cpp
@@ -83,14 +83,20 @@
SkSafeRef(cf);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkColorFilterImageFilter::SkColorFilterImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fColorFilter = buffer.readColorFilter();
}
+#endif
+
+SkFlattenable* SkColorFilterImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
+ return Create(buffer.readColorFilter(), common.getInput(0), &common.cropRect());
+}
void SkColorFilterImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
-
buffer.writeFlattenable(fColorFilter);
}
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index 43df5e9..bcaabf6 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -15,17 +15,9 @@
#include "SkValidationUtils.h"
#include "SkColorMatrixFilter.h"
-#define ILLEGAL_XFERMODE_MODE ((SkXfermode::Mode)-1)
-
// baseclass for filters that store a color and mode
class SkModeColorFilter : public SkColorFilter {
public:
- SkModeColorFilter(SkColor color) {
- fColor = color;
- fMode = ILLEGAL_XFERMODE_MODE;
- this->updateCache();
- }
-
SkModeColorFilter(SkColor color, SkXfermode::Mode mode) {
fColor = color;
fMode = mode;
@@ -34,14 +26,9 @@
SkColor getColor() const { return fColor; }
SkXfermode::Mode getMode() const { return fMode; }
- bool isModeValid() const { return ILLEGAL_XFERMODE_MODE != fMode; }
SkPMColor getPMColor() const { return fPMColor; }
virtual bool asColorMode(SkColor* color, SkXfermode::Mode* mode) const SK_OVERRIDE {
- if (ILLEGAL_XFERMODE_MODE == fMode) {
- return false;
- }
-
if (color) {
*color = fColor;
}
@@ -93,11 +80,11 @@
protected:
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
- this->INHERITED::flatten(buffer);
buffer.writeColor(fColor);
buffer.writeUInt(fMode);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkModeColorFilter(SkReadBuffer& buffer) {
fColor = buffer.readColor();
fMode = (SkXfermode::Mode)buffer.readUInt();
@@ -106,6 +93,7 @@
buffer.validate(SkIsValidMode(fMode));
}
}
+#endif
private:
SkColor fColor;
@@ -121,9 +109,17 @@
fProc16 = SkXfermode::GetProc16(fMode, fColor);
}
+ friend class SkColorFilter;
+
typedef SkColorFilter INHERITED;
};
+SkFlattenable* SkModeColorFilter::CreateProc(SkReadBuffer& buffer) {
+ SkColor color = buffer.readColor();
+ SkXfermode::Mode mode = (SkXfermode::Mode)buffer.readUInt();
+ return SkColorFilter::CreateModeFilter(color, mode);
+}
+
///////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU
#include "GrBlend.h"
@@ -443,12 +439,6 @@
sk_memset16(result, SkPixel32ToPixel16(this->getPMColor()), count);
}
- SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Src_SkModeColorFilter)
-
-protected:
- Src_SkModeColorFilter(SkReadBuffer& buffer)
- : INHERITED(buffer) {}
-
private:
typedef SkModeColorFilter INHERITED;
};
@@ -479,14 +469,6 @@
sk_memset16(result, SkPixel32ToPixel16(this->getPMColor()), count);
}
- SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SrcOver_SkModeColorFilter)
-
-protected:
- SrcOver_SkModeColorFilter(SkReadBuffer& buffer)
- : INHERITED(buffer) {
- fColor32Proc = SkBlitRow::ColorProcFactory();
- }
-
private:
SkBlitRow::ColorProc fColor32Proc;
@@ -496,8 +478,11 @@
///////////////////////////////////////////////////////////////////////////////
-SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color,
- SkXfermode::Mode mode) {
+SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color, SkXfermode::Mode mode) {
+ if (!SkIsValidMode(mode)) {
+ return NULL;
+ }
+
unsigned alpha = SkColorGetA(color);
// first collaps some modes if possible
@@ -562,6 +547,4 @@
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkColorFilter)
SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkModeColorFilter)
- SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(Src_SkModeColorFilter)
- SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SrcOver_SkModeColorFilter)
SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index d76502e..f62e0f1 100644
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -303,18 +303,26 @@
///////////////////////////////////////////////////////////////////////////////
void SkColorMatrixFilter::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
SkASSERT(sizeof(fMatrix.fMat)/sizeof(SkScalar) == 20);
buffer.writeScalarArray(fMatrix.fMat, 20);
}
-SkColorMatrixFilter::SkColorMatrixFilter(SkReadBuffer& buffer)
- : INHERITED(buffer) {
+#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)) {
+ return Create(matrix);
+ }
+ return NULL;
+}
bool SkColorMatrixFilter::asColorMatrix(SkScalar matrix[20]) const {
if (matrix) {
diff --git a/src/effects/SkComposeImageFilter.cpp b/src/effects/SkComposeImageFilter.cpp
index 645d633..c055674 100644
--- a/src/effects/SkComposeImageFilter.cpp
+++ b/src/effects/SkComposeImageFilter.cpp
@@ -21,14 +21,6 @@
SkImageFilter* outer = getInput(0);
SkImageFilter* inner = getInput(1);
- if (!outer && !inner) {
- return false;
- }
-
- if (!outer || !inner) {
- return (outer ? outer : inner)->filterImage(proxy, src, ctx, result, offset);
- }
-
SkBitmap tmp;
return inner->filterImage(proxy, src, ctx, &tmp, offset) &&
outer->filterImage(proxy, tmp, ctx, result, offset);
@@ -40,19 +32,17 @@
SkImageFilter* outer = getInput(0);
SkImageFilter* inner = getInput(1);
- if (!outer && !inner) {
- return false;
- }
-
- if (!outer || !inner) {
- return (outer ? outer : inner)->filterBounds(src, ctm, dst);
- }
-
SkIRect tmp;
- return inner->filterBounds(src, ctm, &tmp) &&
- outer->filterBounds(tmp, ctm, dst);
+ return inner->filterBounds(src, ctm, &tmp) && outer->filterBounds(tmp, ctm, dst);
}
+SkFlattenable* SkComposeImageFilter::CreateProc(SkReadBuffer& buffer) {
+ 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 5b61e06..0655882 100644
--- a/src/effects/SkCornerPathEffect.cpp
+++ b/src/effects/SkCornerPathEffect.cpp
@@ -128,11 +128,16 @@
return true;
}
+SkFlattenable* SkCornerPathEffect::CreateProc(SkReadBuffer& buffer) {
+ return SkCornerPathEffect::Create(buffer.readScalar());
+}
+
void SkCornerPathEffect::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
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 d91e7be..66462af 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -238,20 +238,22 @@
return kDash_DashType;
}
-SkFlattenable::Factory SkDashPathEffect::getFactory() const {
- return CreateProc;
-}
-
void SkDashPathEffect::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
buffer.writeScalar(fPhase);
buffer.writeScalarArray(fIntervals, fCount);
}
SkFlattenable* SkDashPathEffect::CreateProc(SkReadBuffer& buffer) {
- return SkNEW_ARGS(SkDashPathEffect, (buffer));
+ const SkScalar phase = buffer.readScalar();
+ uint32_t count = buffer.getArrayCount();
+ SkAutoSTArray<32, SkScalar> intervals(count);
+ if (buffer.readScalarArray(intervals.get(), count)) {
+ return Create(intervals.get(), SkToInt(count), phase);
+ }
+ return NULL;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer)
: INHERITED(buffer)
, fPhase(0)
@@ -292,3 +294,5 @@
&fInitialDashLength, &fInitialDashIndex, &fIntervalLength);
}
}
+#endif
+
diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp
index f6f9112..e8cc6a2 100644
--- a/src/effects/SkDiscretePathEffect.cpp
+++ b/src/effects/SkDiscretePathEffect.cpp
@@ -75,15 +75,24 @@
return true;
}
+SkFlattenable* SkDiscretePathEffect::CreateProc(SkReadBuffer& buffer) {
+ SkScalar segLength = buffer.readScalar();
+ SkScalar perterb = buffer.readScalar();
+ uint32_t seed = buffer.readUInt();
+ return Create(segLength, perterb, seed);
+}
+
void SkDiscretePathEffect::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
buffer.writeScalar(fSegLength);
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 bae7ac0..27fc0d3 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -159,6 +159,22 @@
///////////////////////////////////////////////////////////////////////////////
+SkDisplacementMapEffect* SkDisplacementMapEffect::Create(ChannelSelectorType xChannelSelector,
+ ChannelSelectorType yChannelSelector,
+ SkScalar scale,
+ SkImageFilter* displacement,
+ SkImageFilter* color,
+ const CropRect* cropRect) {
+ if (!channel_selector_type_is_valid(xChannelSelector) ||
+ !channel_selector_type_is_valid(yChannelSelector)) {
+ return NULL;
+ }
+
+ SkImageFilter* inputs[2] = { displacement, color };
+ return SkNEW_ARGS(SkDisplacementMapEffect, (xChannelSelector, yChannelSelector, scale,
+ inputs, cropRect));
+}
+
SkDisplacementMapEffect::SkDisplacementMapEffect(ChannelSelectorType xChannelSelector,
ChannelSelectorType yChannelSelector,
SkScalar scale,
@@ -174,6 +190,7 @@
SkDisplacementMapEffect::~SkDisplacementMapEffect() {
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkDisplacementMapEffect::SkDisplacementMapEffect(SkReadBuffer& buffer)
: INHERITED(2, buffer)
{
@@ -184,6 +201,15 @@
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();
+ ChannelSelectorType ysel = (ChannelSelectorType)buffer.readInt();
+ SkScalar scale = buffer.readScalar();
+ return Create(xsel, ysel, scale, common.getInput(0), common.getInput(1), &common.cropRect());
+}
void SkDisplacementMapEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index 1d22bbd..f1ebae8 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -27,6 +27,7 @@
{
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkDropShadowImageFilter::SkDropShadowImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fDx = buffer.readScalar();
@@ -39,9 +40,19 @@
SkScalarIsFinite(fSigmaX) &&
SkScalarIsFinite(fSigmaY));
}
+#endif
-void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const
-{
+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();
+ return Create(dx, dy, sigmaX, sigmaY, color, common.getInput(0), &common.cropRect());
+}
+
+void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fDx);
buffer.writeScalar(fDy);
diff --git a/src/effects/SkEmbossMaskFilter.cpp b/src/effects/SkEmbossMaskFilter.cpp
index cdd55fc..4841b92 100644
--- a/src/effects/SkEmbossMaskFilter.cpp
+++ b/src/effects/SkEmbossMaskFilter.cpp
@@ -124,17 +124,26 @@
return true;
}
-SkEmbossMaskFilter::SkEmbossMaskFilter(SkReadBuffer& buffer)
- : SkMaskFilter(buffer) {
+#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))) {
+ light.fPad = 0; // for the font-cache lookup to be clean
+ const SkScalar sigma = buffer.readScalar();
+ return Create(sigma, light);
+ }
+ return NULL;
+}
void SkEmbossMaskFilter::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
-
Light tmpLight = fLight;
tmpLight.fPad = 0; // for the font-cache lookup to be clean
buffer.writeByteArray(&tmpLight, sizeof(tmpLight));
diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp
index aed2c9b..19525ec 100644
--- a/src/effects/SkLayerDrawLooper.cpp
+++ b/src/effects/SkLayerDrawLooper.cpp
@@ -200,20 +200,6 @@
///////////////////////////////////////////////////////////////////////////////
void SkLayerDrawLooper::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
-
-#ifdef SK_DEBUG
- {
- Rec* rec = fRecs;
- int count = 0;
- while (rec) {
- rec = rec->fNext;
- count += 1;
- }
- SkASSERT(count == fCount);
- }
-#endif
-
buffer.writeInt(fCount);
Rec* rec = fRecs;
@@ -245,22 +231,7 @@
info.fPostTranslate = buffer.readBool();
buffer.readPaint(builder.addLayerOnTop(info));
}
- SkLayerDrawLooper* looper = builder.detachLooper();
- SkASSERT(count == looper->fCount);
-
-#ifdef SK_DEBUG
- {
- Rec* rec = looper->fRecs;
- int n = 0;
- while (rec) {
- rec = rec->fNext;
- n += 1;
- }
- SkASSERT(count == n);
- }
-#endif
-
- return looper;
+ return builder.detachLooper();
}
#ifndef SK_IGNORE_TO_STRING
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index 9b7bdca..b331a03 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -148,12 +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 c8389fe..0376a57 100644
--- a/src/effects/SkLerpXfermode.cpp
+++ b/src/effects/SkLerpXfermode.cpp
@@ -23,16 +23,20 @@
SkLerpXfermode::SkLerpXfermode(unsigned scale256) : fScale256(scale256) {}
-SkLerpXfermode::SkLerpXfermode(SkReadBuffer& buffer)
- : INHERITED(buffer) {
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLerpXfermode::SkLerpXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
fScale256 = buffer.readUInt();
}
+#endif
void SkLerpXfermode::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
buffer.writeUInt(fScale256);
}
+SkFlattenable* SkLerpXfermode::CreateProc(SkReadBuffer& buffer) {
+ return SkNEW_ARGS(SkLerpXfermode, (buffer.readUInt()));
+}
+
void SkLerpXfermode::xfer32(SkPMColor dst[], const SkPMColor src[], int count,
const SkAlpha aa[]) const {
const int scale = fScale256;
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index ebb9390..d93f4cc 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -264,13 +264,18 @@
class SkDiffuseLightingImageFilter : public SkLightingImageFilter {
public:
- SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
- SkScalar kd, SkImageFilter* input, const CropRect* cropRect);
+ static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter*,
+ const CropRect*);
+
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
SkScalar kd() const { return fKD; }
protected:
+ SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
+ SkScalar kd, SkImageFilter* input, const CropRect* cropRect);
+#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;
@@ -280,20 +285,27 @@
#endif
private:
+ friend class SkLightingImageFilter;
typedef SkLightingImageFilter INHERITED;
SkScalar fKD;
};
class SkSpecularLightingImageFilter : public SkLightingImageFilter {
public:
- SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect);
+ static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale,
+ SkScalar ks, SkScalar shininess, SkImageFilter*, const CropRect*);
+
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
SkScalar ks() const { return fKS; }
SkScalar shininess() const { return fShininess; }
protected:
+ SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks,
+ SkScalar shininess, SkImageFilter* input, const CropRect*);
+#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;
@@ -303,9 +315,10 @@
#endif
private:
- typedef SkLightingImageFilter INHERITED;
SkScalar fKS;
SkScalar fShininess;
+ friend class SkLightingImageFilter;
+ typedef SkLightingImageFilter INHERITED;
};
#if SK_SUPPORT_GPU
@@ -832,101 +845,139 @@
SkLightingImageFilter::SkLightingImageFilter(SkLight* light, SkScalar surfaceScale,
SkImageFilter* input, const CropRect* cropRect)
- : INHERITED(1, &input, cropRect),
- fLight(light),
- fSurfaceScale(SkScalarDiv(surfaceScale, SkIntToScalar(255)))
-{
- SkASSERT(fLight);
- // our caller knows that we take ownership of the light, so we don't
- // need to call ref() here.
+ : INHERITED(1, &input, cropRect)
+ , fLight(SkRef(light))
+ , fSurfaceScale(surfaceScale / 255)
+{}
+
+SkImageFilter* SkLightingImageFilter::CreateDistantLitDiffuse(const SkPoint3& direction,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar kd,
+ SkImageFilter* input,
+ const CropRect* cropRect) {
+ SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor)));
+ return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
}
-SkImageFilter* SkLightingImageFilter::CreateDistantLitDiffuse(
- const SkPoint3& direction, SkColor lightColor, SkScalar surfaceScale,
- SkScalar kd, SkImageFilter* input, const CropRect* cropRect) {
- return SkNEW_ARGS(SkDiffuseLightingImageFilter,
- (SkNEW_ARGS(SkDistantLight, (direction, lightColor)), surfaceScale, kd,
- input, cropRect));
+SkImageFilter* SkLightingImageFilter::CreatePointLitDiffuse(const SkPoint3& location,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar kd,
+ SkImageFilter* input,
+ const CropRect* cropRect) {
+ SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor)));
+ return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
}
-SkImageFilter* SkLightingImageFilter::CreatePointLitDiffuse(
- const SkPoint3& location, SkColor lightColor, SkScalar surfaceScale,
- SkScalar kd, SkImageFilter* input, const CropRect* cropRect) {
- return SkNEW_ARGS(SkDiffuseLightingImageFilter,
- (SkNEW_ARGS(SkPointLight, (location, lightColor)), surfaceScale, kd,
- input, cropRect));
+SkImageFilter* SkLightingImageFilter::CreateSpotLitDiffuse(const SkPoint3& location,
+ const SkPoint3& target,
+ SkScalar specularExponent,
+ SkScalar cutoffAngle,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar kd,
+ SkImageFilter* input,
+ const CropRect* cropRect) {
+ SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkSpotLight, (location, target, specularExponent,
+ cutoffAngle, lightColor)));
+ return SkDiffuseLightingImageFilter::Create(light, surfaceScale, kd, input, cropRect);
}
-SkImageFilter* SkLightingImageFilter::CreateSpotLitDiffuse(
- const SkPoint3& location, const SkPoint3& target,
- SkScalar specularExponent, SkScalar cutoffAngle,
- SkColor lightColor, SkScalar surfaceScale, SkScalar kd,
- SkImageFilter* input, const CropRect* cropRect) {
- return SkNEW_ARGS(SkDiffuseLightingImageFilter,
- (SkNEW_ARGS(SkSpotLight, (location, target, specularExponent,
- cutoffAngle, lightColor)),
- surfaceScale, kd, input, cropRect));
+SkImageFilter* SkLightingImageFilter::CreateDistantLitSpecular(const SkPoint3& direction,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar ks,
+ SkScalar shine,
+ SkImageFilter* input,
+ const CropRect* cropRect) {
+ SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkDistantLight, (direction, lightColor)));
+ return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
}
-SkImageFilter* SkLightingImageFilter::CreateDistantLitSpecular(
- const SkPoint3& direction, SkColor lightColor, SkScalar surfaceScale,
- SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect) {
- return SkNEW_ARGS(SkSpecularLightingImageFilter,
- (SkNEW_ARGS(SkDistantLight, (direction, lightColor)),
- surfaceScale, ks, shininess, input, cropRect));
+SkImageFilter* SkLightingImageFilter::CreatePointLitSpecular(const SkPoint3& location,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar ks,
+ SkScalar shine,
+ SkImageFilter* input,
+ const CropRect* cropRect) {
+ SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkPointLight, (location, lightColor)));
+ return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
}
-SkImageFilter* SkLightingImageFilter::CreatePointLitSpecular(
- const SkPoint3& location, SkColor lightColor, SkScalar surfaceScale,
- SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect) {
- return SkNEW_ARGS(SkSpecularLightingImageFilter,
- (SkNEW_ARGS(SkPointLight, (location, lightColor)),
- surfaceScale, ks, shininess, input, cropRect));
+SkImageFilter* SkLightingImageFilter::CreateSpotLitSpecular(const SkPoint3& location,
+ const SkPoint3& target,
+ SkScalar specularExponent,
+ SkScalar cutoffAngle,
+ SkColor lightColor,
+ SkScalar surfaceScale,
+ SkScalar ks,
+ SkScalar shine,
+ SkImageFilter* input,
+ const CropRect* cropRect) {
+ SkAutoTUnref<SkLight> light(SkNEW_ARGS(SkSpotLight, (location, target, specularExponent,
+ cutoffAngle, lightColor)));
+ return SkSpecularLightingImageFilter::Create(light, surfaceScale, ks, shine, input, cropRect);
}
-SkImageFilter* SkLightingImageFilter::CreateSpotLitSpecular(
- const SkPoint3& location, const SkPoint3& target,
- SkScalar specularExponent, SkScalar cutoffAngle,
- SkColor lightColor, SkScalar surfaceScale,
- SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect) {
- return SkNEW_ARGS(SkSpecularLightingImageFilter,
- (SkNEW_ARGS(SkSpotLight, (location, target, specularExponent, cutoffAngle, lightColor)),
- surfaceScale, ks, shininess, input, cropRect));
-}
+SkLightingImageFilter::~SkLightingImageFilter() {}
-SkLightingImageFilter::~SkLightingImageFilter() {
- SkSafeUnref(fLight);
-}
-
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkLightingImageFilter::SkLightingImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
- fLight = SkLight::UnflattenLight(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);
- buffer.writeScalar(fSurfaceScale);
+ buffer.writeScalar(fSurfaceScale * 255);
}
///////////////////////////////////////////////////////////////////////////////
-SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter* input, const CropRect* cropRect = NULL)
- : SkLightingImageFilter(light, surfaceScale, input, cropRect),
+SkImageFilter* SkDiffuseLightingImageFilter::Create(SkLight* light, SkScalar surfaceScale,
+ SkScalar kd, SkImageFilter* input, const CropRect* cropRect) {
+ if (NULL == light) {
+ return NULL;
+ }
+ if (!SkScalarIsFinite(surfaceScale) || !SkScalarIsFinite(kd)) {
+ return NULL;
+ }
// According to the spec, kd can be any non-negative number :
// http://www.w3.org/TR/SVG/filters.html#feDiffuseLightingElement
- fKD(kd < 0 ? 0 : kd)
+ if (kd < 0) {
+ return NULL;
+ }
+ return SkNEW_ARGS(SkDiffuseLightingImageFilter, (light, surfaceScale, kd, input, cropRect));
+}
+
+SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter* input, const CropRect* cropRect = NULL)
+ : SkLightingImageFilter(light, surfaceScale, input, cropRect),
+ fKD(kd)
{
}
+#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));
+ SkScalar surfaceScale = buffer.readScalar();
+ SkScalar kd = buffer.readScalar();
+ return Create(light, surfaceScale, kd, common.getInput(0), &common.cropRect());
+}
void SkDiffuseLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
@@ -1000,23 +1051,49 @@
///////////////////////////////////////////////////////////////////////////////
-SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect)
- : SkLightingImageFilter(light, surfaceScale, input, cropRect),
+SkImageFilter* SkSpecularLightingImageFilter::Create(SkLight* light, SkScalar surfaceScale,
+ SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect) {
+ if (NULL == light) {
+ return NULL;
+ }
+ if (!SkScalarIsFinite(surfaceScale) || !SkScalarIsFinite(ks) || !SkScalarIsFinite(shininess)) {
+ return NULL;
+ }
// According to the spec, ks can be any non-negative number :
// http://www.w3.org/TR/SVG/filters.html#feSpecularLightingElement
- fKS(ks < 0 ? 0 : ks),
+ if (ks < 0) {
+ return NULL;
+ }
+ return SkNEW_ARGS(SkSpecularLightingImageFilter,
+ (light, surfaceScale, ks, shininess, input, cropRect));
+}
+
+SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect)
+ : SkLightingImageFilter(light, surfaceScale, input, cropRect),
+ fKS(ks),
fShininess(shininess)
{
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkReadBuffer& buffer)
- : INHERITED(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));
+ SkScalar surfaceScale = buffer.readScalar();
+ SkScalar ks = buffer.readScalar();
+ SkScalar shine = buffer.readScalar();
+ return Create(light, surfaceScale, ks, shine, common.getInput(0), &common.cropRect());
+}
void SkSpecularLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index d33e5e8..26621bb 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -41,16 +41,17 @@
return SkNEW(SkLumaColorFilter);
}
-SkLumaColorFilter::SkLumaColorFilter()
- : INHERITED() {
+SkLumaColorFilter::SkLumaColorFilter() : INHERITED() {}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkLumaColorFilter::SkLumaColorFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#endif
+
+SkFlattenable* SkLumaColorFilter::CreateProc(SkReadBuffer&) {
+ return SkNEW(SkLumaColorFilter);
}
-SkLumaColorFilter::SkLumaColorFilter(SkReadBuffer& buffer)
- : INHERITED(buffer) {
-}
-
-void SkLumaColorFilter::flatten(SkWriteBuffer&) const {
-}
+void SkLumaColorFilter::flatten(SkWriteBuffer&) const {}
#ifndef SK_IGNORE_TO_STRING
void SkLumaColorFilter::toString(SkString* str) const {
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 203cab7..cb0fc24 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -232,6 +232,22 @@
#endif
////////////////////////////////////////////////////////////////////////////////
+
+SkImageFilter* SkMagnifierImageFilter::Create(const SkRect& srcRect, SkScalar inset,
+ SkImageFilter* input) {
+
+ if (!SkScalarIsFinite(inset) || !SkIsValidRect(srcRect)) {
+ return NULL;
+ }
+ // Negative numbers in src rect are not supported
+ if (srcRect.fLeft < 0 || srcRect.fTop < 0) {
+ return NULL;
+ }
+ return SkNEW_ARGS(SkMagnifierImageFilter, (srcRect, inset, input));
+}
+
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkMagnifierImageFilter::SkMagnifierImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
float x = buffer.readScalar();
@@ -245,6 +261,7 @@
// Negative numbers in src rect are not supported
(fSrcRect.fLeft >= 0) && (fSrcRect.fTop >= 0));
}
+#endif
SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset,
SkImageFilter* input)
@@ -271,12 +288,16 @@
}
#endif
+SkFlattenable* SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
+ SkRect src;
+ buffer.readRect(&src);
+ return Create(src, buffer.readScalar(), common.getInput(0));
+}
+
void SkMagnifierImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
- buffer.writeScalar(fSrcRect.x());
- buffer.writeScalar(fSrcRect.y());
- buffer.writeScalar(fSrcRect.width());
- buffer.writeScalar(fSrcRect.height());
+ buffer.writeRect(fSrcRect);
buffer.writeScalar(fInset);
}
diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp
index 6e1d1a4..e01b640 100644
--- a/src/effects/SkMatrixConvolutionImageFilter.cpp
+++ b/src/effects/SkMatrixConvolutionImageFilter.cpp
@@ -17,18 +17,6 @@
#include "effects/GrMatrixConvolutionEffect.h"
#endif
-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(
const SkISize& kernelSize,
const SkScalar* kernel,
@@ -54,6 +42,19 @@
SkASSERT(kernelOffset.fY >= 0 && kernelOffset.fY < kernelSize.fHeight);
}
+#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) {
// We need to be able to read at most SK_MaxS32 bytes, so divide that
@@ -86,6 +87,33 @@
(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;
+ kernelSize.fWidth = buffer.readInt();
+ kernelSize.fHeight = buffer.readInt();
+ const int count = buffer.getArrayCount();
+
+ const int64_t kernelArea = sk_64_mul(kernelSize.width(), kernelSize.height());
+ if (!buffer.validate(kernelArea == count)) {
+ return NULL;
+ }
+ SkAutoSTArray<16, SkScalar> kernel(count);
+ if (!buffer.readScalarArray(kernel.get(), count)) {
+ return NULL;
+ }
+ SkScalar gain = buffer.readScalar();
+ SkScalar bias = buffer.readScalar();
+ SkIPoint kernelOffset;
+ kernelOffset.fX = buffer.readInt();
+ kernelOffset.fY = buffer.readInt();
+ TileMode tileMode = (TileMode)buffer.readInt();
+ bool convolveAlpha = buffer.readBool();
+ return Create(kernelSize, kernel.get(), gain, bias, kernelOffset, tileMode, convolveAlpha,
+ common.getInput(0), &common.cropRect());
+}
void SkMatrixConvolutionImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/SkMatrixImageFilter.cpp b/src/effects/SkMatrixImageFilter.cpp
index c7c815a..2b7786a 100644
--- a/src/effects/SkMatrixImageFilter.cpp
+++ b/src/effects/SkMatrixImageFilter.cpp
@@ -29,11 +29,21 @@
return SkNEW_ARGS(SkMatrixImageFilter, (transform, filterLevel, input));
}
+#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;
+ buffer.readMatrix(&matrix);
+ SkPaint::FilterLevel level = static_cast<SkPaint::FilterLevel>(buffer.readInt());
+ return Create(matrix, level, common.getInput(0));
+}
void SkMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/SkMergeImageFilter.cpp b/src/effects/SkMergeImageFilter.cpp
index 4022da3..a76702f 100755
--- a/src/effects/SkMergeImageFilter.cpp
+++ b/src/effects/SkMergeImageFilter.cpp
@@ -105,15 +105,41 @@
return true;
}
+SkFlattenable* SkMergeImageFilter::CreateProc(SkReadBuffer& buffer) {
+ Common common;
+ if (!common.unflatten(buffer, -1)) {
+ return NULL;
+ }
+
+ const int count = common.inputCount();
+ bool hasModes = buffer.readBool();
+ if (hasModes) {
+ SkAutoSTArray<4, SkXfermode::Mode> modes(count);
+ SkAutoSTArray<4, uint8_t> modes8(count);
+ if (!buffer.readByteArray(modes8.get(), count)) {
+ return NULL;
+ }
+ for (int i = 0; i < count; ++i) {
+ modes[i] = (SkXfermode::Mode)modes8[i];
+ buffer.validate(SkIsValidMode(modes[i]));
+ }
+ if (!buffer.isValid()) {
+ return NULL;
+ }
+ return Create(common.inputs(), count, modes.get(), &common.cropRect());
+ }
+ return Create(common.inputs(), count, NULL, &common.cropRect());
+}
+
void SkMergeImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
-
buffer.writeBool(fModes != NULL);
if (fModes) {
buffer.writeByteArray(fModes, countInputs() * sizeof(fModes[0]));
}
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkMergeImageFilter::SkMergeImageFilter(SkReadBuffer& buffer)
: INHERITED(-1, buffer) {
bool hasModes = buffer.readBool();
@@ -132,3 +158,4 @@
fModes = 0;
}
}
+#endif
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 67769f2..bb8478c 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -21,6 +21,7 @@
#include "effects/Gr1DKernelEffect.h"
#endif
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkMorphologyImageFilter::SkMorphologyImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fRadius.fWidth = buffer.readInt();
@@ -28,6 +29,7 @@
buffer.validate((fRadius.fWidth >= 0) &&
(fRadius.fHeight >= 0));
}
+#endif
SkMorphologyImageFilter::SkMorphologyImageFilter(int radiusX,
int radiusY,
@@ -36,7 +38,6 @@
: INHERITED(1, &input, cropRect), fRadius(SkISize::Make(radiusX, radiusY)) {
}
-
void SkMorphologyImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt(fRadius.fWidth);
@@ -258,6 +259,20 @@
return true;
}
+SkFlattenable* SkErodeImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
+ const int width = buffer.readInt();
+ const int height = buffer.readInt();
+ return Create(width, height, common.getInput(0), &common.cropRect());
+}
+
+SkFlattenable* SkDilateImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
+ const int width = buffer.readInt();
+ const int height = buffer.readInt();
+ return Create(width, height, common.getInput(0), &common.cropRect());
+}
+
#if SK_SUPPORT_GPU
///////////////////////////////////////////////////////////////////////////////
diff --git a/src/effects/SkOffsetImageFilter.cpp b/src/effects/SkOffsetImageFilter.cpp
index 57f36db..fcf09cc 100644
--- a/src/effects/SkOffsetImageFilter.cpp
+++ b/src/effects/SkOffsetImageFilter.cpp
@@ -91,6 +91,13 @@
return true;
}
+SkFlattenable* SkOffsetImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
+ SkPoint offset;
+ buffer.readPoint(&offset);
+ return Create(offset.x(), offset.y(), common.getInput(0), &common.cropRect());
+}
+
void SkOffsetImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fOffset);
@@ -102,9 +109,11 @@
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 b9b09dd..427b451 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -287,9 +287,8 @@
SkASSERT(numOctaves >= 0 && numOctaves < 256);
}
-SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer)
- : INHERITED(buffer)
-{
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer) : INHERITED(buffer) {
fType = (SkPerlinNoiseShader::Type) buffer.readInt();
fBaseFrequencyX = buffer.readScalar();
fBaseFrequencyY = buffer.readScalar();
@@ -302,18 +301,37 @@
(fNumOctaves >= 0) && (fNumOctaves <= 255) &&
(fStitchTiles != fTileSize.isEmpty()));
}
+#endif
SkPerlinNoiseShader::~SkPerlinNoiseShader() {
}
+SkFlattenable* SkPerlinNoiseShader::CreateProc(SkReadBuffer& buffer) {
+ Type type = (Type)buffer.readInt();
+ SkScalar freqX = buffer.readScalar();
+ SkScalar freqY = buffer.readScalar();
+ int octaves = buffer.readInt();
+ SkScalar seed = buffer.readScalar();
+ SkISize tileSize;
+ tileSize.fWidth = buffer.readInt();
+ tileSize.fHeight = buffer.readInt();
+
+ switch (type) {
+ case kFractalNoise_Type:
+ return SkPerlinNoiseShader::CreateFractalNoise(freqX, freqY, octaves, seed, &tileSize);
+ case kTurbulence_Type:
+ return SkPerlinNoiseShader::CreateTubulence(freqX, freqY, octaves, seed, &tileSize);
+ default:
+ return NULL;
+ }
+}
+
void SkPerlinNoiseShader::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
buffer.writeInt((int) fType);
buffer.writeScalar(fBaseFrequencyX);
buffer.writeScalar(fBaseFrequencyY);
buffer.writeInt(fNumOctaves);
buffer.writeScalar(fSeed);
- buffer.writeBool(fStitchTiles);
buffer.writeInt(fTileSize.fWidth);
buffer.writeInt(fTileSize.fHeight);
}
diff --git a/src/effects/SkPictureImageFilter.cpp b/src/effects/SkPictureImageFilter.cpp
index 508f53e..a1958f3 100644
--- a/src/effects/SkPictureImageFilter.cpp
+++ b/src/effects/SkPictureImageFilter.cpp
@@ -31,6 +31,7 @@
SkSafeUnref(fPicture);
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkPictureImageFilter::SkPictureImageFilter(SkReadBuffer& buffer)
: INHERITED(0, buffer),
fPicture(NULL) {
@@ -43,9 +44,25 @@
}
buffer.readRect(&fCropRect);
}
+#endif
+
+SkFlattenable* SkPictureImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SkAutoTUnref<SkPicture> picture;
+ SkRect cropRect;
+
+ if (!buffer.isCrossProcess()) {
+ if (buffer.readBool()) {
+ picture.reset(SkPicture::CreateFromBuffer(buffer));
+ }
+ } else {
+ buffer.validate(!buffer.readBool());
+ }
+ buffer.readRect(&cropRect);
+
+ return Create(picture, cropRect);
+}
void SkPictureImageFilter::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
if (!buffer.isCrossProcess()) {
bool hasPicture = (fPicture != NULL);
buffer.writeBool(hasPicture);
diff --git a/src/effects/SkPixelXorXfermode.cpp b/src/effects/SkPixelXorXfermode.cpp
index 129f182..68b5306 100644
--- a/src/effects/SkPixelXorXfermode.cpp
+++ b/src/effects/SkPixelXorXfermode.cpp
@@ -22,14 +22,18 @@
}
void SkPixelXorXfermode::flatten(SkWriteBuffer& wb) const {
- this->INHERITED::flatten(wb);
wb.writeColor(fOpColor);
}
-SkPixelXorXfermode::SkPixelXorXfermode(SkReadBuffer& rb)
- : INHERITED(rb) {
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkPixelXorXfermode::SkPixelXorXfermode(SkReadBuffer& rb) : INHERITED(rb) {
fOpColor = rb.readColor();
}
+#endif
+
+SkFlattenable* SkPixelXorXfermode::CreateProc(SkReadBuffer& buffer) {
+ return Create(buffer.readColor());
+}
#ifndef SK_IGNORE_TO_STRING
void SkPixelXorXfermode::toString(SkString* str) const {
diff --git a/src/effects/SkRectShaderImageFilter.cpp b/src/effects/SkRectShaderImageFilter.cpp
index 6961fac..fe0be12 100644
--- a/src/effects/SkRectShaderImageFilter.cpp
+++ b/src/effects/SkRectShaderImageFilter.cpp
@@ -35,14 +35,20 @@
s->ref();
}
+#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);
+ return Create(buffer.readShader(), &common.cropRect());
+}
void SkRectShaderImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
-
buffer.writeFlattenable(fShader);
}
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 2544b03..54e1efe 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -61,7 +61,9 @@
};
protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkTable_ColorFilter(SkReadBuffer& buffer);
+#endif
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
@@ -70,6 +72,8 @@
uint8_t fStorage[256 * 4];
unsigned fFlags;
+ friend class SkTableColorFilter;
+
typedef SkColorFilter INHERITED;
};
@@ -168,19 +172,62 @@
#include "SkPackBits.h"
void SkTable_ColorFilter::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
-
uint8_t storage[5*256];
int count = gCountNibBits[fFlags & 0xF];
size_t size = SkPackBits::Pack8(fStorage, count * 256, storage);
SkASSERT(size <= sizeof(storage));
-// SkDebugf("raw %d packed %d\n", count * 256, size);
-
- buffer.writeInt(fFlags);
+ buffer.write32(fFlags);
buffer.writeByteArray(storage, size);
}
+SkFlattenable* SkTable_ColorFilter::CreateProc(SkReadBuffer& buffer) {
+ const int flags = buffer.read32();
+ const size_t count = gCountNibBits[flags & 0xF];
+ SkASSERT(count <= 4);
+
+ uint8_t packedStorage[5*256];
+ size_t packedSize = buffer.getArrayCount();
+ if (!buffer.validate(packedSize <= sizeof(packedStorage))) {
+ return NULL;
+ }
+ if (!buffer.readByteArray(packedStorage, packedSize)) {
+ return NULL;
+ }
+
+ uint8_t unpackedStorage[4*256];
+ size_t unpackedSize = SkPackBits::Unpack8(packedStorage, packedSize, unpackedStorage);
+ // now check that we got the size we expected
+ if (!buffer.validate(unpackedSize != count*256)) {
+ return NULL;
+ }
+
+ const uint8_t* a = NULL;
+ const uint8_t* r = NULL;
+ const uint8_t* g = NULL;
+ const uint8_t* b = NULL;
+ const uint8_t* ptr = unpackedStorage;
+
+ if (flags & kA_Flag) {
+ a = ptr;
+ ptr += 256;
+ }
+ if (flags & kR_Flag) {
+ r = ptr;
+ ptr += 256;
+ }
+ if (flags & kG_Flag) {
+ g = ptr;
+ ptr += 256;
+ }
+ if (flags & kB_Flag) {
+ b = ptr;
+ ptr += 256;
+ }
+ return SkTableColorFilter::CreateARGB(a, r, g, b);
+}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkTable_ColorFilter::SkTable_ColorFilter(SkReadBuffer& buffer) : INHERITED(buffer) {
fBitmap = NULL;
@@ -199,6 +246,7 @@
SkDEBUGCODE(size_t count = gCountNibBits[fFlags & 0xF]);
SkASSERT(raw == count * 256);
}
+#endif
bool SkTable_ColorFilter::asComponentTable(SkBitmap* table) const {
if (table) {
diff --git a/src/effects/SkTableMaskFilter.cpp b/src/effects/SkTableMaskFilter.cpp
index 602302e..42b4ab6 100644
--- a/src/effects/SkTableMaskFilter.cpp
+++ b/src/effects/SkTableMaskFilter.cpp
@@ -71,15 +71,23 @@
}
void SkTableMaskFilter::flatten(SkWriteBuffer& wb) const {
- this->INHERITED::flatten(wb);
wb.writeByteArray(fTable, 256);
}
-SkTableMaskFilter::SkTableMaskFilter(SkReadBuffer& rb)
- : INHERITED(rb) {
+SkFlattenable* SkTableMaskFilter::CreateProc(SkReadBuffer& buffer) {
+ uint8_t table[256];
+ if (!buffer.readByteArray(table, 256)) {
+ return NULL;
+ }
+ return Create(table);
+}
+
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkTableMaskFilter::SkTableMaskFilter(SkReadBuffer& rb) : INHERITED(rb) {
SkASSERT(256 == rb.getArrayCount());
rb.readByteArray(fTable, 256);
}
+#endif
///////////////////////////////////////////////////////////////////////////////
diff --git a/src/effects/SkTestImageFilters.cpp b/src/effects/SkTestImageFilters.cpp
index da88316..a414c92 100755
--- a/src/effects/SkTestImageFilters.cpp
+++ b/src/effects/SkTestImageFilters.cpp
@@ -71,14 +71,20 @@
return true;
}
+SkFlattenable* SkDownSampleImageFilter::CreateProc(SkReadBuffer& buffer) {
+ SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
+ return Create(buffer.readScalar(), common.getInput(0));
+}
+
void SkDownSampleImageFilter::flatten(SkWriteBuffer& buffer) const {
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 73c0a58..64492e2 100644
--- a/src/effects/SkTileImageFilter.cpp
+++ b/src/effects/SkTileImageFilter.cpp
@@ -16,6 +16,14 @@
#include "SkShader.h"
#include "SkValidationUtils.h"
+SkTileImageFilter* SkTileImageFilter::Create(const SkRect& srcRect, const SkRect& dstRect,
+ SkImageFilter* input) {
+ if (!SkIsValidRect(srcRect) || !SkIsValidRect(dstRect)) {
+ return NULL;
+ }
+ return SkNEW_ARGS(SkTileImageFilter, (srcRect, dstRect, input));
+}
+
bool SkTileImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& src,
const Context& ctx,
SkBitmap* dst, SkIPoint* offset) const {
@@ -86,12 +94,22 @@
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;
+ buffer.readRect(&src);
+ buffer.readRect(&dst);
+ return Create(src, dst, common.getInput(0));
+}
void SkTileImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/SkTransparentShader.cpp b/src/effects/SkTransparentShader.cpp
index f290d0d..aab5a3d 100644
--- a/src/effects/SkTransparentShader.cpp
+++ b/src/effects/SkTransparentShader.cpp
@@ -115,6 +115,10 @@
}
}
+SkFlattenable* SkTransparentShader::CreateProc(SkReadBuffer& buffer) {
+ return SkNEW(SkTransparentShader);
+}
+
#ifndef SK_IGNORE_TO_STRING
void SkTransparentShader::toString(SkString* str) const {
str->append("SkTransparentShader: (");
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index c876d5f..15ff92a 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -31,10 +31,18 @@
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());
+ return Create(mode, common.getInput(0), common.getInput(1), &common.cropRect());
+}
void SkXfermodeImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index 21bf885..7cc9063 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -12,6 +12,61 @@
#include "SkTwoPointConicalGradient.h"
#include "SkSweepGradient.h"
+void SkGradientShaderBase::Descriptor::flatten(SkWriteBuffer& buffer) const {
+ buffer.writeColorArray(fColors, fCount);
+ if (fPos) {
+ buffer.writeBool(true);
+ buffer.writeScalarArray(fPos, fCount);
+ } else {
+ buffer.writeBool(false);
+ }
+ buffer.write32(fTileMode);
+ buffer.write32(fGradFlags);
+ if (fLocalMatrix) {
+ buffer.writeBool(true);
+ buffer.writeMatrix(*fLocalMatrix);
+ } else {
+ buffer.writeBool(false);
+ }
+}
+
+bool SkGradientShaderBase::DescriptorScope::unflatten(SkReadBuffer& buffer) {
+ fCount = buffer.getArrayCount();
+ if (fCount > kStorageCount) {
+ size_t allocSize = (sizeof(SkColor) + sizeof(SkScalar)) * fCount;
+ fDynamicStorage.reset(allocSize);
+ fColors = (SkColor*)fDynamicStorage.get();
+ fPos = (SkScalar*)(fColors + fCount);
+ } else {
+ fColors = fColorStorage;
+ fPos = fPosStorage;
+ }
+
+ if (!buffer.readColorArray(const_cast<SkColor*>(fColors), fCount)) {
+ return false;
+ }
+ if (buffer.readBool()) {
+ if (!buffer.readScalarArray(const_cast<SkScalar*>(fPos), fCount)) {
+ return false;
+ }
+ } else {
+ fPos = NULL;
+ }
+
+ fTileMode = (SkShader::TileMode)buffer.read32();
+ fGradFlags = buffer.read32();
+
+ if (buffer.readBool()) {
+ fLocalMatrix = &fLocalMatrixStorage;
+ buffer.readMatrix(&fLocalMatrixStorage);
+ } else {
+ fLocalMatrix = NULL;
+ }
+ return buffer.isValid();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+
SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc)
: INHERITED(desc.fLocalMatrix)
{
@@ -47,6 +102,9 @@
if (fColorCount > kColorStorageCount) {
size_t size = sizeof(SkColor) + sizeof(Rec);
+ if (desc.fPos) {
+ size += sizeof(SkScalar);
+ }
fOrigColors = reinterpret_cast<SkColor*>(
sk_malloc_throw(size * fColorCount));
}
@@ -67,13 +125,23 @@
}
}
- fRecs = (Rec*)(fOrigColors + fColorCount);
+ if (desc.fPos && fColorCount) {
+ fOrigPos = (SkScalar*)(fOrigColors + fColorCount);
+ fRecs = (Rec*)(fOrigPos + fColorCount);
+ } else {
+ fOrigPos = NULL;
+ fRecs = (Rec*)(fOrigColors + fColorCount);
+ }
+
if (fColorCount > 2) {
Rec* recs = fRecs;
recs->fPos = 0;
// recs->fScale = 0; // unused;
recs += 1;
if (desc.fPos) {
+ SkScalar* origPosPtr = fOrigPos;
+ *origPosPtr++ = 0;
+
/* We need to convert the user's array of relative positions into
fixed-point positions and scale factors. We need these results
to be strictly monotonic (no two values equal or out of order).
@@ -81,26 +149,22 @@
value if it sees a segment out of order, and it assures that
we start at 0 and end at 1.0
*/
- SkFixed prev = 0;
+ SkScalar prev = 0;
int startIndex = dummyFirst ? 0 : 1;
int count = desc.fCount + dummyLast;
for (int i = startIndex; i < count; i++) {
// force the last value to be 1.0
- SkFixed curr;
+ SkScalar curr;
if (i == desc.fCount) { // we're really at the dummyLast
- curr = SK_Fixed1;
+ curr = 1;
} else {
- curr = SkScalarToFixed(desc.fPos[i]);
+ curr = SkScalarPin(desc.fPos[i], 0, 1);
}
- // pin curr withing range
- if (curr < 0) {
- curr = 0;
- } else if (curr > SK_Fixed1) {
- curr = SK_Fixed1;
- }
- recs->fPos = curr;
+ *origPosPtr++ = curr;
+
+ recs->fPos = SkScalarToFixed(curr);
if (curr > prev) {
- recs->fScale = (1 << 24) / (curr - prev);
+ recs->fScale = (1 << 24) / SkScalarToFixed(curr - prev);
} else {
recs->fScale = 0; // ignore this segment
}
@@ -109,6 +173,8 @@
recs += 1;
}
} else { // assume even distribution
+ fOrigPos = NULL;
+
SkFixed dp = SK_Fixed1 / (desc.fCount - 1);
SkFixed p = dp;
SkFixed scale = (desc.fCount - 1) << 8; // (1 << 24) / dp
@@ -121,16 +187,18 @@
recs->fPos = SK_Fixed1;
recs->fScale = scale;
}
+ } else if (desc.fPos) {
+ SkASSERT(2 == fColorCount);
+ fOrigPos[0] = SkScalarPin(desc.fPos[0], 0, 1);
+ fOrigPos[1] = SkScalarPin(desc.fPos[1], fOrigPos[0], 1);
+ if (0 == fOrigPos[0] && 1 == fOrigPos[1]) {
+ fOrigPos = NULL;
+ }
}
this->initCommon();
}
-static uint32_t pack_mode_flags(SkShader::TileMode mode, uint32_t flags) {
- SkASSERT(0 == (flags >> 28));
- SkASSERT(0 == ((uint32_t)mode >> 4));
- return (flags << 4) | mode;
-}
-
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
static SkShader::TileMode unpack_mode(uint32_t packed) {
return (SkShader::TileMode)(packed & 0xF);
}
@@ -177,6 +245,7 @@
buffer.readMatrix(&fPtsToUnit);
this->initCommon();
}
+#endif
SkGradientShaderBase::~SkGradientShaderBase() {
if (fOrigColors != fStorage) {
@@ -193,17 +262,16 @@
}
void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const {
- this->INHERITED::flatten(buffer);
- buffer.writeColorArray(fOrigColors, fColorCount);
- buffer.writeUInt(pack_mode_flags(fTileMode, fGradFlags));
- if (fColorCount > 2) {
- Rec* recs = fRecs;
- for (int i = 1; i < fColorCount; i++) {
- buffer.writeInt(recs[i].fPos);
- buffer.writeUInt(recs[i].fScale);
- }
- }
- buffer.writeMatrix(fPtsToUnit);
+ Descriptor desc;
+ desc.fColors = fOrigColors;
+ desc.fPos = fOrigPos;
+ desc.fCount = fColorCount;
+ desc.fTileMode = fTileMode;
+ desc.fGradFlags = fGradFlags;
+
+ const SkMatrix& m = this->getLocalMatrix();
+ desc.fLocalMatrix = m.isIdentity() ? NULL : &m;
+ desc.flatten(buffer);
}
SkGradientShaderBase::GpuColorType SkGradientShaderBase::getGpuColorType(SkColor colors[3]) const {
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index 1787e24..cf6c671 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -95,6 +95,29 @@
int fCount;
SkShader::TileMode fTileMode;
uint32_t fGradFlags;
+
+ void flatten(SkWriteBuffer&) const;
+ };
+
+ class DescriptorScope : public Descriptor {
+ public:
+ DescriptorScope() {}
+
+ bool unflatten(SkReadBuffer&);
+
+ // fColors and fPos always point into local memory, so they can be safely mutated
+ //
+ SkColor* mutableColors() { return const_cast<SkColor*>(fColors); }
+ SkScalar* mutablePos() { return const_cast<SkScalar*>(fPos); }
+
+ private:
+ enum {
+ kStorageCount = 16
+ };
+ SkColor fColorStorage[kStorageCount];
+ SkScalar fPosStorage[kStorageCount];
+ SkMatrix fLocalMatrixStorage;
+ SkAutoMalloc fDynamicStorage;
};
public:
@@ -234,10 +257,11 @@
enum {
kColorStorageCount = 4, // more than this many colors, and we'll use sk_malloc for the space
- kStorageSize = kColorStorageCount * (sizeof(SkColor) + sizeof(Rec))
+ kStorageSize = kColorStorageCount * (sizeof(SkColor) + sizeof(SkScalar) + sizeof(Rec))
};
SkColor fStorage[(kStorageSize + 3) >> 2];
SkColor* fOrigColors; // original colors, before modulation by paint in context.
+ SkScalar* fOrigPos; // original positions
bool fColorsAreOpaque;
GradientShaderCache* refCache(U8CPU alpha) const;
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 4f85da3..9d939bf 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -60,11 +60,25 @@
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)) {
+ return NULL;
+ }
+ SkPoint pts[2];
+ pts[0] = buffer.readPoint();
+ pts[1] = buffer.readPoint();
+ return SkGradientShader::CreateLinear(pts, desc.fColors, desc.fPos, desc.fCount,
+ desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix);
+}
void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/gradients/SkLinearGradient.h b/src/effects/gradients/SkLinearGradient.h
index 65d8bfd..6890106 100644
--- a/src/effects/gradients/SkLinearGradient.h
+++ b/src/effects/gradients/SkLinearGradient.h
@@ -42,6 +42,7 @@
virtual Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
private:
+ friend class SkGradientShader;
typedef SkGradientShaderBase INHERITED;
const SkPoint fStart;
const SkPoint fEnd;
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index a6a2e36..fb1d40a 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -252,11 +252,24 @@
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)) {
+ return NULL;
+ }
+ const SkPoint center = buffer.readPoint();
+ const SkScalar radius = buffer.readScalar();
+ return SkGradientShader::CreateRadial(center, radius, desc.fColors, desc.fPos, desc.fCount,
+ desc.fTileMode, desc.fGradFlags, desc.fLocalMatrix);
+}
void SkRadialGradient::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/gradients/SkRadialGradient.h b/src/effects/gradients/SkRadialGradient.h
index b7dbcbd..7709c38 100644
--- a/src/effects/gradients/SkRadialGradient.h
+++ b/src/effects/gradients/SkRadialGradient.h
@@ -43,6 +43,7 @@
virtual Context* onCreateContext(const ContextRec&, void* storage) const SK_OVERRIDE;
private:
+ friend class SkGradientShader;
typedef SkGradientShaderBase INHERITED;
const SkPoint fCenter;
const SkScalar fRadius;
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index a539216..1bb595c 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -41,10 +41,22 @@
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)) {
+ return NULL;
+ }
+ const SkPoint center = buffer.readPoint();
+ return SkGradientShader::CreateSweep(center.x(), center.y(), desc.fColors, desc.fPos,
+ desc.fCount, desc.fGradFlags, desc.fLocalMatrix);
+}
void SkSweepGradient::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
diff --git a/src/effects/gradients/SkSweepGradient.h b/src/effects/gradients/SkSweepGradient.h
index 5c46061..640079a 100644
--- a/src/effects/gradients/SkSweepGradient.h
+++ b/src/effects/gradients/SkSweepGradient.h
@@ -41,13 +41,16 @@
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;
private:
const SkPoint fCenter;
+ friend class SkGradientShader;
typedef SkGradientShaderBase INHERITED;
};
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index 91856c8..9284e7c 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -343,6 +343,7 @@
return kConical_GradientType;
}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkTwoPointConicalGradient::SkTwoPointConicalGradient(
SkReadBuffer& buffer)
: INHERITED(buffer),
@@ -366,9 +367,47 @@
}
this->init();
};
+#endif
-void SkTwoPointConicalGradient::flatten(
- SkWriteBuffer& buffer) const {
+SkFlattenable* SkTwoPointConicalGradient::CreateProc(SkReadBuffer& buffer) {
+ DescriptorScope desc;
+ if (!desc.unflatten(buffer)) {
+ return NULL;
+ }
+ SkPoint c1 = buffer.readPoint();
+ SkPoint c2 = buffer.readPoint();
+ SkScalar r1 = buffer.readScalar();
+ SkScalar r2 = buffer.readScalar();
+
+ if (buffer.readBool()) { // flipped
+ SkTSwap(c1, c2);
+ SkTSwap(r1, r2);
+
+ SkColor* colors = desc.mutableColors();
+ SkScalar* pos = desc.mutablePos();
+ const int last = desc.fCount - 1;
+ const int half = desc.fCount >> 1;
+ for (int i = 0; i < half; ++i) {
+ SkTSwap(colors[i], colors[last - i]);
+ if (pos) {
+ SkScalar tmp = pos[i];
+ pos[i] = SK_Scalar1 - pos[last - i];
+ pos[last - i] = SK_Scalar1 - tmp;
+ }
+ }
+ if (pos) {
+ if (desc.fCount & 1) {
+ pos[half] = SK_Scalar1 - pos[half];
+ }
+ }
+ }
+
+ return SkGradientShader::CreateTwoPointConical(c1, r1, c2, r2, desc.fColors, desc.fPos,
+ desc.fCount, desc.fTileMode, desc.fGradFlags,
+ desc.fLocalMatrix);
+}
+
+void SkTwoPointConicalGradient::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fCenter1);
buffer.writePoint(fCenter2);
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.h b/src/effects/gradients/SkTwoPointConicalGradient.h
index fc39046..608ea76 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.h
+++ b/src/effects/gradients/SkTwoPointConicalGradient.h
@@ -91,6 +91,7 @@
SkScalar fRadius2;
bool fFlippedGrad;
+ friend class SkGradientShader;
typedef SkGradientShaderBase INHERITED;
};
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp
index 8a40822..754a532 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.cpp
+++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp
@@ -343,8 +343,8 @@
}
#endif
-SkTwoPointRadialGradient::SkTwoPointRadialGradient(
- SkReadBuffer& buffer)
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+SkTwoPointRadialGradient::SkTwoPointRadialGradient(SkReadBuffer& buffer)
: INHERITED(buffer),
fCenter1(buffer.readPoint()),
fCenter2(buffer.readPoint()),
@@ -352,6 +352,21 @@
fRadius2(buffer.readScalar()) {
init();
};
+#endif
+
+SkFlattenable* SkTwoPointRadialGradient::CreateProc(SkReadBuffer& buffer) {
+ DescriptorScope desc;
+ if (!desc.unflatten(buffer)) {
+ return NULL;
+ }
+ const SkPoint c1 = buffer.readPoint();
+ const SkPoint c2 = buffer.readPoint();
+ const SkScalar r1 = buffer.readScalar();
+ const SkScalar r2 = buffer.readScalar();
+ return SkGradientShader::CreateTwoPointRadial(c1, r1, c2, r2, desc.fColors, desc.fPos,
+ desc.fCount, desc.fTileMode, desc.fGradFlags,
+ desc.fLocalMatrix);
+}
void SkTwoPointRadialGradient::flatten(
SkWriteBuffer& buffer) const {
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.h b/src/effects/gradients/SkTwoPointRadialGradient.h
index 73fa547..bfeecc5 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.h
+++ b/src/effects/gradients/SkTwoPointRadialGradient.h
@@ -58,6 +58,7 @@
void init();
+ friend class SkGradientShader;
typedef SkGradientShaderBase INHERITED;
};