Revert "Add SkColorSpace factory from 3x3 row-major gamut and transfer function"

This reverts commit a9549ab31630fc244094e6f1692371cbaf87f666.

Reason for revert: SKPs changed?

Original change's description:
> Add SkColorSpace factory from 3x3 row-major gamut and transfer function
> 
> Moved named common transfer functions and gamuts to constexpr values in
> SkColorSpace.h, in SkNamedTransferFn and SkNamedGamut namespaces.
> 
> Converted nearly all SkColorSpace::MakeRGB calls within Skia to use the
> new factory with the named values. Multiple clients want a way to
> extract named transfer function and gamut - this still doesn't provide
> that, but this may be a better path forward for honestly advertising how
> SkColorSpace works internally.
> 
> Bug: skia:
> Change-Id: I9296d67e8f0dab5ceb49869cb3ba24e98a05f3c4
> Reviewed-on: https://skia-review.googlesource.com/c/180360
> Reviewed-by: Mike Klein <mtklein@google.com>
> Reviewed-by: Brian Osman <brianosman@google.com>
> Commit-Queue: Brian Osman <brianosman@google.com>

TBR=mtklein@google.com,brianosman@google.com,reed@google.com

Change-Id: Ie888f877b3c1dba33e1a8c0f5fa92594628de7fb
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/c/181300
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>
diff --git a/src/codec/SkAndroidCodec.cpp b/src/codec/SkAndroidCodec.cpp
index d741d6d..581640f 100644
--- a/src/codec/SkAndroidCodec.cpp
+++ b/src/codec/SkAndroidCodec.cpp
@@ -164,8 +164,9 @@
     switch (outputColorType) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType: {
-            // If |prefColorSpace| is supplied, choose it.
-            if (prefColorSpace) {
+            // If |prefColorSpace| is supported, choose it.
+            SkColorSpaceTransferFn fn;
+            if (prefColorSpace && prefColorSpace->isNumericalTransferFn(&fn)) {
                 return prefColorSpace;
             }
 
@@ -178,7 +179,8 @@
                 }
 
                 if (is_wide_gamut(*encodedProfile)) {
-                    return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDCIP3);
+                    return SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
+                                                 SkColorSpace::kDCIP3_D65_Gamut);
                 }
             }
 
diff --git a/src/codec/SkRawCodec.cpp b/src/codec/SkRawCodec.cpp
index a8ec40b..fb7efb9 100644
--- a/src/codec/SkRawCodec.cpp
+++ b/src/codec/SkRawCodec.cpp
@@ -612,6 +612,17 @@
     bool fIsXtransImage;
 };
 
