Enable flattening and unflattening of SkColorSpace

src/core/SkColorSpace.cpp

Index: src/core/SkColorSpace.cpp
diff --git a/src/core/SkColorSpace.cpp b/src/core/SkColorSpace.cpp
index 5df45fff4126d7e9a08a1251e9b9cde029ae7de8..5cf44b8a78e85fc8473415479ce59a8959776ca1 100644
--- a/src/core/SkColorSpace.cpp
+++ b/src/core/SkColorSpace.cpp
@@ -9,6 +9,8 @@
 #include "SkColorSpace_Base.h"
 #include "SkEndian.h"
 #include "SkOnce.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
 
 #define SkColorSpacePrintf(...)
 
@@ -24,11 +26,10 @@ SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Na
     , fNamed(named)
 {}
 
-SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named,
-                                     sk_sp<SkData> profileData)
+SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
     : INHERITED(gammaNamed, toXYZD50, named)
     , fGammas(nullptr)
-    , fProfileData(std::move(profileData))
+    , fProfileData(nullptr)
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
@@ -102,11 +103,10 @@ sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(float values[3], const SkMatrix44&
         return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, gammas, toXYZD50, nullptr));
     }
 
-    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50, nullptr);
+    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50);
 }
 
-sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50,
-                                              sk_sp<SkData> profileData) {
+sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
     switch (gammaNamed) {
         case kSRGB_GammaNamed:
             if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
@@ -125,12 +125,11 @@ sk_sp<SkColorSpace> SkColorSpace_Base::NewRGB(GammaNamed gammaNamed, const SkMat
             break;
     }
 
-    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammaNamed, toXYZD50, kUnknown_Named,
-                                                     profileData));
+    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammaNamed, toXYZD50, kUnknown_Named));
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
-    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50, nullptr);
+    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50);
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
@@ -144,7 +143,7 @@ sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
             sRGBOnce([] {
                 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 srgbToxyzD50.set3x3ColMajorf(gSRGB_toXYZD50);
-                sRGB = new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50, kSRGB_Named, nullptr);
+                sRGB = new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50, kSRGB_Named);
             });
             return sk_ref_sp(sRGB);
         }
@@ -153,7 +152,7 @@ sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
                 SkMatrix44 adobergbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 adobergbToxyzD50.set3x3ColMajorf(gAdobeRGB_toXYZD50);
                 adobeRGB = new SkColorSpace_Base(k2Dot2Curve_GammaNamed, adobergbToxyzD50,
-                                                 kAdobeRGB_Named, nullptr);
+                                                 kAdobeRGB_Named);
             });
             return sk_ref_sp(adobeRGB);
         }
@@ -930,7 +929,7 @@ sk_sp<SkColorSpace> SkColorSpace::NewICC(const void* input, size_t len) {
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, std::move(gammas),
                                                                      mat, std::move(data)));
                 } else {
-                    return SkColorSpace_Base::NewRGB(gammaNamed, mat, std::move(data));
+                    return SkColorSpace_Base::NewRGB(gammaNamed, mat);
                 }
             }
 
@@ -955,7 +954,7 @@ sk_sp<SkColorSpace> SkColorSpace::NewICC(const void* input, size_t len) {
                                                                      std::move(gammas), toXYZ,
                                                                      std::move(data)));
                 } else {
-                    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ, std::move(data));
+                    return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ);
                 }
             }
         }
@@ -1208,3 +1207,138 @@ sk_sp<SkData> SkColorSpace_Base::writeToICC() const {
     //                 the client calls again?
     return SkData::MakeFromMalloc(profile.release(), kICCProfileSize);
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+static void write_matrix(float* dst, const SkMatrix44& matrix) {
+    dst[0] = matrix.getFloat(0, 0);
+    dst[1] = matrix.getFloat(0, 1);
+    dst[2] = matrix.getFloat(0, 2);
+    dst[3] = matrix.getFloat(0, 3);
+    dst[4] = matrix.getFloat(1, 0);
+    dst[5] = matrix.getFloat(1, 1);
+    dst[6] = matrix.getFloat(1, 2);
+    dst[7] = matrix.getFloat(1, 3);
+    dst[8] = matrix.getFloat(2, 0);
+    dst[9] = matrix.getFloat(2, 1);
+    dst[10] = matrix.getFloat(2, 2);
+    dst[11] = matrix.getFloat(2, 3);
+    dst[12] = matrix.getFloat(3, 0);
+    dst[13] = matrix.getFloat(3, 1);
+    dst[14] = matrix.getFloat(3, 2);
+    dst[15] = matrix.getFloat(3, 3);
+}
+
+SkData* SkColorSpace::serialize() const {
+    // If we have a named profile, only write the enum.
+    switch (fNamed) {
+        case kSRGB_Named:
+        case kAdobeRGB_Named: {
+            SkData* data = SkData::NewUninitialized(sizeof(Named));
+            *((Named*) data->writable_data()) = fNamed;
+            return data;
+        }
+        default:
+            break;
+    }
+
+    // If we have a named gamma, write the enum and the matrix.
+    switch (fGammaNamed) {
+        case kSRGB_GammaNamed:
+        case k2Dot2Curve_GammaNamed:
+        case kLinear_GammaNamed: {
+            SkData* data = SkData::NewUninitialized(sizeof(Named) + sizeof(GammaNamed) +
+                                                    16 * sizeof(float));
+            void* dataPtr = data->writable_data();
+
+            *((Named*) dataPtr) = fNamed;
+            dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fNamed));
+
+            *((GammaNamed*) dataPtr) = fGammaNamed;
+            dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fGammaNamed));
+
+            write_matrix((float*) dataPtr, fToXYZD50);

