Add writeToMemory() API to SkColorSpace

src/core/SkColorSpace.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 "SkColorSpace.h"
 #include "SkColorSpace_Base.h"
 #include "SkColorSpacePriv.h"
@@ skipping 182 matching lines @@
         header.fFlags = flags;
         return header;
     }
 
     uint8_t fVersion;    // Always zero
     uint8_t fNamed;      // Must be a SkColorSpace::Named
     uint8_t fGammaNamed; // Must be a SkColorSpace::GammaNamed
     uint8_t fFlags;      // Some combination of the flags listed above
 };
 
-sk_sp<SkData> SkColorSpace::serialize() const {
+size_t SkColorSpace::writeToMemory(void* memory) 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(ColorSpaceHeader));
-            *((ColorSpaceHeader*) data->writable_data()) =
-                    ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed, 0);
-            return data;
+            if (memory) {
+                *((ColorSpaceHeader*) memory) =
+                        ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed, 0);
+            }
+            return sizeof(ColorSpaceHeader);
         }
         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(ColorSpaceHeader) +
-                                                           12 * sizeof(float));
-            void* dataPtr = data->writable_data();
-
-            *((ColorSpaceHeader*) dataPtr) = ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed,
-                                                                    ColorSpaceHeader::kMatrix_Flag);
-            dataPtr = SkTAddOffset<void>(dataPtr, sizeof(ColorSpaceHeader));
-
-            fToXYZD50.as4x3ColMajorf((float*) dataPtr);
-            return data;
+            if (memory) {
+                *((ColorSpaceHeader*) memory) =
+                        ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed,
+                                               ColorSpaceHeader::kMatrix_Flag);
+                memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+                fToXYZD50.as4x3ColMajorf((float*) memory);
+            }
+            return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
         }
         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);
 
     size_t profileSize = as_CSB(this)->fProfileData->size();
     if (SkAlign4(profileSize) != (uint32_t) SkAlign4(profileSize)) {
+        return 0;
+    }
+
+    if (memory) {
+        *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed,
+                                                               ColorSpaceHeader::kICC_Flag);
+        memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
+
+        *((uint32_t*) memory) = (uint32_t) SkAlign4(profileSize);
+        memory = SkTAddOffset<void>(memory, sizeof(uint32_t));
+
+        memcpy(memory, as_CSB(this)->fProfileData->data(), profileSize);
+        memset(SkTAddOffset<void>(memory, profileSize), 0, SkAlign4(profileSize) - profileSize);
+    }
+    return sizeof(ColorSpaceHeader) + sizeof(uint32_t) + SkAlign4(profileSize);
+}
+
+sk_sp<SkData> SkColorSpace::serialize() const {
+    size_t size = this->writeToMemory(nullptr);
+    if (0 == size) {
         return nullptr;
     }
 
-    sk_sp<SkData> data = SkData::MakeUninitialized(sizeof(ColorSpaceHeader) + sizeof(uint32_t) +
-                                                   SkAlign4(profileSize));
-    void* dataPtr = data->writable_data();
-
-    *((ColorSpaceHeader*) dataPtr) = ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed,
-                                                            ColorSpaceHeader::kICC_Flag);
-    dataPtr = SkTAddOffset<void>(dataPtr, sizeof(ColorSpaceHeader));
-
-    *((uint32_t*) dataPtr) = (uint32_t) SkAlign4(profileSize);
-    dataPtr = SkTAddOffset<void>(dataPtr, sizeof(uint32_t));
-
-    memcpy(dataPtr, as_CSB(this)->fProfileData->data(), profileSize);
-    memset(SkTAddOffset<void>(dataPtr, profileSize), 0, SkAlign4(profileSize) - profileSize);
+    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)) {
         return nullptr;
     }
 
     ColorSpaceHeader header = *((const ColorSpaceHeader*) data);
     data = SkTAddOffset<const void>(data, sizeof(ColorSpaceHeader));
@@ skipping 28 matching lines @@
 
     uint32_t profileSize = *((uint32_t*) data);
     data = SkTAddOffset<const void>(data, sizeof(uint32_t));
     length -= sizeof(uint32_t);
     if (length < profileSize) {
         return nullptr;
     }
 
     return NewICC(data, profileSize);
 }