+static constexpr skcms_Matrix3x3 gAdobe_RGB_to_XYZD50 = {{
+    // ICC fixed-point (16.16) repesentation of:
+    // 0.60974, 0.20528, 0.14919,
+    // 0.31111, 0.62567, 0.06322,
+    // 0.01947, 0.06087, 0.74457,
+    { SkFixedToFloat(0x9c18), SkFixedToFloat(0x348d), SkFixedToFloat(0x2631) }, // Rx, Gx, Bx
+    { SkFixedToFloat(0x4fa5), SkFixedToFloat(0xa02c), SkFixedToFloat(0x102f) }, // Ry, Gy, By
+    { SkFixedToFloat(0x04fc), SkFixedToFloat(0x0f95), SkFixedToFloat(0xbe9c) }, // Rz, Gz, Bz
+}};
+
+
 /*
  * Tries to handle the image with PIEX. If PIEX returns kOk and finds the preview image, create a
  * SkJpegCodec. If PIEX returns kFail, then the file is invalid, return nullptr. In other cases,
@@ -638,10 +649,12 @@
 
         std::unique_ptr<SkEncodedInfo::ICCProfile> profile;
         if (imageData.color_space == ::piex::PreviewImageData::kAdobeRgb) {
+            constexpr skcms_TransferFunction twoDotTwo =
+                    { 2.2f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
             skcms_ICCProfile skcmsProfile;
             skcms_Init(&skcmsProfile);
-            skcms_SetTransferFunction(&skcmsProfile, &SkNamedTransferFn::k2Dot2);
-            skcms_SetXYZD50(&skcmsProfile, &SkNamedGamut::kAdobeRGB);
+            skcms_SetTransferFunction(&skcmsProfile, &twoDotTwo);
+            skcms_SetXYZD50(&skcmsProfile, &gAdobe_RGB_to_XYZD50);
             profile = SkEncodedInfo::ICCProfile::Make(skcmsProfile);
         }
 
diff --git a/src/core/SkColorSpace.cpp b/src/core/SkColorSpace.cpp
index 1471095..66ddaf4 100644
--- a/src/core/SkColorSpace.cpp
+++ b/src/core/SkColorSpace.cpp
@@ -20,10 +20,6 @@
     return true;
 }
 
-bool SkColorSpacePrimaries::toXYZD50(skcms_Matrix3x3* toXYZ_D50) const {
-    return skcms_PrimariesToXYZD50(fRX, fRY, fGX, fGY, fBX, fBY, fWX, fWY, toXYZ_D50);
-}
-
 static bool is_3x3(const SkMatrix44& m44) {
     return m44.getFloat(0, 3) == 0.0f
         && m44.getFloat(1, 3) == 0.0f
@@ -61,9 +57,9 @@
     fToXYZD50Hash = SkOpts::hash_fn(fToXYZD50_3x3, 9*sizeof(float), 0);
 
     switch (fGammaNamed) {
-        case kSRGB_SkGammaNamed:        transferFn = &  SkNamedTransferFn::kSRGB.g; break;
-        case k2Dot2Curve_SkGammaNamed:  transferFn = & SkNamedTransferFn::k2Dot2.g; break;
-        case kLinear_SkGammaNamed:      transferFn = &SkNamedTransferFn::kLinear.g; break;
+        case kSRGB_SkGammaNamed:        transferFn = &  gSRGB_TransferFn.fG; break;
+        case k2Dot2Curve_SkGammaNamed:  transferFn = & g2Dot2_TransferFn.fG; break;
+        case kLinear_SkGammaNamed:      transferFn = &gLinear_TransferFn.fG; break;
         case kNonStandard_SkGammaNamed:                                      break;
     }
     memcpy(fTransferFn, transferFn, 7*sizeof(float));
@@ -77,12 +73,12 @@
     }
     switch (gammaNamed) {
         case kSRGB_SkGammaNamed:
-            if (xyz_almost_equal(toXYZD50, &SkNamedGamut::kSRGB.vals[0][0])) {
+            if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
                 return SkColorSpace::MakeSRGB();
             }
             break;
         case kLinear_SkGammaNamed:
-            if (xyz_almost_equal(toXYZD50, &SkNamedGamut::kSRGB.vals[0][0])) {
+            if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
                 return SkColorSpace::MakeSRGBLinear();
             }
             break;
@@ -140,16 +136,6 @@
     return SkColorSpace::MakeRGB(coeffs, toXYZD50);
 }
 
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const skcms_TransferFunction& transferFn,
-                                          const skcms_Matrix3x3& toXYZ) {
-    SkMatrix44 toXYZD50;
-    toXYZD50.set3x3RowMajorf(&toXYZ.vals[0][0]);
-    SkColorSpaceTransferFn tf;
-    memcpy(&tf, &transferFn, sizeof(tf));
-    // Going through this old path makes sure we classify transferFn as an SkGammaNamed
-    return SkColorSpace::MakeRGB(tf, toXYZD50);
-}
-
 class SkColorSpaceSingletonFactory {
 public:
     static SkColorSpace* Make(SkGammaNamed gamma, const float to_xyz[9]) {
@@ -162,12 +148,12 @@
 
 SkColorSpace* sk_srgb_singleton() {
     static SkColorSpace* cs = SkColorSpaceSingletonFactory::Make(kSRGB_SkGammaNamed,
-                                                                 &SkNamedGamut::kSRGB.vals[0][0]);
+                                                                 gSRGB_toXYZD50);
     return cs;
 }
 SkColorSpace* sk_srgb_linear_singleton() {
     static SkColorSpace* cs = SkColorSpaceSingletonFactory::Make(kLinear_SkGammaNamed,
-                                                                 &SkNamedGamut::kSRGB.vals[0][0]);
+                                                                 gSRGB_toXYZD50);
     return cs;
 }
 
@@ -210,11 +196,6 @@
     return true;
 }
 
-bool SkColorSpace::isNumericalTransferFn(skcms_TransferFunction* coeffs) const {
-    this->transferFn(&coeffs->g);
-    return true;
-}
-
 void SkColorSpace::transferFn(float gabcdef[7]) const {
     memcpy(gabcdef, &fTransferFn, 7*sizeof(float));
 }
@@ -229,10 +210,6 @@
     return true;
 }
 
-bool SkColorSpace::toXYZD50(skcms_Matrix3x3* toXYZD50) const {
-    memcpy(toXYZD50, fToXYZD50_3x3, 9*sizeof(float));
-    return true;
-}
 
 void SkColorSpace::gamutTransformTo(const SkColorSpace* dst, float src_to_dst[9]) const {
     dst->computeLazyDstFields();
@@ -336,53 +313,201 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 enum Version {
-    k0_Version, // Initial version, now deprecated
-    k1_Version, // Simple header (version tag) + 16 floats
+    k0_Version, // Initial version, header + flags for matrix and profile
+};
 
-    kCurrent_Version = k1_Version,
+enum NamedColorSpace {
+    kSRGB_NamedColorSpace,
+    // No longer a singleton, preserved to support reading data from branches m65 and older
+    kAdobeRGB_NamedColorSpace,
+    kSRGBLinear_NamedColorSpace,
 };
 
 struct ColorSpaceHeader {
-    uint8_t fVersion = kCurrent_Version;
+    /**
+     *  It is only valid to set zero or one flags.
+     *  Setting multiple flags is invalid.
+     */
+
+    /**
+     *  If kMatrix_Flag is set, we will write 12 floats after the header.
+     */
+    static constexpr uint8_t kMatrix_Flag     = 1 << 0;
+
+    /**
+     *  If kICC_Flag is set, we will write an ICC profile after the header.
+     *  The ICC profile will be written as a uint32 size, followed immediately
+     *  by the data (padded to 4 bytes).
+     *  DEPRECATED / UNUSED
+     */
+    static constexpr uint8_t kICC_Flag        = 1 << 1;
+
+    /**
+     *  If kTransferFn_Flag is set, we will write 19 floats after the header.
+     *  The first seven represent the transfer fn, and the next twelve are the
+     *  matrix.
+     */
+    static constexpr uint8_t kTransferFn_Flag = 1 << 3;
+
+    static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed, uint8_t flags)
+    {
+        ColorSpaceHeader header;
+
+        SkASSERT(k0_Version == version);
+        header.fVersion = (uint8_t) version;
+
+        SkASSERT(named <= kSRGBLinear_NamedColorSpace);
+        header.fNamed = (uint8_t) named;
+
+        SkASSERT(gammaNamed <= kNonStandard_SkGammaNamed);
+        header.fGammaNamed = (uint8_t) gammaNamed;
+
+        SkASSERT(flags <= kTransferFn_Flag);
+        header.fFlags = flags;
+        return header;
+    }
+
+    uint8_t fVersion;            // Always zero
+    uint8_t fNamed;              // Must be a SkColorSpace::Named
+    uint8_t fGammaNamed;         // Must be a SkGammaNamed
+    uint8_t fFlags;
 };
 
 size_t SkColorSpace::writeToMemory(void* memory) const {
-    if (memory) {
-        *((ColorSpaceHeader*)memory) = ColorSpaceHeader();
-        memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
-
-        memcpy(memory, fTransferFn, 7 * sizeof(float));
-        memory = SkTAddOffset<void>(memory, 7 * sizeof(float));
-
-        memcpy(memory, fToXYZD50_3x3, 9 * sizeof(float));
+    // If we have a named profile, only write the enum.
+    const SkGammaNamed gammaNamed = this->gammaNamed();
+    if (this == sk_srgb_singleton()) {
+        if (memory) {
+            *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
+                    k0_Version, kSRGB_NamedColorSpace, gammaNamed, 0);
+        }
+        return sizeof(ColorSpaceHeader);
+    } else if (this == sk_srgb_linear_singleton()) {
+        if (memory) {
+            *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
+                    k0_Version, kSRGBLinear_NamedColorSpace, gammaNamed, 0);
+        }
+        return sizeof(ColorSpaceHeader);
     }
