SkColorSpace follow-ups

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 "SkAtomics.h"
 #include "SkColorSpace.h"
 #include "SkColorSpacePriv.h"
@@ skipping 536 matching lines @@
     array[10] = SkFixedToFloat(read_big_endian_int(src + 32));
     array[11] = 0;
     array[12] = SkFixedToFloat(read_big_endian_int(src + 36));  // translate R
     array[13] = SkFixedToFloat(read_big_endian_int(src + 40));  // translate G
     array[14] = SkFixedToFloat(read_big_endian_int(src + 44));
     array[15] = 1;
     toXYZ->setColMajorf(array);
     return true;
 }
 
-bool SkColorSpace::LoadA2B0(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas, SkMatrix44* toXYZ,
+bool SkColorSpace::LoadA2B0(SkColorLookUpTable* colorLUT, SkGammaCurve* gammas, SkMatrix44* toXYZ,
                             const uint8_t* src, size_t len) {
     if (len < 32) {
         SkColorSpacePrintf("A to B tag is too small (%d bytes).", len);
         return false;
     }
 
     uint32_t type = read_big_endian_uint(src);
     if (kTAG_AtoBType != type) {
         // FIXME (msarett): Need to support lut8Type and lut16Type.
         SkColorSpacePrintf("Unsupported A to B tag type.\n");
@@ skipping 29 matching lines @@
     uint32_t offsetToColorLUT = read_big_endian_int(src + 24);
     if (0 != offsetToColorLUT && offsetToColorLUT < len) {
         if (!SkColorSpace::LoadColorLUT(colorLUT, inputChannels, outputChannels,
                                         src + offsetToColorLUT, len - offsetToColorLUT)) {
             SkColorSpacePrintf("Failed to read color LUT from A to B tag.\n");
         }
     }
 
     uint32_t offsetToMCurves = read_big_endian_int(src + 20);
     if (0 != offsetToMCurves && offsetToMCurves < len) {
-        if (!SkColorSpace::LoadGammas(&gammas->fRed, outputChannels, src + offsetToMCurves,
+        if (!SkColorSpace::LoadGammas(gammas, outputChannels, src + offsetToMCurves,
                                       len - offsetToMCurves)) {
             SkColorSpacePrintf("Failed to read M curves from A to B tag.\n");
         }
     }
 
     uint32_t offsetToMatrix = read_big_endian_int(src + 16);
     if (0 != offsetToMatrix && offsetToMatrix < len) {
         if (!load_matrix(toXYZ, src + offsetToMatrix, len - offsetToMatrix)) {
             SkColorSpacePrintf("Failed to read matrix from A to B tag.\n");
         }
@@ skipping 55 matching lines @@
                 float toXYZ[9];
                 if (!load_xyz(&toXYZ[0], r->addr((const uint8_t*) base), r->fLength) ||
                     !load_xyz(&toXYZ[3], g->addr((const uint8_t*) base), g->fLength) ||
                     !load_xyz(&toXYZ[6], b->addr((const uint8_t*) base), b->fLength))
                 {
                     return_null("Need valid rgb tags for XYZ space");
                 }
 
                 // It is not uncommon to see missing or empty gamma tags.  This indicates
                 // that we should use unit gamma.
-                sk_sp<SkGammas> gammas(new SkGammas());
+                SkGammaCurve curves[3];
                 r = ICCTag::Find(tags.get(), tagCount, kTAG_rTRC);
                 g = ICCTag::Find(tags.get(), tagCount, kTAG_gTRC);
                 b = ICCTag::Find(tags.get(), tagCount, kTAG_bTRC);
-                if (!r || !SkColorSpace::LoadGammas(&gammas->fRed, 1,
+                if (!r || !SkColorSpace::LoadGammas(&curves[0], 1,
                                                     r->addr((const uint8_t*) base), r->fLength)) {
                     SkColorSpacePrintf("Failed to read R gamma tag.\n");
                 }
-                if (!g || !SkColorSpace::LoadGammas(&gammas->fGreen, 1,
+                if (!g || !SkColorSpace::LoadGammas(&curves[1], 1,
                                                     g->addr((const uint8_t*) base), g->fLength)) {
                     SkColorSpacePrintf("Failed to read G gamma tag.\n");
                 }
-                if (!b || !SkColorSpace::LoadGammas(&gammas->fBlue, 1,
+                if (!b || !SkColorSpace::LoadGammas(&curves[2], 1,
                                                     b->addr((const uint8_t*) base), b->fLength)) {
                     SkColorSpacePrintf("Failed to read B gamma tag.\n");
                 }
 
+                sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
+                                                    std::move(curves[2])));
                 SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
                 mat.set3x3ColMajorf(toXYZ);
                 if (gammas->isValues()) {
                     // When we have values, take advantage of the NewFromRGB initializer.
                     // This allows us to check for canonical sRGB and Adobe RGB.
                     float gammaVals[3];
                     gammaVals[0] = gammas->fRed.fValue;
                     gammaVals[1] = gammas->fGreen.fValue;
                     gammaVals[2] = gammas->fBlue.fValue;
                     return SkColorSpace::NewRGB(gammaVals, mat);
                 } else {
                     return sk_sp<SkColorSpace>(new SkColorSpace(gammas, mat, kUnknown_Named));
                 }
             }
 
             // Recognize color profile specified by A2B0 tag.
             const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
             if (a2b0) {
                 SkAutoTDelete<SkColorLookUpTable> colorLUT(new SkColorLookUpTable());
-                sk_sp<SkGammas> gammas(new SkGammas());
+                SkGammaCurve curves[3];
                 SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
-                if (!SkColorSpace::LoadA2B0(colorLUT, gammas, &toXYZ,
+                if (!SkColorSpace::LoadA2B0(colorLUT, curves, &toXYZ,
                                             a2b0->addr((const uint8_t*) base), a2b0->fLength)) {
                     return_null("Failed to parse A2B0 tag");
                 }
 
+                sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
+                                                    std::move(curves[2])));
                 if (colorLUT->fTable) {
                     return sk_sp<SkColorSpace>(new SkColorSpace(colorLUT.release(), gammas, toXYZ));
                 } else if (gammas->isValues()) {
                     // When we have values, take advantage of the NewFromRGB initializer.
                     // This allows us to check for canonical sRGB and Adobe RGB.
                     float gammaVals[3];
                     gammaVals[0] = gammas->fRed.fValue;
                     gammaVals[1] = gammas->fGreen.fValue;
                     gammaVals[2] = gammas->fBlue.fValue;
                     return SkColorSpace::NewRGB(gammaVals, toXYZ);
                 } else {
                     return sk_sp<SkColorSpace>(new SkColorSpace(gammas, toXYZ, kUnknown_Named));
                 }
             }
 
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }