Simplify flattening to just write enough to call the factory

src/core/SkXfermode.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkXfermode.h"
@@ skipping 1222 matching lines @@
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(XferEffect, (static_cast<SkXfermode::Mode>(mode), NULL));
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
 SkProcCoeffXfermode::SkProcCoeffXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
     uint32_t mode32 = buffer.read32() % SK_ARRAY_COUNT(gProcCoeffs);
     if (mode32 >= SK_ARRAY_COUNT(gProcCoeffs)) {
         // out of range, just set to something harmless
         mode32 = SkXfermode::kSrcOut_Mode;
     }
     fMode = (SkXfermode::Mode)mode32;
 
     const ProcCoeff& rec = gProcCoeffs[fMode];
     fProc = rec.fProc;
     // these may be valid, or may be CANNOT_USE_COEFF
     fSrcCoeff = rec.fSC;
     fDstCoeff = rec.fDC;
 }
+#endif
+
+SkFlattenable* SkProcCoeffXfermode::CreateProc(SkReadBuffer& buffer) {
+    uint32_t mode32 = buffer.read32();
+    if (!buffer.validate(mode32 >= SK_ARRAY_COUNT(gProcCoeffs))) {
+        return NULL;
+    }
+    return SkXfermode::Create((SkXfermode::Mode)mode32);
+}
+
+void SkProcCoeffXfermode::flatten(SkWriteBuffer& buffer) const {
+    buffer.write32(fMode);
+}
 
 bool SkProcCoeffXfermode::asMode(Mode* mode) const {
     if (mode) {
         *mode = fMode;
     }
     return true;
 }
 
 bool SkProcCoeffXfermode::asCoeff(Coeff* sc, Coeff* dc) const {
     if (CANNOT_USE_COEFF == fSrcCoeff) {
@@ skipping 102 matching lines @@
         if (NULL != effect) {
             *effect = XferEffect::Create(fMode, background);
             SkASSERT(NULL != *effect);
         }
         return true;
     }
     return false;
 }
 #endif
 
-void SkProcCoeffXfermode::flatten(SkWriteBuffer& buffer) const {
-    this->INHERITED::flatten(buffer);
-    buffer.write32(fMode);
-}
-
 const char* SkXfermode::ModeName(Mode mode) {
     SkASSERT((unsigned) mode <= (unsigned)kLastMode);
     const char* gModeStrings[] = {
         "Clear", "Src", "Dst", "SrcOver", "DstOver", "SrcIn", "DstIn",
         "SrcOut", "DstOut", "SrcATop", "DstATop", "Xor", "Plus",
         "Modulate", "Screen", "Overlay", "Darken", "Lighten", "ColorDodge",
         "ColorBurn", "HardLight", "SoftLight", "Difference", "Exclusion",
         "Multiply", "Hue", "Saturation", "Color",  "Luminosity"
     };
     return gModeStrings[mode];
@@ skipping 36 matching lines @@
     }
 
     virtual void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
     virtual void xferA8(SkAlpha*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkClearXfermode)
 
 private:
     SkClearXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kClear_Mode) {}
-    SkClearXfermode(SkReadBuffer& buffer)
-        : SkProcCoeffXfermode(buffer) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+    SkClearXfermode(SkReadBuffer& buffer) : SkProcCoeffXfermode(buffer) {}
+#endif
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE {}
 
     typedef SkProcCoeffXfermode INHERITED;
 };
 
+SkFlattenable* SkClearXfermode::CreateProc(SkReadBuffer& buffer) {
+    return SkXfermode::Create(kClear_Mode);
+}
+
 void SkClearXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                              const SkPMColor* SK_RESTRICT, int count,
                              const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && count >= 0);
 
     if (NULL == aa) {
         memset(dst, 0, count << 2);
     } else {
         for (int i = count - 1; i >= 0; --i) {
             unsigned a = aa[i];
@@ skipping 39 matching lines @@
     }
 
     virtual void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
     virtual void xferA8(SkAlpha*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSrcXfermode)
 
 private:
     SkSrcXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kSrc_Mode) {}
-    SkSrcXfermode(SkReadBuffer& buffer)
-        : SkProcCoeffXfermode(buffer) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+    SkSrcXfermode(SkReadBuffer& buffer) : SkProcCoeffXfermode(buffer) {}
+#endif
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE {}
 
     typedef SkProcCoeffXfermode INHERITED;
 };
 
+SkFlattenable* SkSrcXfermode::CreateProc(SkReadBuffer& buffer) {
+    return SkXfermode::Create(kSrc_Mode);
+}
+
 void SkSrcXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                            const SkPMColor* SK_RESTRICT src, int count,
                            const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
     if (NULL == aa) {
         memcpy(dst, src, count << 2);
     } else {
         for (int i = count - 1; i >= 0; --i) {
             unsigned a = aa[i];
@@ skipping 43 matching lines @@
         return SkNEW_ARGS(SkDstInXfermode, (rec));
     }
 
     virtual void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDstInXfermode)
 
 private:
     SkDstInXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kDstIn_Mode) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
     SkDstInXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#endif
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE {}
 
     typedef SkProcCoeffXfermode INHERITED;
 };
 
+SkFlattenable* SkDstInXfermode::CreateProc(SkReadBuffer&) {
+    return SkXfermode::Create(kDstIn_Mode);
+}
+
 void SkDstInXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                              const SkPMColor* SK_RESTRICT src, int count,
                              const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src);
 
     if (count <= 0) {
         return;
     }
     if (NULL != aa) {
         return this->INHERITED::xfer32(dst, src, count, aa);
@@ skipping 21 matching lines @@
         return SkNEW_ARGS(SkDstOutXfermode, (rec));
     }
 
     virtual void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const SK_OVERRIDE;
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDstOutXfermode)
 
 private:
     SkDstOutXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kDstOut_Mode) {}
-    SkDstOutXfermode(SkReadBuffer& buffer)
-        : INHERITED(buffer) {}
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+    SkDstOutXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {}
+#endif
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE {}
 
     typedef SkProcCoeffXfermode INHERITED;
 };
 
+SkFlattenable* SkDstOutXfermode::CreateProc(SkReadBuffer&) {
+    return SkXfermode::Create(kDstOut_Mode);
+}
+
 void SkDstOutXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                               const SkPMColor* SK_RESTRICT src, int count,
                               const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src);
 
     if (count <= 0) {
         return;
     }
     if (NULL != aa) {
         return this->INHERITED::xfer32(dst, src, count, aa);
@@ skipping 49 matching lines @@
                 SkASSERT(false);    // should not land here
                 break;
             case SkXfermode::kDstIn_Mode:
                 xfer = SkDstInXfermode::Create(rec);
                 break;
             case SkXfermode::kDstOut_Mode:
                 xfer = SkDstOutXfermode::Create(rec);
                 break;
             default:
                 // no special-case, just rely in the rec and its function-ptrs
-                xfer = SkProcCoeffXfermode::Create(rec, mode);
+                xfer = SkNEW_ARGS(SkProcCoeffXfermode, (rec, mode));
                 break;
         }
     }
     return xfer;
 }
 }  // namespace
 
 
 SkXfermode* SkXfermode::Create(Mode mode) {
     SkASSERT(SK_ARRAY_COUNT(gProcCoeffs) == kModeCount);
@@ skipping 250 matching lines @@
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSrcXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstInXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstOutXfermode)
 #if !SK_ARM_NEON_IS_NONE
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkNEONProcCoeffXfermode)
 #endif
 #if defined(SK_CPU_X86) && !defined(SK_BUILD_FOR_IOS)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSSE2ProcCoeffXfermode)
 #endif
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END