-    return sizeof(ColorSpaceHeader) + 16 * sizeof(float);
+
+    // If we have a named gamma, write the enum and the matrix.
+    switch (gammaNamed) {
+        case kSRGB_SkGammaNamed:
+        case k2Dot2Curve_SkGammaNamed:
+        case kLinear_SkGammaNamed: {
+            if (memory) {
+                *((ColorSpaceHeader*) memory) =
+                        ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
+                                                ColorSpaceHeader::kMatrix_Flag);
+                memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+                SkMatrix44 m44;
+                this->toXYZD50(&m44);
+                m44.as3x4RowMajorf((float*) memory);
+            }
+            return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
+        }
+        default: {
+            SkColorSpaceTransferFn transferFn;
+            SkAssertResult(this->isNumericalTransferFn(&transferFn));
+
+            if (memory) {
+                *((ColorSpaceHeader*) memory) =
+                        ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
+                                                ColorSpaceHeader::kTransferFn_Flag);
+                memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+
+                *(((float*) memory) + 0) = transferFn.fA;
+                *(((float*) memory) + 1) = transferFn.fB;
+                *(((float*) memory) + 2) = transferFn.fC;
+                *(((float*) memory) + 3) = transferFn.fD;
+                *(((float*) memory) + 4) = transferFn.fE;
+                *(((float*) memory) + 5) = transferFn.fF;
+                *(((float*) memory) + 6) = transferFn.fG;
+                memory = SkTAddOffset<void>(memory, 7 * sizeof(float));
+
+                SkMatrix44 m44;
+                this->toXYZD50(&m44);
+                m44.as3x4RowMajorf((float*) memory);
+            }
+
+            return sizeof(ColorSpaceHeader) + 19 * sizeof(float);
+        }
+    }
 }
 
 sk_sp<SkData> SkColorSpace::serialize() const {
-    sk_sp<SkData> data = SkData::MakeUninitialized(this->writeToMemory(nullptr));
+    size_t size = this->writeToMemory(nullptr);
+    if (0 == size) {
+        return nullptr;
+    }
+
+    sk_sp<SkData> data = SkData::MakeUninitialized(size);
     this->writeToMemory(data->writable_data());
     return data;
 }
 
 sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