[Brian Osman, 2016/06/21 13:38:19]

Could just write:
fToXYZD50.asColMajorf((float*)dataPtr);
... and remove write_matrix entirely.

[msarett, 2016/06/21 14:41:56]

Ahh yes of course.

+            return data;
+        }
+        default:
+            break;
+    }
+
+    // If we do not have a named gamma, this must have been created from an ICC profile.
+    // Since we were unable to recognize the gamma, we will have saved the ICC data.
+    SkASSERT(as_CSB(this)->fProfileData);
+
+    SkData* data = SkData::NewUninitialized(sizeof(Named) + sizeof(GammaNamed) +
+                                            as_CSB(this)->fProfileData->size());
+    void* dataPtr = data->writable_data();
+
+    *((Named*) dataPtr) = fNamed;
+    dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fNamed));
+
+    *((GammaNamed*) dataPtr) = fGammaNamed;
+    dataPtr = SkTAddOffset<void>(dataPtr, sizeof(fGammaNamed));
+
+    memcpy(dataPtr, as_CSB(this)->fProfileData->data(), as_CSB(this)->fProfileData->size());
+    return data;
+}
+
+static void read_matrix(SkMatrix44* matrix, const float* src) {
+    matrix->setFloat(0, 0, src[0]);
+    matrix->setFloat(0, 1, src[1]);
+    matrix->setFloat(0, 2, src[2]);
+    matrix->setFloat(0, 3, src[3]);
+    matrix->setFloat(1, 0, src[4]);
+    matrix->setFloat(1, 1, src[5]);
+    matrix->setFloat(1, 2, src[6]);
+    matrix->setFloat(1, 3, src[7]);
+    matrix->setFloat(2, 0, src[8]);
+    matrix->setFloat(2, 1, src[9]);
+    matrix->setFloat(2, 2, src[10]);
+    matrix->setFloat(2, 3, src[11]);
+    matrix->setFloat(3, 0, src[12]);
+    matrix->setFloat(3, 1, src[13]);
+    matrix->setFloat(3, 2, src[14]);
+    matrix->setFloat(3, 3, src[15]);
+}
+
+sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
+    if (length < sizeof(Named)) {
+        return nullptr;
+    }
+
+    Named named = *((const Named*) data);
+    data = SkTAddOffset<const void>(data, sizeof(Named));
+    length -= sizeof(Named);
+    switch (named) {
+        case kSRGB_Named:
+        case kAdobeRGB_Named:
+            return NewNamed(named);
+        default:
+            break;
+    }
+
+    if (length < sizeof(GammaNamed)) {
+        return nullptr;
+    }
+
+    GammaNamed gammaNamed = *((const GammaNamed*) data);
+    data = SkTAddOffset<const void>(data, sizeof(GammaNamed));
+    length -= sizeof(GammaNamed);
+    switch (gammaNamed) {
+        case kSRGB_GammaNamed:
+        case k2Dot2Curve_GammaNamed:
+        case kLinear_GammaNamed: {
+            if (length < 16 * sizeof(float)) {
+                return nullptr;
+            }
+
+            SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
+            read_matrix(&toXYZ, (const float*) data);

[Brian Osman, 2016/06/21 13:38:19]

Similar to above:
toXYZ.setColMajorf((const float*) data);
... and remove read_matrix.

[msarett, 2016/06/21 14:41:56]

Yes.

+            return NewRGB(gammaNamed, toXYZ);
+        }
+        default:
+            break;
+    }
+
+    return NewICC(data, length);
+}