Add SkColorSpaceTransferFn to SkColorSpace

src/core/SkColorSpace_Base.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkColorSpace_Base_DEFINED
 #define SkColorSpace_Base_DEFINED
 
@@ skipping 24 matching lines @@
     // Contains information for a gamma table.
     struct Table {
         size_t fOffset;
         int    fSize;
 
         const float* table(const SkGammas* base) const {
             return SkTAddOffset<const float>(base, sizeof(SkGammas) + fOffset);
         }
     };
 
-    // Contains the parameters for a parametric curve.
-    struct Params {
-        //     Y = (aX + b)^g + c  for X >= d
-        //     Y = eX + f          otherwise
-        float                    fG;
-        float                    fA;
-        float                    fB;
-        float                    fC;
-        float                    fD;
-        float                    fE;
-        float                    fF;
-    };
-
     // Contains the actual gamma curve information.  Should be interpreted
     // based on the type of the gamma curve.
     union Data {
         Data()
             : fTable{ 0, 0 }
         {}
 
         inline bool operator==(const Data& that) const {
             return this->fTable.fOffset == that.fTable.fOffset &&
                    this->fTable.fSize == that.fTable.fSize;
         }
 
         SkGammaNamed             fNamed;
         float                    fValue;
         Table                    fTable;
         size_t                   fParamOffset;
 
-        const Params& params(const SkGammas* base) const {
-            return *SkTAddOffset<const Params>(base, sizeof(SkGammas) + fParamOffset);
+        const SkColorSpaceTransferFn& params(const SkGammas* base) const {
+            return *SkTAddOffset<const SkColorSpaceTransferFn>(
+                    base, sizeof(SkGammas) + fParamOffset);
         }
     };
 
     bool isNamed(int i) const {
         return Type::kNamed_Type == this->type(i);
     }
 
     bool isValue(int i) const {
         return Type::kValue_Type == this->type(i);
     }
@@ skipping 18 matching lines @@
                 SkASSERT(false);
                 return fRedData;
         }
     }
 
     const float* table(int i) const {
         SkASSERT(isTable(i));
         return this->data(i).fTable.table(this);
     }
 
-    const Params& params(int i) const {
+    const SkColorSpaceTransferFn& params(int i) const {
         SkASSERT(isParametric(i));
         return this->data(i).params(this);
     }
 
     Type type(int i) const {
         switch (i) {
             case 0:
                 return fRedType;
             case 1:
                 return fGreenType;
@@ skipping 105 matching lines @@
 
 static inline const SkColorSpace_Base* as_CSB(const SkColorSpace* colorSpace) {
     return static_cast<const SkColorSpace_Base*>(colorSpace);
 }
 
 static inline SkColorSpace_Base* as_CSB(const sk_sp<SkColorSpace>& colorSpace) {
     return static_cast<SkColorSpace_Base*>(colorSpace.get());
 }
 
 #endif