Push much of the SkColorSpace_Base interface up to SkColorSpace

Some pieces still remain, but the next step looks less mechanical,
so I wanted to land this piece independently.

Bug: skia:
Change-Id: Ie63afcfa08af2f6e4996911fa2225c43441dbfb2
Reviewed-on: https://skia-review.googlesource.com/84120
Reviewed-by: Mike Klein <mtklein@chromium.org>
Commit-Queue: Brian Osman <brianosman@google.com>

15 files changed, 64 insertions, 116 deletions

diff --git a/src/codec/SkAndroidCodec.cpp b/src/codec/SkAndroidCodec.cpp
index a694b4b916..97e07ce70b 100644
--- a/src/codec/SkAndroidCodec.cpp
+++ b/src/codec/SkAndroidCodec.cpp
@@ -47,7 +47,7 @@ static constexpr float kSRGB_D50_GamutArea = 0.084f;
 static bool is_wide_gamut(const SkColorSpace* colorSpace) {
     // Determine if the source image has a gamut that is wider than sRGB.  If so, we
     // will use P3 as the output color space to avoid clipping the gamut.
-    const SkMatrix44* toXYZD50 = as_CSB(colorSpace)->toXYZD50();
+    const SkMatrix44* toXYZD50 = colorSpace->toXYZD50();
     if (toXYZD50) {
         SkPoint rgb[3];
         load_gamut(rgb, *toXYZD50);
diff --git a/src/codec/SkJpegCodec.cpp b/src/codec/SkJpegCodec.cpp
index 8a8b23b248..97d71eb00e 100644
--- a/src/codec/SkJpegCodec.cpp
+++ b/src/codec/SkJpegCodec.cpp
@@ -558,7 +558,7 @@ static inline bool needs_swizzler_to_convert_from_cmyk(J_COLOR_SPACE jpegColorTy
         return false;
     }
 
-    bool hasCMYKColorSpace = as_CSB(srcInfo.colorSpace())->onIsCMYK();
+    bool hasCMYKColorSpace = SkColorSpace::kCMYK_Type ==  srcInfo.colorSpace()->type();
     return !hasCMYKColorSpace || !hasColorSpaceXform;
 }
 
diff --git a/src/core/SkColorSpace.cpp b/src/core/SkColorSpace.cpp
index 5d22a18718..06ec26d101 100644
--- a/src/core/SkColorSpace.cpp
+++ b/src/core/SkColorSpace.cpp
@@ -235,27 +235,31 @@ sk_sp<SkColorSpace> SkColorSpace::MakeSRGBLinear() {
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkColorSpace::Type SkColorSpace::type() const {
-    SkMatrix44  m(SkMatrix44::kUninitialized_Constructor);
-    if (this->toXYZD50(&m)) {
-        return m.isScale() ? kGray_Type : kRGB_Type;
+    const SkMatrix44* m = this->toXYZD50();
+    if (m) {
+        return m->isScale() ? kGray_Type : kRGB_Type;
     }
-    return as_CSB(this)->onIsCMYK() ? kCMYK_Type : kRGB_Type;
+    return this->onIsCMYK() ? kCMYK_Type : kRGB_Type;
+}
+
+SkGammaNamed SkColorSpace::gammaNamed() const {
+    return this->onGammaNamed();
 }
 
 bool SkColorSpace::gammaCloseToSRGB() const {
-    return as_CSB(this)->onGammaCloseToSRGB();
+    return this->onGammaCloseToSRGB();
 }
 
 bool SkColorSpace::gammaIsLinear() const {
-    return as_CSB(this)->onGammaIsLinear();
+    return this->onGammaIsLinear();
 }
 
 bool SkColorSpace::isNumericalTransferFn(SkColorSpaceTransferFn* fn) const {
-    return as_CSB(this)->onIsNumericalTransferFn(fn);
+    return this->onIsNumericalTransferFn(fn);
 }
 
 bool SkColorSpace::toXYZD50(SkMatrix44* toXYZD50) const {
-    const SkMatrix44* matrix = as_CSB(this)->toXYZD50();
+    const SkMatrix44* matrix = this->onToXYZD50();
     if (matrix) {
         *toXYZD50 = *matrix;
         return true;
@@ -264,6 +268,18 @@ bool SkColorSpace::toXYZD50(SkMatrix44* toXYZD50) const {
     return false;
 }
 
+const SkMatrix44* SkColorSpace::toXYZD50() const {
+    return this->onToXYZD50();
+}
+
+const SkMatrix44* SkColorSpace::fromXYZD50() const {
+    return this->onFromXYZD50();
+}
+
+uint32_t SkColorSpace::toXYZD50Hash() const {
+    return this->onToXYZD50Hash();
+}
+
 bool SkColorSpace::isSRGB() const {
     return srgb() == this;
 }
@@ -331,7 +347,7 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
         SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(this)->type());
         const SkColorSpace_XYZ* thisXYZ = static_cast<const SkColorSpace_XYZ*>(this);
         // If we have a named profile, only write the enum.
-        const SkGammaNamed gammaNamed = thisXYZ->gammaNamed();
+        const SkGammaNamed gammaNamed = this->gammaNamed();
         if (this == srgb()) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
@@ -362,7 +378,7 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
                             ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
                                                    ColorSpaceHeader::kMatrix_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
-                    thisXYZ->toXYZD50()->as3x4RowMajorf((float*) memory);
+                    this->toXYZD50()->as3x4RowMajorf((float*) memory);
                 }
                 return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
             }
@@ -377,7 +393,7 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
 
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
-                            ColorSpaceHeader::Pack(k0_Version, 0, thisXYZ->fGammaNamed,
+                            ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
                                                    ColorSpaceHeader::kTransferFn_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
@@ -390,7 +406,7 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
                     *(((float*) memory) + 6) = gammas->params(0).fG;
                     memory = SkTAddOffset<void>(memory, 7 * sizeof(float));
 
-                    thisXYZ->fToXYZD50.as3x4RowMajorf((float*) memory);
+                    this->toXYZD50()->as3x4RowMajorf((float*) memory);
                 }
 
                 return sizeof(ColorSpaceHeader) + 19 * sizeof(float);
@@ -517,21 +533,17 @@ bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
         return false;
     }
 
-    // profiles are mandatory for A2B0 color spaces
-    SkASSERT(as_CSB(src)->type() == SkColorSpace_Base::Type::kXYZ);
-    const SkColorSpace_XYZ* srcXYZ = static_cast<const SkColorSpace_XYZ*>(src);
-    const SkColorSpace_XYZ* dstXYZ = static_cast<const SkColorSpace_XYZ*>(dst);
-
-    if (srcXYZ->gammaNamed() != dstXYZ->gammaNamed()) {
+    // Profiles are mandatory for A2B0 color spaces, so these must be XYZ
+    if (src->gammaNamed() != dst->gammaNamed()) {
         return false;
     }
 
-    switch (srcXYZ->gammaNamed()) {
+    switch (src->gammaNamed()) {
         case kSRGB_SkGammaNamed:
         case k2Dot2Curve_SkGammaNamed:
         case kLinear_SkGammaNamed:
-            if (srcXYZ->toXYZD50Hash() == dstXYZ->toXYZD50Hash()) {
-                SkASSERT(*srcXYZ->toXYZD50() == *dstXYZ->toXYZD50() && "Hash collision");
+            if (src->toXYZD50Hash() == dst->toXYZD50Hash()) {
+                SkASSERT(*src->toXYZD50() == *dst->toXYZD50() && "Hash collision");
                 return true;
             }
             return false;
diff --git a/src/core/SkColorSpace_A2B.h b/src/core/SkColorSpace_A2B.h
index 08784c23bb..ca78c64db9 100644
--- a/src/core/SkColorSpace_A2B.h
+++ b/src/core/SkColorSpace_A2B.h
@@ -27,7 +27,7 @@
 // here by the nature of the design.
 class SkColorSpace_A2B : public SkColorSpace_Base {
 public:
-    const SkMatrix44* toXYZD50() const override {
+    const SkMatrix44* onToXYZD50() const override {
         // the matrix specified in A2B0 profiles is not necessarily
         // a to-XYZ matrix, as to-Lab is supported as well so returning
         // that could be misleading. Additionally, B-curves are applied
@@ -36,18 +36,19 @@ public:
         return nullptr;
     }
 
-    uint32_t toXYZD50Hash() const override {
-        // See toXYZD50()'s comment.
+    uint32_t onToXYZD50Hash() const override {
+        // See onToXYZD50()'s comment.
         return 0;
     }
 
-    const SkMatrix44* fromXYZD50() const override {
-        // See toXYZD50()'s comment. Also, A2B0 profiles are not supported
+    const SkMatrix44* onFromXYZD50() const override {
+        // See onToXYZD50()'s comment. Also, A2B0 profiles are not supported
         // as destination color spaces, so an inverse matrix is never wanted.
         return nullptr;
     }
 
     // There is no single gamma curve in an A2B0 profile
+    SkGammaNamed onGammaNamed() const override { return kNonStandard_SkGammaNamed; }
     bool onGammaCloseToSRGB() const override { return false; }
     bool onGammaIsLinear() const override { return false; }
     bool onIsNumericalTransferFn(SkColorSpaceTransferFn* coeffs) const override { return false; }
diff --git a/src/core/SkColorSpace_Base.h b/src/core/SkColorSpace_Base.h
index 083c3ebccd..c59a827a96 100644
--- a/src/core/SkColorSpace_Base.h
+++ b/src/core/SkColorSpace_Base.h
@@ -14,13 +14,6 @@
 #include "SkOnce.h"
 #include "SkTemplates.h"
 
-enum SkGammaNamed : uint8_t {
-    kLinear_SkGammaNamed,
-    kSRGB_SkGammaNamed,
-    k2Dot2Curve_SkGammaNamed,
-    kNonStandard_SkGammaNamed,
-};
-
 struct SkGammas : SkRefCnt {
 
     // There are four possible representations for gamma curves.  kNone_Type is used
@@ -139,57 +132,6 @@ struct SkGammas : SkRefCnt {
 class SkColorSpace_Base : public SkColorSpace {
 public:
 
-    /**
-     *  Describes color space gamut as a transformation to XYZ D50.
-     *  Returns nullptr if color gamut cannot be described in terms of XYZ D50.
-     */
-    virtual const SkMatrix44* toXYZD50() const = 0;
-
-    /**
-     *  Returns a hash of the gamut transofmration to XYZ D50. Allows for fast equality checking
-     *  of gamuts, at the (very small) risk of collision.
-     *  Returns 0 if color gamut cannot be described in terms of XYZ D50.
-     */
-    virtual uint32_t toXYZD50Hash() const = 0;
-
-    /**
-     *  Describes color space gamut as a transformation from XYZ D50
-     *  Returns nullptr if color gamut cannot be described in terms of XYZ D50.
-     */
-    virtual const SkMatrix44* fromXYZD50() const = 0;
-
-    virtual bool onGammaCloseToSRGB() const = 0;
-
-    virtual bool onGammaIsLinear() const = 0;
-
-    virtual bool onIsNumericalTransferFn(SkColorSpaceTransferFn* coeffs) const = 0;
-
-    virtual bool onIsCMYK() const { return false; }
-
-    /**
-     *  Returns a color space with the same gamut as this one, but with a linear gamma.
-     *  For color spaces whose gamut can not be described in terms of XYZ D50, returns
-     *  linear sRGB.
-     */
-    virtual sk_sp<SkColorSpace> makeLinearGamma() const = 0;
-
-    /**
-     *  Returns a color space with the same gamut as this one, with with the sRGB transfer
-     *  function. For color spaces whose gamut can not be described in terms of XYZ D50, returns
-     *  sRGB.
-     */
-    virtual sk_sp<SkColorSpace> makeSRGBGamma() const = 0;
-
-    /**
-     *  Returns a color space with the same transfer function as this one, but with the primary
-     *  colors rotated. For any XYZ space, this produces a new color space that maps RGB to GBR
-     *  (when applied to a source), and maps RGB to BRG (when applied to a destination). For other
-     *  types of color spaces, returns nullptr.
-     *
-     *  This is used for testing, to construct color spaces that have severe and testable behavior.
-     */
-    virtual sk_sp<SkColorSpace> makeColorSpin() const { return nullptr; }
-
     enum class Type : uint8_t {
         kXYZ,
         kA2B
diff --git a/src/core/SkColorSpace_XYZ.cpp b/src/core/SkColorSpace_XYZ.cpp
index ed66a74d7a..34a93f7047 100644
--- a/src/core/SkColorSpace_XYZ.cpp
+++ b/src/core/SkColorSpace_XYZ.cpp
@@ -37,7 +37,7 @@ SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, sk_sp<SkGammas> gamm
     }
 }
 
-const SkMatrix44* SkColorSpace_XYZ::fromXYZD50() const {
+const SkMatrix44* SkColorSpace_XYZ::onFromXYZD50() const {
     fFromXYZOnce([this] {
         if (!fToXYZD50.invert(&fFromXYZD50)) {
             // If a client gives us a dst gamut with a transform that we can't invert, we will
diff --git a/src/core/SkColorSpace_XYZ.h b/src/core/SkColorSpace_XYZ.h
index 3ea2665f63..4e12a5a4b5 100644
--- a/src/core/SkColorSpace_XYZ.h
+++ b/src/core/SkColorSpace_XYZ.h
@@ -14,10 +14,10 @@
 
 class SkColorSpace_XYZ : public SkColorSpace_Base {
 public:
-    const SkMatrix44* toXYZD50() const override { return &fToXYZD50; }
-    uint32_t toXYZD50Hash() const override { return fToXYZD50Hash; }
+    const SkMatrix44* onToXYZD50() const override { return &fToXYZD50; }
+    uint32_t onToXYZD50Hash() const override { return fToXYZD50Hash; }
 
-    const SkMatrix44* fromXYZD50() const override;
+    const SkMatrix44* onFromXYZD50() const override;
 
     bool onGammaCloseToSRGB() const override;
 
@@ -31,7 +31,7 @@ public:
     sk_sp<SkColorSpace> makeSRGBGamma() const override;
     sk_sp<SkColorSpace> makeColorSpin() const override;
 
-    SkGammaNamed gammaNamed() const { return fGammaNamed; }
+    SkGammaNamed onGammaNamed() const override { return fGammaNamed; }
 
     const SkGammas* gammas() const { return fGammas.get(); }
 
diff --git a/src/core/SkDraw_vertices.cpp b/src/core/SkDraw_vertices.cpp
index 004575ea99..52d2a6cd48 100644
--- a/src/core/SkDraw_vertices.cpp
+++ b/src/core/SkDraw_vertices.cpp
@@ -163,7 +163,7 @@ static SkPM4f* convert_colors(const SkColor src[], int count, SkColorSpace* devi
         }
     } else {
         auto srcCS = SkColorSpace::MakeSRGB();
-        auto dstCS = as_CSB(deviceCS)->makeLinearGamma();
+        auto dstCS = deviceCS->makeLinearGamma();
         SkColorSpaceXform::Apply(dstCS.get(), SkColorSpaceXform::kRGBA_F32_ColorFormat, dst,
                                  srcCS.get(), SkColorSpaceXform::kBGRA_8888_ColorFormat, src,
                                  count, SkColorSpaceXform::kPremul_AlphaOp);
diff --git a/src/core/SkICC.cpp b/src/core/SkICC.cpp
index 109c40ac7f..128bce368d 100644
--- a/src/core/SkICC.cpp
+++ b/src/core/SkICC.cpp
@@ -32,17 +32,11 @@ sk_sp<SkICC> SkICC::Make(const void* ptr, size_t len) {
 }
 
 bool SkICC::toXYZD50(SkMatrix44* toXYZD50) const {
-    const SkMatrix44* m = as_CSB(fColorSpace)->toXYZD50();
-    if (!m) {
-        return false;
-    }
-
-    *toXYZD50 = *m;
-    return true;
+    return fColorSpace->toXYZD50(toXYZD50);
 }
 
 bool SkICC::isNumericalTransferFn(SkColorSpaceTransferFn* coeffs) const {
-    return as_CSB(fColorSpace)->onIsNumericalTransferFn(coeffs);
+    return fColorSpace->isNumericalTransferFn(coeffs);
 }
 
 static const int kDefaultTableSize = 512; // Arbitrary
diff --git a/src/core/SkPM4fPriv.h b/src/core/SkPM4fPriv.h
index ff4e644f05..28780d659a 100644
--- a/src/core/SkPM4fPriv.h
+++ b/src/core/SkPM4fPriv.h
@@ -109,15 +109,15 @@ static inline bool append_gamut_transform_noclamp(SkRasterPipeline* p,
         return false;
     }
 
-    const SkMatrix44 *fromSrc = as_CSB(src)->  toXYZD50(),
-                       *toDst = as_CSB(dst)->fromXYZD50();
+    const SkMatrix44 *fromSrc = src->  toXYZD50(),
+                       *toDst = dst->fromXYZD50();
     if (!fromSrc || !toDst) {
         SkDEBUGFAIL("We can't handle non-XYZ color spaces in append_gamut_transform().");
         return false;
     }
 
     // Slightly more sophisticated version of if (src == dst)
-    if (as_CSB(src)->toXYZD50Hash() == as_CSB(dst)->toXYZD50Hash()) {
+    if (src->toXYZD50Hash() == dst->toXYZD50Hash()) {
         return false;
     }
 
diff --git a/src/gpu/GrColorSpaceXform.cpp b/src/gpu/GrColorSpaceXform.cpp
index f0dc279be3..ac93fb496e 100644
--- a/src/gpu/GrColorSpaceXform.cpp
+++ b/src/gpu/GrColorSpaceXform.cpp
@@ -119,20 +119,20 @@ sk_sp<GrColorSpaceXform> GrColorSpaceXform::Make(const SkColorSpace* src,
         return nullptr;
     }
 
-    const SkMatrix44* toXYZD50   = as_CSB(src)->toXYZD50();
-    const SkMatrix44* fromXYZD50 = as_CSB(dst)->fromXYZD50();
+    const SkMatrix44* toXYZD50   = src->toXYZD50();
+    const SkMatrix44* fromXYZD50 = dst->fromXYZD50();
     if (!toXYZD50 || !fromXYZD50) {
         // Unsupported colour spaces -- cannot specify gamut as a matrix
         return nullptr;
     }
 
     // Determine if a gamut xform is needed
-    uint32_t srcHash = as_CSB(src)->toXYZD50Hash();
-    uint32_t dstHash = as_CSB(dst)->toXYZD50Hash();
+    uint32_t srcHash = src->toXYZD50Hash();
+    uint32_t dstHash = dst->toXYZD50Hash();
     if (srcHash != dstHash) {
         flags |= kApplyGamutXform_Flag;
     } else {
-        SkASSERT(*toXYZD50 == *as_CSB(dst)->toXYZD50() && "Hash collision");
+        SkASSERT(*toXYZD50 == *dst->toXYZD50() && "Hash collision");
     }
 
     if (0 == flags) {
diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp
index b18b17a870..c5a2b8ddff 100644
--- a/src/image/SkImage_Lazy.cpp
+++ b/src/image/SkImage_Lazy.cpp
@@ -390,7 +390,7 @@ SkImageInfo SkImage_Lazy::buildCacheInfo(CachedFormat format) const {
             return fInfo.makeColorSpace(nullptr);
         case kLinearF16_CachedFormat:
             return fInfo.makeColorType(kRGBA_F16_SkColorType)
-                        .makeColorSpace(as_CSB(fInfo.colorSpace())->makeLinearGamma());
+                        .makeColorSpace(fInfo.colorSpace()->makeLinearGamma());
         case kSRGB8888_CachedFormat:
             // If the transfer function is nearly (but not exactly) sRGB, we don't want the codec
             // to bother trans-coding. It would be slow, and do more harm than good visually,
@@ -399,7 +399,7 @@ SkImageInfo SkImage_Lazy::buildCacheInfo(CachedFormat format) const {
                 return fInfo.makeColorType(kRGBA_8888_SkColorType);
             } else {
                 return fInfo.makeColorType(kRGBA_8888_SkColorType)
-                            .makeColorSpace(as_CSB(fInfo.colorSpace())->makeSRGBGamma());
+                            .makeColorSpace(fInfo.colorSpace()->makeSRGBGamma());
             }
         case kSBGR8888_CachedFormat:
             // See note above about not-quite-sRGB transfer functions.
@@ -407,7 +407,7 @@ SkImageInfo SkImage_Lazy::buildCacheInfo(CachedFormat format) const {
                 return fInfo.makeColorType(kBGRA_8888_SkColorType);
             } else {
                 return fInfo.makeColorType(kBGRA_8888_SkColorType)
-                            .makeColorSpace(as_CSB(fInfo.colorSpace())->makeSRGBGamma());
+                            .makeColorSpace(fInfo.colorSpace()->makeSRGBGamma());
             }
         default:
             SkDEBUGFAIL("Invalid cached format");
diff --git a/src/images/SkImageEncoderFns.h b/src/images/SkImageEncoderFns.h
index dd02ebf78b..8e44ff222e 100644
--- a/src/images/SkImageEncoderFns.h
+++ b/src/images/SkImageEncoderFns.h
@@ -361,7 +361,7 @@ static inline sk_sp<SkData> icc_from_color_space(const SkImageInfo& info) {
 
     sk_sp<SkColorSpace> owned;
     if (kRGBA_F16_SkColorType == info.colorType()) {
-        owned = as_CSB(cs)->makeSRGBGamma();
+        owned = cs->makeSRGBGamma();
         cs = owned.get();
     }
 
diff --git a/src/shaders/gradients/SkGradientShader.cpp b/src/shaders/gradients/SkGradientShader.cpp
index 1ff42e7a2f..1a3e749235 100644
--- a/src/shaders/gradients/SkGradientShader.cpp
+++ b/src/shaders/gradients/SkGradientShader.cpp
@@ -1385,8 +1385,7 @@ GrGradientEffect::RandomGradientParams::RandomGradientParams(SkRandom* random) {
     if (fUseColors4f) {
         fColorSpace = GrTest::TestColorSpace(random);
         if (fColorSpace) {
-            SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(fColorSpace)->type());
-            fColorSpace = static_cast<SkColorSpace_XYZ*>(fColorSpace.get())->makeLinearGamma();
+            fColorSpace = fColorSpace->makeLinearGamma();
         }
     }
 
diff --git a/src/utils/SkPatchUtils.cpp b/src/utils/SkPatchUtils.cpp
index 512e8cc334..c42957ca8f 100644
--- a/src/utils/SkPatchUtils.cpp
+++ b/src/utils/SkPatchUtils.cpp
@@ -253,7 +253,7 @@ static void skcolor_to_linear(SkRGBAf dst[], const SkColor src[], int count, SkC
                               bool doPremul) {
     if (cs) {
         auto srcCS = SkColorSpace::MakeSRGB();
-        auto dstCS = as_CSB(cs)->makeLinearGamma();
+        auto dstCS = cs->makeLinearGamma();
         auto op = doPremul ? SkColorSpaceXform::kPremul_AlphaOp
                            : SkColorSpaceXform::kPreserve_AlphaOp;
         SkColorSpaceXform::Apply(dstCS.get(), SkColorSpaceXform::kRGBA_F32_ColorFormat,  dst,
@@ -271,7 +271,7 @@ static void skcolor_to_linear(SkRGBAf dst[], const SkColor src[], int count, SkC
 
 static void linear_to_skcolor(SkColor dst[], const SkRGBAf src[], int count, SkColorSpace* cs) {
     if (cs) {
-        auto srcCS = as_CSB(cs)->makeLinearGamma();
+        auto srcCS = cs->makeLinearGamma();
         auto dstCS = SkColorSpace::MakeSRGB();
         SkColorSpaceXform::Apply(dstCS.get(), SkColorSpaceXform::kBGRA_8888_ColorFormat, dst,
                                  srcCS.get(), SkColorSpaceXform::kRGBA_F32_ColorFormat,  src,