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