Refactored SkColorSpace and added in a Lab PCS GM

src/core/SkColorSpaceXform.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorPriv.h"
+#include "SkColorSpace_A2B.h"
 #include "SkColorSpace_Base.h"
+#include "SkColorSpace_XYZ.h"
 #include "SkColorSpacePriv.h"
 #include "SkColorSpaceXform_Base.h"
 #include "SkHalf.h"
 #include "SkOpts.h"
 #include "SkSRGB.h"
 
 static constexpr float sk_linear_from_2dot2[256] = {
         0.000000000000000000f, 0.000005077051900662f, 0.000023328004666099f, 0.000056921765712193f,
         0.000107187362341244f, 0.000175123977503027f, 0.000261543754548491f, 0.000367136269815943f,
         0.000492503787191433f, 0.000638182842167022f, 0.000804658499513058f, 0.000992374304074325f,
@@ skipping 227 matching lines @@
     nullptr,
     nullptr,
     &build_table_linear_to_gamma,
     &build_table_linear_to_gamma,
     &build_table_linear_to_gamma,
 };
 
 // Build tables to transform src gamma to linear.
 template <typename T>
 static void build_gamma_tables(const T* outGammaTables[3], T* gammaTableStorage, int gammaTableSize,
-                               const SkColorSpace* space, const GammaFns<T>& fns,
+                               const SkColorSpace_XYZ* space, const GammaFns<T>& fns,
                                bool gammasAreMatching)
 {
-    switch (as_CSB(space)->gammaNamed()) {
+    switch (space->gammaNamed()) {
         case kSRGB_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.fSRGBTable;
             break;
         case k2Dot2Curve_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.f2Dot2Table;
             break;
         case kLinear_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = nullptr;
             break;
         default: {
-            const SkGammas* gammas = as_CSB(space)->gammas();
+            const SkGammas* gammas = space->gammas();
             SkASSERT(gammas);
 
             auto build_table = [=](int i) {
                 if (gammas->isNamed(i)) {
                     switch (gammas->data(i).fNamed) {
                         case kSRGB_SkGammaNamed:
                             (*fns.fBuildFromParam)(&gammaTableStorage[i * gammaTableSize], 2.4f,
                                                    (1.0f / 1.055f), (0.055f / 1.055f), 0.0f,
                                                    0.04045f, (1.0f / 12.92f), 0.0f);
                             outGammaTables[i] = &gammaTableStorage[i * gammaTableSize];
@@ skipping 37 matching lines @@
                 build_table(1);
                 build_table(2);
             }
 
             break;
         }
     }
 }
 
 void SkColorSpaceXform_Base::BuildDstGammaTables(const uint8_t* dstGammaTables[3],
-                                                 uint8_t* dstStorage, const SkColorSpace* space,
+                                                 uint8_t* dstStorage,
+                                                 const SkColorSpace_XYZ* space,
                                                  bool gammasAreMatching) {
     build_gamma_tables(dstGammaTables, dstStorage, kDstGammaTableSize, space, kFromLinear,
                        gammasAreMatching);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline bool is_almost_identity(const SkMatrix44& srcToDst) {
     for (int i = 0; i < 4; i++) {
         for (int j = 0; j < 4; j++) {
             float expected = (i == j) ? 1.0f : 0.0f;
             if (!color_space_almost_equal(srcToDst.getFloat(i,j), expected)) {
                 return false;
             }
         }
     }
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 std::unique_ptr<SkColorSpaceXform> SkColorSpaceXform::New(SkColorSpace* srcSpace,
                                                           SkColorSpace* dstSpace) {
     if (!srcSpace || !dstSpace) {
         // Invalid input
         return nullptr;
     }
 
+    if (SkColorSpace_Base::Type::kA2B == as_CSB(dstSpace)->type()) {
+        SkColorSpacePrintf("A2B destinations not supported\n");
+        return nullptr;
+    }
+
+    if (SkColorSpace_Base::Type::kA2B == as_CSB(srcSpace)->type()) {
+        // TODO (raftias): return an A2B-supporting SkColorSpaceXform here once the xform.
+        // is implemented. SkColorSpaceXform_Base only supports XYZ+TRC based SkColorSpaces
+        //SkColorSpace_A2B* src = static_cast<SkColorSpace_A2B*>(srcSpace);
+        //SkColorSpace_XYZ* dst = static_cast<SkColorSpace_XYZ*>(dstSpace);
+        //return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_A2B(src, dst));
+        SkColorSpacePrintf("A2B sources not supported (yet)\n");
+        return nullptr;
+    }
+    SkColorSpace_XYZ* srcSpaceXYZ = static_cast<SkColorSpace_XYZ*>(srcSpace);
+    SkColorSpace_XYZ* dstSpaceXYZ = static_cast<SkColorSpace_XYZ*>(dstSpace);
+
     ColorSpaceMatch csm = kNone_ColorSpaceMatch;
     SkMatrix44 srcToDst(SkMatrix44::kUninitialized_Constructor);
     if (SkColorSpace::Equals(srcSpace, dstSpace)) {
         srcToDst.setIdentity();
         csm = kFull_ColorSpaceMatch;
     } else {
-        srcToDst.setConcat(as_CSB(dstSpace)->fromXYZD50(), as_CSB(srcSpace)->toXYZD50());
+        srcToDst.setConcat(*dstSpaceXYZ->fromXYZD50(), *srcSpaceXYZ->toXYZD50());
 
         if (is_almost_identity(srcToDst)) {
             srcToDst.setIdentity();
             csm = kGamut_ColorSpaceMatch;
         }
     }
 
     switch (csm) {
         case kNone_ColorSpaceMatch:
-            switch (as_CSB(dstSpace)->gammaNamed()) {
+            switch (dstSpaceXYZ->gammaNamed()) {
                 case kSRGB_SkGammaNamed:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, kSRGB_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, kSRGB_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
                 case k2Dot2Curve_SkGammaNamed:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, k2Dot2_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, k2Dot2_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
                 case kLinear_SkGammaNamed:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, kLinear_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, kLinear_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
                 default:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
             }
         case kGamut_ColorSpaceMatch:
-            switch (as_CSB(dstSpace)->gammaNamed()) {
+            switch (dstSpaceXYZ->gammaNamed()) {
                 case kSRGB_SkGammaNamed:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, kSRGB_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, kSRGB_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
                 case k2Dot2Curve_SkGammaNamed:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, k2Dot2_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, k2Dot2_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
                 case kLinear_SkGammaNamed:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, kLinear_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, kLinear_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
                 default:
-                    if (srcSpace->gammaIsLinear()) {
+                    if (srcSpaceXYZ->gammaIsLinear()) {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kLinear_SrcGamma, kTable_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     } else {
                         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                                 <kTable_SrcGamma, kTable_DstGamma, kGamut_ColorSpaceMatch>
-                                (srcSpace, srcToDst, dstSpace));
+                                (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                     }
             }
         case kFull_ColorSpaceMatch:
-            switch (as_CSB(dstSpace)->gammaNamed()) {
+            switch (dstSpaceXYZ->gammaNamed()) {
                 case kSRGB_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                             <kTable_SrcGamma, kSRGB_DstGamma, kFull_ColorSpaceMatch>
-                            (srcSpace, srcToDst, dstSpace));
+                            (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                 case k2Dot2Curve_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                             <kTable_SrcGamma, k2Dot2_DstGamma, kFull_ColorSpaceMatch>
-                            (srcSpace, srcToDst, dstSpace));
+                            (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                 case kLinear_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                             <kLinear_SrcGamma, kLinear_DstGamma, kFull_ColorSpaceMatch>
-                            (srcSpace, srcToDst, dstSpace));
+                            (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
                 default:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                             <kTable_SrcGamma, kTable_DstGamma, kFull_ColorSpaceMatch>
-                            (srcSpace, srcToDst, dstSpace));
+                            (srcSpaceXYZ, srcToDst, dstSpaceXYZ));
             }
         default:
             SkASSERT(false);
             return nullptr;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-static float byte_to_float(uint8_t byte) {
-    return ((float) byte) * (1.0f / 255.0f);
-}
-
-// Clamp to the 0-1 range.
-static float clamp_normalized_float(float v) {
-    if (v > 1.0f) {
-        return 1.0f;
-    } else if ((v < 0.0f) || (v != v)) {
-        return 0.0f;
-    } else {
-        return v;
-    }
-}
-
-static void interp_3d_clut(float dst[3], float src[3], const SkColorLookUpTable* colorLUT) {
-    // Call the src components x, y, and z.
-    uint8_t maxX = colorLUT->fGridPoints[0] - 1;
-    uint8_t maxY = colorLUT->fGridPoints[1] - 1;
-    uint8_t maxZ = colorLUT->fGridPoints[2] - 1;
-
-    // An approximate index into each of the three dimensions of the table.
-    float x = src[0] * maxX;
-    float y = src[1] * maxY;
-    float z = src[2] * maxZ;
-
-    // This gives us the low index for our interpolation.
-    int ix = sk_float_floor2int(x);
-    int iy = sk_float_floor2int(y);
-    int iz = sk_float_floor2int(z);
-
-    // Make sure the low index is not also the max index.
-    ix = (maxX == ix) ? ix - 1 : ix;
-    iy = (maxY == iy) ? iy - 1 : iy;
-    iz = (maxZ == iz) ? iz - 1 : iz;
-
-    // Weighting factors for the interpolation.
-    float diffX = x - ix;
-    float diffY = y - iy;
-    float diffZ = z - iz;
-
-    // Constants to help us navigate the 3D table.
-    // Ex: Assume x = a, y = b, z = c.
-    //     table[a * n001 + b * n010 + c * n100] logically equals table[a][b][c].
-    const int n000 = 0;
-    const int n001 = 3 * colorLUT->fGridPoints[1] * colorLUT->fGridPoints[2];
-    const int n010 = 3 * colorLUT->fGridPoints[2];
-    const int n011 = n001 + n010;
-    const int n100 = 3;
-    const int n101 = n100 + n001;
-    const int n110 = n100 + n010;
-    const int n111 = n110 + n001;
-
-    // Base ptr into the table.
-    const float* ptr = &(colorLUT->table()[ix*n001 + iy*n010 + iz*n100]);
-
-    // The code below performs a tetrahedral interpolation for each of the three
-    // dst components.  Once the tetrahedron containing the interpolation point is
-    // identified, the interpolation is a weighted sum of grid values at the
-    // vertices of the tetrahedron.  The claim is that tetrahedral interpolation
-    // provides a more accurate color conversion.
-    // blogs.mathworks.com/steve/2006/11/24/tetrahedral-interpolation-for-colorspace-conversion/
-    //
-    // I have one test image, and visually I can't tell the difference between
-    // tetrahedral and trilinear interpolation.  In terms of computation, the
-    // tetrahedral code requires more branches but less computation.  The
-    // SampleICC library provides an option for the client to choose either
-    // tetrahedral or trilinear.
-    for (int i = 0; i < 3; i++) {
-        if (diffZ < diffY) {
-            if (diffZ < diffX) {
-                dst[i] = (ptr[n000] + diffZ * (ptr[n110] - ptr[n010]) +
-                                      diffY * (ptr[n010] - ptr[n000]) +
-                                      diffX * (ptr[n111] - ptr[n110]));
-            } else if (diffY < diffX) {
-                dst[i] = (ptr[n000] + diffZ * (ptr[n111] - ptr[n011]) +
-                                      diffY * (ptr[n011] - ptr[n001]) +
-                                      diffX * (ptr[n001] - ptr[n000]));
-            } else {
-                dst[i] = (ptr[n000] + diffZ * (ptr[n111] - ptr[n011]) +
-                                      diffY * (ptr[n010] - ptr[n000]) +
-                                      diffX * (ptr[n011] - ptr[n010]));
-            }
-        } else {
-            if (diffZ < diffX) {
-                dst[i] = (ptr[n000] + diffZ * (ptr[n101] - ptr[n001]) +
-                                      diffY * (ptr[n111] - ptr[n101]) +
-                                      diffX * (ptr[n001] - ptr[n000]));
-            } else if (diffY < diffX) {
-                dst[i] = (ptr[n000] + diffZ * (ptr[n100] - ptr[n000]) +
-                                      diffY * (ptr[n111] - ptr[n101]) +
-                                      diffX * (ptr[n101] - ptr[n100]));
-            } else {
-                dst[i] = (ptr[n000] + diffZ * (ptr[n100] - ptr[n000]) +
-                                      diffY * (ptr[n110] - ptr[n100]) +
-                                      diffX * (ptr[n111] - ptr[n110]));
-            }
-        }
-
-        // Increment the table ptr in order to handle the next component.
-        // Note that this is the how table is designed: all of nXXX
-        // variables are multiples of 3 because there are 3 output
-        // components.
-        ptr++;
-    }
-}
-
-static void handle_color_lut(uint32_t* dst, const void* vsrc, int len,
-                             SkColorLookUpTable* colorLUT) {
-    const uint32_t* src = (const uint32_t*) vsrc;
-    while (len-- > 0) {
-        uint8_t r = (*src >>  0) & 0xFF,
-                g = (*src >>  8) & 0xFF,
-                b = (*src >> 16) & 0xFF;
-
-        float in[3];
-        float out[3];
-        in[0] = byte_to_float(r);
-        in[1] = byte_to_float(g);
-        in[2] = byte_to_float(b);
-        interp_3d_clut(out, in, colorLUT);
-
-        r = sk_float_round2int(255.0f * clamp_normalized_float(out[0]));
-        g = sk_float_round2int(255.0f * clamp_normalized_float(out[1]));
-        b = sk_float_round2int(255.0f * clamp_normalized_float(out[2]));
-        *dst = SkPackARGB_as_RGBA(0xFF, r, g, b);
-
-        src++;
-        dst++;
-    }
-}
-
 static inline void load_matrix(const float matrix[16],
                                Sk4f& rXgXbX, Sk4f& rYgYbY, Sk4f& rZgZbZ, Sk4f& rTgTbT) {
     rXgXbX = Sk4f::Load(matrix +  0);
     rYgYbY = Sk4f::Load(matrix +  4);
     rZgZbZ = Sk4f::Load(matrix +  8);
     rTgTbT = Sk4f::Load(matrix + 12);
 }
 
 enum Order {
     kRGBA_Order,
@@ skipping 591 matching lines @@
         store_1(dst, src, rgba, a, dstTables);
 
         src += 1;
         len -= 1;
         dst = SkTAddOffset<void>(dst, sizeOfDstPixel);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-static inline int num_tables(SkColorSpace* space) {
-    switch (as_CSB(space)->gammaNamed()) {
+static inline int num_tables(SkColorSpace_XYZ* space) {
+    switch (space->gammaNamed()) {
         case kSRGB_SkGammaNamed:
         case k2Dot2Curve_SkGammaNamed:
         case kLinear_SkGammaNamed:
             return 0;
         default: {
-            const SkGammas* gammas = as_CSB(space)->gammas();
+            const SkGammas* gammas = space->gammas();
             SkASSERT(gammas);
 
             bool gammasAreMatching = (gammas->type(0) == gammas->type(1)) &&
                                      (gammas->data(0) == gammas->data(1)) &&
                                      (gammas->type(0) == gammas->type(2)) &&
                                      (gammas->data(0) == gammas->data(2));
 
             // It's likely that each component will have the same gamma.  In this case,
             // we only need to build one table.
             return gammasAreMatching ? 1 : 3;
         }
     }
 }
 
 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM>
 SkColorSpaceXform_XYZ<kSrc, kDst, kCSM>
-::SkColorSpaceXform_XYZ(SkColorSpace* srcSpace, const SkMatrix44& srcToDst, SkColorSpace* dstSpace)
-    : fColorLUT(sk_ref_sp((SkColorLookUpTable*) as_CSB(srcSpace)->colorLUT()))
+::SkColorSpaceXform_XYZ(SkColorSpace_XYZ* srcSpace, const SkMatrix44& srcToDst,
+                        SkColorSpace_XYZ* dstSpace)
 {
     srcToDst.asColMajorf(fSrcToDst);
 
     const int numSrcTables = num_tables(srcSpace);
     const size_t srcEntries = numSrcTables * 256;
     const bool srcGammasAreMatching = (1 >= numSrcTables);
     fSrcStorage.reset(srcEntries);
     build_gamma_tables(fSrcGammaTables, fSrcStorage.get(), 256, srcSpace, kToLinear,
                        srcGammasAreMatching);
 
     const int numDstTables = num_tables(dstSpace);
-    as_CSB(dstSpace)->toDstGammaTables(fDstGammaTables, &fDstStorage, numDstTables);
+    dstSpace->toDstGammaTables(fDstGammaTables, &fDstStorage, numDstTables);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 template <SrcFormat kSrc, DstFormat kDst, ColorSpaceMatch kCSM>
 static inline bool apply_set_alpha(void* dst, const void* src, int len, SkAlphaType alphaType,
                                    const float* const srcTables[3], const float matrix[16],
                                    const uint8_t* const dstTables[3]) {
     switch (alphaType) {
         case kOpaque_SkAlphaType:
@@ skipping 64 matching lines @@
                     case kRGBA_F16_ColorFormat:
                     case kRGBA_F32_ColorFormat:
                         // There's still work to do to xform to linear floats.
                         break;
                     default:
                         return false;
                 }
         }
     }
 
-#if defined(GOOGLE3)
-    // Stack frame size is limited in GOOGLE3.
-    SkAutoSMalloc<256 * sizeof(uint32_t)> storage;
-#else
-    SkAutoSMalloc<1024 * sizeof(uint32_t)> storage;
-#endif
-    if (fColorLUT) {
-        size_t storageBytes = len * sizeof(uint32_t);
-        storage.reset(storageBytes);
-        handle_color_lut((uint32_t*) storage.get(), src, len, fColorLUT.get());
-        src = (const uint32_t*) storage.get();
-    }
-
     switch (dstColorFormat) {
         case kRGBA_8888_ColorFormat:
             switch (kDst) {
                 case kLinear_DstGamma:
                     return apply_set_src<kSrc, kRGBA_8888_Linear_DstFormat, kCSM>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
                              srcColorFormat);
                 case kSRGB_DstGamma:
                     return apply_set_src<kSrc, kRGBA_8888_SRGB_DstFormat, kCSM>
                             (dst, src, len, alphaType, fSrcGammaTables, fSrcToDst, nullptr,
@@ skipping 50 matching lines @@
 }
 
 bool SkColorSpaceXform::apply(ColorFormat dstColorFormat, void* dst, ColorFormat srcColorFormat,
                               const void* src, int len, SkAlphaType alphaType) const {
     return ((SkColorSpaceXform_Base*) this)->onApply(dstColorFormat, dst, srcColorFormat, src, len,
                                                      alphaType);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(SkColorSpace* space) {
+std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(SkColorSpace_XYZ* space) {
         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ
                 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch>
                 (space, SkMatrix::I(), space));
 }