Introduce SkGammas type to represent ICC gamma curves

src/codec/SkPngCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 192 matching lines @@
         // FIXME (msarett): Extract this information from the sRGB chunk once
         //                  we are able to handle this information in
         //                  SkColorSpace.
         return SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
     }
 
     // Next, check for chromaticities.
     png_fixed_point XYZ[9];
     SkFloat3x3 toXYZD50;
     png_fixed_point gamma;
-    SkFloat3 gammas;
+    SkGammas gammas;
     if (png_get_cHRM_XYZ_fixed(png_ptr, info_ptr, &XYZ[0], &XYZ[1], &XYZ[2], &XYZ[3], &XYZ[4],
             &XYZ[5], &XYZ[6], &XYZ[7], &XYZ[8])) {
 
         // FIXME (msarett): Here we are treating XYZ values as D50 even though the color
         //                  temperature is unspecified.  I suspect that this assumption
         //                  is most often ok, but we could also calculate the color
         //                  temperature (D value) and then convert the XYZ to D50.  Maybe
         //                  we should add a new constructor to SkColorSpace that accepts
         //                  XYZ with D-Unkown?
         for (int i = 0; i < 9; i++) {
             toXYZD50.fMat[i] = png_fixed_point_to_float(XYZ[i]);
         }
 
         if (PNG_INFO_gAMA == png_get_gAMA_fixed(png_ptr, info_ptr, &gamma)) {
-            gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] =
+            gammas.fRed.fValue = gammas.fGreen.fValue = gammas.fBlue.fValue =
                     png_inverted_fixed_point_to_float(gamma);
         } else {
             // If the image does not specify gamma, let's choose linear.  Should we default
             // to sRGB?  Most images are intended to be sRGB (gamma = 2.2f).
-            gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] = 1.0f;
+            gammas.fRed.fValue = gammas.fGreen.fValue = gammas.fBlue.fValue = 1.0f;
         }
 
 
-        return SkColorSpace::NewRGB(toXYZD50, gammas);
+        return SkColorSpace::NewRGB(toXYZD50, std::move(gammas));
     }
 
     // Last, check for gamma.
     if (PNG_INFO_gAMA == png_get_gAMA_fixed(png_ptr, info_ptr, &gamma)) {
 
         // Guess a default value for cHRM?  Or should we just give up?
         // Here we use the identity matrix as a default.
         // FIXME (msarett): Should SkFloat3x3 have a method to set the identity matrix?
         memset(toXYZD50.fMat, 0, 9 * sizeof(float));
         toXYZD50.fMat[0] = toXYZD50.fMat[4] = toXYZD50.fMat[8] = 1.0f;
 
         // Set the gammas.
-        gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] = png_inverted_fixed_point_to_float(gamma);
+        gammas.fRed.fValue = gammas.fGreen.fValue = gammas.fBlue.fValue =
+                png_inverted_fixed_point_to_float(gamma);
 
-        return SkColorSpace::NewRGB(toXYZD50, gammas);
+        return SkColorSpace::NewRGB(toXYZD50, std::move(gammas));
     }
 
 #endif // LIBPNG >= 1.6
 
     // Finally, what should we do if there is no color space information in the PNG?
     // The specification says that this indicates "gamma is unknown" and that the
     // "color is device dependent".  I'm assuming we can represent this with NULL.
     // But should we guess sRGB?  Most images are sRGB, even if they don't specify.
     return nullptr;
 }
@@ skipping 533 matching lines @@
     SkCodec* outCodec;
     if (read_header(stream, chunkReader, &outCodec, nullptr, nullptr)) {
         // Codec has taken ownership of the stream.
         SkASSERT(outCodec);
         streamDeleter.release();
         return outCodec;
     }
 
     return nullptr;
 }