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..f996127dfeea93a5db1f08cb53b58945d2c66000 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,100 @@ sk_sp<SkData> SkColorSpace_Base::writeToICC() const {
     //                 the client calls again?
     return SkData::MakeFromMalloc(profile.release(), kICCProfileSize);
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////

[reed1, 2016/06/21 14:58:34]

Some thoughts.

I think we should be more explicit about sizes and the memory layout of the
serialized buffer. sizeof(enum) can possibly change (depending on compiler
settings and the value ranges for our enums), and I also think we should
explicitly encode the size of the profile-data (when present) rather than rely
on implicitly knowing it from the total size... think of the case where we may
have our contents embedded in a larger stream of data...

I guess that last thought implies that our Deserialize might want to return the
number of bytes actually processed (think if Deserialize took a stream ...)

e.g.
First 4 bytes encode the type of encoding...

struct Header {
    uint8_t  fVersion;
    uint8_t fNamed;   // or 0xFF if this guy is not named
    uint8_t fGammaNamed;   // or 0xFF if this guy is not a named gamma
    uint8_t fFlags;  // 0 for now, maybe 1 bit means an ICC Profile follows:
4-byte length + data (padded to 4 bytes?)
};

[msarett, 2016/06/21 16:41:57]

The implementation with Header sgtm, along with storing the length of the icc
data.

And I agree that returning the length from the API could be useful - but I'd
rather not make that change until we have a caller that needs it.

The current implementation on SkImageInfo uses read/writeData() APIs, so we
already know that the blob we pass to Deserialize is just the serialized
SkColorSpace.

+
+sk_sp<SkData> SkColorSpace::serialize() const {
+    // If we have a named profile, only write the enum.
+    switch (fNamed) {
+        case kSRGB_Named:
+        case kAdobeRGB_Named: {
+            sk_sp<SkData> data = SkData::MakeUninitialized(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: {
+            sk_sp<SkData> data = SkData::MakeUninitialized(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));
+
+            fToXYZD50.asColMajorf((float*) dataPtr);
+            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);
+
+    sk_sp<SkData> data = SkData::MakeUninitialized(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;
+}
+
+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);
+            toXYZ.setColMajorf((const float*) data);
+            return NewRGB(gammaNamed, toXYZ);
+        }
+        default:
+            break;
+    }
+
+    return NewICC(data, length);
+}