Revert of Remove SK_SUPPORT_LEGACY_DEEPFLATTENING.

src/effects/SkTableColorFilter.cpp

 
 #include "SkBitmap.h"
 #include "SkTableColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkUnPreMultiply.h"
 #include "SkString.h"
 
 class SkTable_ColorFilter : public SkColorFilter {
@@ skipping 43 matching lines @@
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTable_ColorFilter)
 
     enum {
         kA_Flag = 1 << 0,
         kR_Flag = 1 << 1,
         kG_Flag = 1 << 2,
         kB_Flag = 1 << 3,
     };
 
 protected:
+#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
+    SkTable_ColorFilter(SkReadBuffer& buffer);
+#endif
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     mutable const SkBitmap* fBitmap; // lazily allocated
 
     uint8_t fStorage[256 * 4];
     unsigned fFlags;
 
     friend class SkTableColorFilter;
 
@@ skipping 143 matching lines @@
         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;
+
+    uint8_t storage[5*256];
+
+    fFlags = buffer.readInt();
+
+    size_t size = buffer.getArrayCount();
+    SkASSERT(size <= sizeof(storage));
+    buffer.validate(size <= sizeof(storage));
+    buffer.readByteArray(storage, size);
+
+    SkDEBUGCODE(size_t raw = ) SkPackBits::Unpack8(storage, size, fStorage);
+
+    SkASSERT(raw <= sizeof(fStorage));
+    SkDEBUGCODE(size_t count = gCountNibBits[fFlags & 0xF]);
+    SkASSERT(raw == count * 256);
+}
+#endif
+
 bool SkTable_ColorFilter::asComponentTable(SkBitmap* table) const {
     if (table) {
         if (NULL == fBitmap) {
             SkBitmap* bmp = SkNEW(SkBitmap);
             bmp->allocPixels(SkImageInfo::MakeA8(256, 4));
             uint8_t* bitmapPixels = bmp->getAddr8(0, 0);
             int offset = 0;
             static const unsigned kFlags[] = { kA_Flag, kR_Flag, kG_Flag, kB_Flag };
 
             for (int x = 0; x < 4; ++x) {
@@ skipping 44 matching lines @@
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
     ColorTableEffect(GrTexture* texture, GrTextureStripAtlas* atlas, int row, unsigned flags);
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     GrTextureAccess         fTextureAccess;
 
     // currently not used in shader code, just to assist onComputeInvariantOutput().
-    unsigned                fFlags;
+    unsigned                fFlags; 
 
     GrTextureStripAtlas*    fAtlas;
     int                     fRow;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 class GLColorTableEffect : public GrGLFragmentProcessor {
 public:
     GLColorTableEffect(const GrBackendProcessorFactory&, const GrProcessor&);
@@ skipping 25 matching lines @@
     if (cte.atlas()) {
         SkScalar yDelta = cte.atlas()->getNormalizedTexelHeight();
         rgbaYValues[3] = cte.atlas()->getYOffset(cte.atlasRow()) + SK_ScalarHalf * yDelta;
         rgbaYValues[0] = rgbaYValues[3] + yDelta;
         rgbaYValues[1] = rgbaYValues[0] + yDelta;
         rgbaYValues[2] = rgbaYValues[1] + yDelta;
     } else {
         rgbaYValues[3] = 0.125;
         rgbaYValues[0] = 0.375;
         rgbaYValues[1] = 0.625;
-        rgbaYValues[2] = 0.875;
+        rgbaYValues[2] = 0.875;        
     }
     pdm.set4fv(fRGBAYValuesUni, 1, rgbaYValues);
 }
 
 void GLColorTableEffect::emitCode(GrGLFPBuilder* builder,
                                   const GrFragmentProcessor&,
                                   const char* outputColor,
                                   const char* inputColor,
                                   const TransformedCoordsArray&,
                                   const TextureSamplerArray& samplers) {
@@ skipping 174 matching lines @@
 SkColorFilter* SkTableColorFilter::CreateARGB(const uint8_t tableA[256],
                                               const uint8_t tableR[256],
                                               const uint8_t tableG[256],
                                               const uint8_t tableB[256]) {
     return SkNEW_ARGS(SkTable_ColorFilter, (tableA, tableR, tableG, tableB));
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkTableColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTable_ColorFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END