-    if (length < sizeof(ColorSpaceHeader) + 16 * sizeof(float)) {
+    if (length < sizeof(ColorSpaceHeader)) {
         return nullptr;
     }
 
     ColorSpaceHeader header = *((const ColorSpaceHeader*) data);
     data = SkTAddOffset<const void>(data, sizeof(ColorSpaceHeader));
-    if (header.fVersion != kCurrent_Version) {
-        return nullptr;
+    length -= sizeof(ColorSpaceHeader);
+    if (0 == header.fFlags) {
+        switch ((NamedColorSpace)header.fNamed) {
+            case kSRGB_NamedColorSpace:
+                return SkColorSpace::MakeSRGB();
+            case kSRGBLinear_NamedColorSpace:
+                return SkColorSpace::MakeSRGBLinear();
+            case kAdobeRGB_NamedColorSpace:
+                return SkColorSpace::MakeRGB(g2Dot2_TransferFn, SkColorSpace::kAdobeRGB_Gamut);
+        }
     }
 
-    skcms_TransferFunction transferFn;
-    memcpy(&transferFn, data, 7 * sizeof(float));
-    data = SkTAddOffset<const void>(data, 7 * sizeof(float));
+    switch ((SkGammaNamed) header.fGammaNamed) {
+        case kSRGB_SkGammaNamed:
+        case k2Dot2Curve_SkGammaNamed:
+        case kLinear_SkGammaNamed: {
+            if (ColorSpaceHeader::kMatrix_Flag != header.fFlags || length < 12 * sizeof(float)) {
+                return nullptr;
+            }
 
-    skcms_Matrix3x3 toXYZ;
-    memcpy(&toXYZ, data, 9*sizeof(float));
-    return SkColorSpace::MakeRGB(transferFn, toXYZ);
+            SkMatrix44 toXYZ;
+            toXYZ.set3x4RowMajorf((const float*) data);
+            return SkColorSpace::MakeRGB((SkGammaNamed) header.fGammaNamed, toXYZ);
+        }
+        default:
+            break;
+    }
+
+    switch (header.fFlags) {
+        case ColorSpaceHeader::kICC_Flag: {
+            // Deprecated and unsupported code path
+            return nullptr;
+        }
+        case ColorSpaceHeader::kTransferFn_Flag: {
+            if (length < 19 * sizeof(float)) {
+                return nullptr;
+            }
+
+            SkColorSpaceTransferFn transferFn;
+            transferFn.fA = *(((const float*) data) + 0);
+            transferFn.fB = *(((const float*) data) + 1);
+            transferFn.fC = *(((const float*) data) + 2);
+            transferFn.fD = *(((const float*) data) + 3);
+            transferFn.fE = *(((const float*) data) + 4);
+            transferFn.fF = *(((const float*) data) + 5);
+            transferFn.fG = *(((const float*) data) + 6);
+            data = SkTAddOffset<const void>(data, 7 * sizeof(float));
+
+            SkMatrix44 toXYZ;
+            toXYZ.set3x4RowMajorf((const float*) data);
+            return SkColorSpace::MakeRGB(transferFn, toXYZ);
+        }
+        default:
+            return nullptr;
+    }
 }
 
 bool SkColorSpace::Equals(const SkColorSpace* x, const SkColorSpace* y) {
diff --git a/src/core/SkColorSpacePriv.h b/src/core/SkColorSpacePriv.h
index 298b932..4d93d59 100644
--- a/src/core/SkColorSpacePriv.h
+++ b/src/core/SkColorSpacePriv.h
@@ -14,26 +14,70 @@
 
 #define SkColorSpacePrintf(...)
 
+static constexpr float gSRGB_toXYZD50[] {
+    // These are taken from skcms, and there originally from 16-bit fixed point.
+    // For best results, please keep them exactly in sync with skcms.
+    0.436065674f, 0.385147095f, 0.143066406f,
+    0.222488403f, 0.716873169f, 0.060607910f,
+    0.013916016f, 0.097076416f, 0.714096069f,
+};
+
+static constexpr float gAdobeRGB_toXYZD50[] {
+    // ICC fixed-point (16.16) repesentation of:
+    // 0.60974, 0.20528, 0.14919,
+    // 0.31111, 0.62567, 0.06322,
+    // 0.01947, 0.06087, 0.74457,
+    SkFixedToFloat(0x9c18), SkFixedToFloat(0x348d), SkFixedToFloat(0x2631), // Rx, Gx, Bx
+    SkFixedToFloat(0x4fa5), SkFixedToFloat(0xa02c), SkFixedToFloat(0x102f), // Ry, Gy, By
+    SkFixedToFloat(0x04fc), SkFixedToFloat(0x0f95), SkFixedToFloat(0xbe9c), // Rz, Gz, Bz
+};
+
+static constexpr float gDCIP3_toXYZD50[] {
+    0.515102f,   0.291965f,  0.157153f,  // Rx, Gx, Bx
+    0.241182f,   0.692236f,  0.0665819f, // Ry, Gy, By
+   -0.00104941f, 0.0418818f, 0.784378f,  // Rz, Gz, Bz
+};
+
+static constexpr float gRec2020_toXYZD50[] {
+    0.673459f,   0.165661f,  0.125100f,  // Rx, Gx, Bx
+    0.279033f,   0.675338f,  0.0456288f, // Ry, Gy, By
+   -0.00193139f, 0.0299794f, 0.797162f,  // Rz, Gz, Bz
+};
+
 // A gamut narrower than sRGB, useful for testing.
-static constexpr skcms_Matrix3x3 gNarrow_toXYZD50 = {{
-    { 0.190974f,  0.404865f,  0.368380f },
-    { 0.114746f,  0.582937f,  0.302318f },
-    { 0.032925f,  0.153615f,  0.638669f },
-}};
+static constexpr float gNarrow_toXYZD50[] {
+    0.190974f,  0.404865f,  0.368380f,
+    0.114746f,  0.582937f,  0.302318f,
+    0.032925f,  0.153615f,  0.638669f,
+};
+
+// Like gSRGB_toXYZD50, keeping this bitwise exactly the same as skcms makes things fastest.
+static constexpr SkColorSpaceTransferFn gSRGB_TransferFn =
+#ifdef SK_LEGACY_SRGB_TRANSFER_FUNCTION
+        { 2.4f, 1.0f / 1.055f, 0.055f / 1.055f, 1.0f / 12.92f, 0.04045f, 0.0f, 0.0f };
+#else
+        { 2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0.0f, 0.0f };
+#endif
+
+static constexpr SkColorSpaceTransferFn g2Dot2_TransferFn =
+        { 2.2f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+
+static constexpr SkColorSpaceTransferFn gLinear_TransferFn =
+        { 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
 
 static inline void to_xyz_d50(SkMatrix44* toXYZD50, SkColorSpace::Gamut gamut) {
     switch (gamut) {
         case SkColorSpace::kSRGB_Gamut:
-            toXYZD50->set3x3RowMajorf(&SkNamedGamut::kSRGB.vals[0][0]);
+            toXYZD50->set3x3RowMajorf(gSRGB_toXYZD50);
             break;
         case SkColorSpace::kAdobeRGB_Gamut:
-            toXYZD50->set3x3RowMajorf(&SkNamedGamut::kAdobeRGB.vals[0][0]);
+            toXYZD50->set3x3RowMajorf(gAdobeRGB_toXYZD50);
             break;
         case SkColorSpace::kDCIP3_D65_Gamut:
-            toXYZD50->set3x3RowMajorf(&SkNamedGamut::kDCIP3.vals[0][0]);
+            toXYZD50->set3x3RowMajorf(gDCIP3_toXYZD50);
             break;
         case SkColorSpace::kRec2020_Gamut:
-            toXYZD50->set3x3RowMajorf(&SkNamedGamut::kRec2020.vals[0][0]);
+            toXYZD50->set3x3RowMajorf(gRec2020_toXYZD50);
             break;
     }
 }
@@ -105,13 +149,13 @@
 }
 
 static inline bool is_almost_srgb(const SkColorSpaceTransferFn& coeffs) {
-    return transfer_fn_almost_equal(SkNamedTransferFn::kSRGB.a, coeffs.fA) &&
-           transfer_fn_almost_equal(SkNamedTransferFn::kSRGB.b, coeffs.fB) &&
-           transfer_fn_almost_equal(SkNamedTransferFn::kSRGB.c, coeffs.fC) &&
-           transfer_fn_almost_equal(SkNamedTransferFn::kSRGB.d, coeffs.fD) &&
-           transfer_fn_almost_equal(SkNamedTransferFn::kSRGB.e, coeffs.fE) &&
-           transfer_fn_almost_equal(SkNamedTransferFn::kSRGB.f, coeffs.fF) &&
-           transfer_fn_almost_equal(SkNamedTransferFn::kSRGB.g, coeffs.fG);
+    return transfer_fn_almost_equal(gSRGB_TransferFn.fA, coeffs.fA) &&
+           transfer_fn_almost_equal(gSRGB_TransferFn.fB, coeffs.fB) &&
+           transfer_fn_almost_equal(gSRGB_TransferFn.fC, coeffs.fC) &&
+           transfer_fn_almost_equal(gSRGB_TransferFn.fD, coeffs.fD) &&
+           transfer_fn_almost_equal(gSRGB_TransferFn.fE, coeffs.fE) &&
+           transfer_fn_almost_equal(gSRGB_TransferFn.fF, coeffs.fF) &&
+           transfer_fn_almost_equal(gSRGB_TransferFn.fG, coeffs.fG);
 }
 
 static inline bool is_almost_2dot2(const SkColorSpaceTransferFn& coeffs) {
diff --git a/src/core/SkColorSpaceXformSteps.cpp b/src/core/SkColorSpaceXformSteps.cpp
index 5fff910..a2f73fc 100644
--- a/src/core/SkColorSpaceXformSteps.cpp
+++ b/src/core/SkColorSpaceXformSteps.cpp
@@ -53,10 +53,10 @@
         this->src_to_dst_matrix[8] = row_major[8];
     } else {
     #ifdef SK_DEBUG
-        skcms_Matrix3x3 srcM, dstM;
+        SkMatrix44 srcM, dstM;
         src->toXYZD50(&srcM);
         dst->toXYZD50(&dstM);
-        SkASSERT(0 == memcmp(&srcM, &dstM, 9*sizeof(float)) && "Hash collision");
+        SkASSERT(0 == memcmp(&srcM, &dstM, 16*sizeof(SkMScalar)) && "Hash collision");
     #endif
     }
 
diff --git a/src/core/SkICC.cpp b/src/core/SkICC.cpp
index d1db49e..a9df5b0 100644
--- a/src/core/SkICC.cpp
+++ b/src/core/SkICC.cpp
@@ -206,14 +206,14 @@
 }
 
 static bool nearly_equal(const SkColorSpaceTransferFn& u,
-                         const skcms_TransferFunction& v) {
-    return nearly_equal(u.fG, v.g)
-        && nearly_equal(u.fA, v.a)
-        && nearly_equal(u.fB, v.b)
-        && nearly_equal(u.fC, v.c)
-        && nearly_equal(u.fD, v.d)
-        && nearly_equal(u.fE, v.e)
-        && nearly_equal(u.fF, v.f);
+                         const SkColorSpaceTransferFn& v) {
+    return nearly_equal(u.fG, v.fG)
+        && nearly_equal(u.fA, v.fA)
+        && nearly_equal(u.fB, v.fB)
+        && nearly_equal(u.fC, v.fC)
+        && nearly_equal(u.fD, v.fD)
+        && nearly_equal(u.fE, v.fE)
+        && nearly_equal(u.fF, v.fF);
 }
 
 static bool nearly_equal(const float u[9], const float v[9]) {
@@ -228,23 +228,23 @@
 // Return nullptr if the color profile doen't have a special name.
 const char* get_color_profile_description(const SkColorSpaceTransferFn& fn,
                                           const float toXYZD50[9]) {
-    bool srgb_xfer = nearly_equal(fn, SkNamedTransferFn::kSRGB);
-    bool srgb_gamut = nearly_equal(toXYZD50, &SkNamedGamut::kSRGB.vals[0][0]);
+    bool srgb_xfer = nearly_equal(fn, gSRGB_TransferFn);
+    bool srgb_gamut = nearly_equal(toXYZD50, gSRGB_toXYZD50);
     if (srgb_xfer && srgb_gamut) {
         return "sRGB";
     }
-    bool line_xfer = nearly_equal(fn, SkNamedTransferFn::kLinear);
+    bool line_xfer = nearly_equal(fn, gLinear_TransferFn);
     if (line_xfer && srgb_gamut) {
         return "Linear Transfer with sRGB Gamut";
     }
-    bool twoDotTwo = nearly_equal(fn, SkNamedTransferFn::k2Dot2);
+    bool twoDotTwo = nearly_equal(fn, g2Dot2_TransferFn);
     if (twoDotTwo && srgb_gamut) {
         return "2.2 Transfer with sRGB Gamut";
     }
-    if (twoDotTwo && nearly_equal(toXYZD50, &SkNamedGamut::kAdobeRGB.vals[0][0])) {
+    if (twoDotTwo && nearly_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
         return "AdobeRGB";
     }
-    bool dcip3_gamut = nearly_equal(toXYZD50, &SkNamedGamut::kDCIP3.vals[0][0]);
+    bool dcip3_gamut = nearly_equal(toXYZD50, gDCIP3_toXYZD50);
     if (srgb_xfer || line_xfer) {
         if (srgb_xfer && dcip3_gamut) {
             return "sRGB Transfer with DCI-P3 Gamut";
@@ -252,7 +252,7 @@
         if (line_xfer && dcip3_gamut) {
             return "Linear Transfer with DCI-P3 Gamut";
         }
-        bool rec2020 = nearly_equal(toXYZD50, &SkNamedGamut::kRec2020.vals[0][0]);
+        bool rec2020 = nearly_equal(toXYZD50, gRec2020_toXYZD50);
         if (srgb_xfer && rec2020) {
             return "sRGB Transfer with Rec-BT-2020 Gamut";
         }
diff --git a/src/gpu/GrColorSpaceXform.cpp b/src/gpu/GrColorSpaceXform.cpp
index 2cd5e5a..e8cb662 100644
--- a/src/gpu/GrColorSpaceXform.cpp
+++ b/src/gpu/GrColorSpaceXform.cpp
@@ -8,6 +8,7 @@
 #include "GrColorSpaceXform.h"
 #include "SkColorSpace.h"
 #include "SkColorSpacePriv.h"
+#include "SkMatrix44.h"
 #include "glsl/GrGLSLColorSpaceXformHelper.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"