Non linear blending flag for SkColorSpace

BUG=skia:6242

Change-Id: I63cce6019ce854ba807b2a819ef4fe3214898bee
Reviewed-on: https://skia-review.googlesource.com/8344
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Reed <reed@google.com>
Reviewed-by: Matt Sarett <msarett@google.com>

9 files changed, 102 insertions, 47 deletions

diff --git a/include/core/SkColorSpace.h b/include/core/SkColorSpace.h
index 8cc20c40c9..86389f22f9 100644
--- a/include/core/SkColorSpace.h
+++ b/include/core/SkColorSpace.h
@@ -81,6 +81,10 @@ public:
         kRec2020_Gamut,
     };
 
+    enum ColorSpaceFlags {
+        kNonLinearBlending_ColorSpaceFlag = 0x1,
+    };
+
     /**
      *  Create an SkColorSpace from a transfer function and a color gamut.
      *
@@ -88,10 +92,11 @@ public:
      *  Gamut can be specified as an enum or as the matrix transformation to XYZ D50.
      */
     static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, Gamut gamut);
-    static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50);
+    static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50,
+                                       uint32_t flags = 0);
     static sk_sp<SkColorSpace> MakeRGB(const SkColorSpaceTransferFn& coeffs, Gamut gamut);
     static sk_sp<SkColorSpace> MakeRGB(const SkColorSpaceTransferFn& coeffs,
-                                       const SkMatrix44& toXYZD50);
+                                       const SkMatrix44& toXYZD50, uint32_t flags = 0);
 
     /**
      *  Create an SkColorSpace from an ICC profile.
diff --git a/src/core/SkColorSpace.cpp b/src/core/SkColorSpace.cpp
index 6c0890f178..80c5ac133e 100644
--- a/src/core/SkColorSpace.cpp
+++ b/src/core/SkColorSpace.cpp
@@ -83,8 +83,9 @@ bool SkColorSpacePrimaries::toXYZD50(SkMatrix44* toXYZ_D50) const {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkData> profileData)
+SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkData> profileData, uint32_t flags)
     : fProfileData(std::move(profileData))
+    , fFlags(flags)
 {}
 
 /**
@@ -112,21 +113,25 @@ static bool xyz_almost_equal(const SkMatrix44& toXYZD50, const float* standard)
            color_space_almost_equal(toXYZD50.getFloat(3, 3), 1.0f);
 }
 
-sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
+sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
+                                               uint32_t flags)
 {
+    bool nonLinearBlending = SkToBool(flags & kNonLinearBlending_ColorSpaceFlag);
     switch (gammaNamed) {
         case kSRGB_SkGammaNamed:
             if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
-                return SkColorSpace_Base::MakeNamed(kSRGB_Named);
+                return nonLinearBlending
+                    ? SkColorSpace_Base::MakeNamed(kSRGB_NonLinearBlending_Named)
+                    : SkColorSpace_Base::MakeNamed(kSRGB_Named);
             }
             break;
         case k2Dot2Curve_SkGammaNamed:
-            if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
+            if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50) && !nonLinearBlending) {
                 return SkColorSpace_Base::MakeNamed(kAdobeRGB_Named);
             }
             break;
         case kLinear_SkGammaNamed:
-            if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
+            if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50) && !nonLinearBlending) {
                 return SkColorSpace_Base::MakeNamed(kSRGBLinear_Named);
             }
             break;
@@ -137,36 +142,37 @@ sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const Sk
             break;
     }
 
-    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, toXYZD50));
+    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, toXYZD50, flags));
 }
 
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50) {
+sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50,
+                                          uint32_t flags) {
     switch (gamma) {
         case kLinear_RenderTargetGamma:
-            return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50);
+            return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50, flags);
         case kSRGB_RenderTargetGamma:
-            return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, toXYZD50);
+            return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, toXYZD50, flags);
         default:
             return nullptr;
     }
 }
 
 sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs,
-                                          const SkMatrix44& toXYZD50) {
+                                          const SkMatrix44& toXYZD50, uint32_t flags) {
     if (!is_valid_transfer_fn(coeffs)) {
         return nullptr;
     }
 
     if (is_almost_srgb(coeffs)) {
-        return SkColorSpace::MakeRGB(kSRGB_RenderTargetGamma, toXYZD50);
+        return SkColorSpace::MakeRGB(kSRGB_RenderTargetGamma, toXYZD50, flags);
     }
 
     if (is_almost_2dot2(coeffs)) {
-        return SkColorSpace_Base::MakeRGB(k2Dot2Curve_SkGammaNamed, toXYZD50);
+        return SkColorSpace_Base::MakeRGB(k2Dot2Curve_SkGammaNamed, toXYZD50, flags);
     }
 
     if (is_almost_linear(coeffs)) {
-        return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50);
+        return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50, flags);
     }
 
     void* memory = sk_malloc_throw(sizeof(SkGammas) + sizeof(SkColorSpaceTransferFn));
@@ -180,7 +186,7 @@ sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs,
         gammas->fData[channel] = data;
     }
     return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(kNonStandard_SkGammaNamed,
-                                                    std::move(gammas), toXYZD50, nullptr));
+                                                    std::move(gammas), toXYZD50, nullptr, flags));
 }
 
 sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, Gamut gamut) {
@@ -198,11 +204,13 @@ sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs,
 static SkColorSpace* gAdobeRGB;
 static SkColorSpace* gSRGB;
 static SkColorSpace* gSRGBLinear;
+static SkColorSpace* gSRGBNonLinearBlending;
 
 sk_sp<SkColorSpace> SkColorSpace_Base::MakeNamed(Named named) {
     static SkOnce sRGBOnce;
     static SkOnce adobeRGBOnce;
     static SkOnce sRGBLinearOnce;
+    static SkOnce sRGBNonLinearBlendingOnce;
 
     switch (named) {
         case kSRGB_Named: {
@@ -212,7 +220,7 @@ sk_sp<SkColorSpace> SkColorSpace_Base::MakeNamed(Named named) {
 
                 // Force the mutable type mask to be computed.  This avoids races.
                 (void)srgbToxyzD50.getType();
-                gSRGB = new SkColorSpace_XYZ(kSRGB_SkGammaNamed, srgbToxyzD50);
+                gSRGB = new SkColorSpace_XYZ(kSRGB_SkGammaNamed, srgbToxyzD50, 0 /* flags */);
             });
             return sk_ref_sp<SkColorSpace>(gSRGB);
         }
@@ -223,7 +231,8 @@ sk_sp<SkColorSpace> SkColorSpace_Base::MakeNamed(Named named) {
 
                 // Force the mutable type mask to be computed.  This avoids races.
                 (void)adobergbToxyzD50.getType();
-                gAdobeRGB = new SkColorSpace_XYZ(k2Dot2Curve_SkGammaNamed, adobergbToxyzD50);
+                gAdobeRGB = new SkColorSpace_XYZ(k2Dot2Curve_SkGammaNamed, adobergbToxyzD50,
+                                                 0 /* flags */);
             });
             return sk_ref_sp<SkColorSpace>(gAdobeRGB);
         }
@@ -234,10 +243,23 @@ sk_sp<SkColorSpace> SkColorSpace_Base::MakeNamed(Named named) {
 
                 // Force the mutable type mask to be computed.  This avoids races.
                 (void)srgbToxyzD50.getType();
-                gSRGBLinear = new SkColorSpace_XYZ(kLinear_SkGammaNamed, srgbToxyzD50);
+                gSRGBLinear = new SkColorSpace_XYZ(kLinear_SkGammaNamed, srgbToxyzD50,
+                                                   0 /* flags */);
             });
             return sk_ref_sp<SkColorSpace>(gSRGBLinear);
         }
+        case kSRGB_NonLinearBlending_Named: {
+            sRGBNonLinearBlendingOnce([] {
+                SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
+                srgbToxyzD50.set3x3RowMajorf(gSRGB_toXYZD50);
+
+                // Force the mutable type mask to be computed.  This avoids races.
+                (void)srgbToxyzD50.getType();
+                gSRGBNonLinearBlending = new SkColorSpace_XYZ(kSRGB_SkGammaNamed, srgbToxyzD50,
+                                                              kNonLinearBlending_ColorSpaceFlag);
+            });
+            return sk_ref_sp<SkColorSpace>(gSRGBNonLinearBlending);
+        }
         default:
             break;
     }
@@ -303,7 +325,8 @@ struct ColorSpaceHeader {
      */
     static constexpr uint8_t kTransferFn_Flag = 1 << 3;
 
-    static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed, uint8_t flags)
+    static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed,
+                                 bool nonLinearBlending, uint8_t flags)
     {
         ColorSpaceHeader header;
 
@@ -316,15 +339,18 @@ struct ColorSpaceHeader {
         SkASSERT(gammaNamed <= kNonStandard_SkGammaNamed);
         header.fGammaNamed = (uint8_t) gammaNamed;
 
+        header.fNonLinearBlend = nonLinearBlending ? 1 : 0;
+
         SkASSERT(flags <= kTransferFn_Flag);
         header.fFlags = flags;
         return header;
     }
 
-    uint8_t fVersion;    // Always zero
-    uint8_t fNamed;      // Must be a SkColorSpace::Named
-    uint8_t fGammaNamed; // Must be a SkGammaNamed
-    uint8_t fFlags;      // Some combination of the flags listed above
+    uint8_t fVersion;            // Always zero
+    uint8_t fNamed;              // Must be a SkColorSpace::Named
+    uint8_t fGammaNamed;         // Must be a SkGammaNamed
+    uint8_t fNonLinearBlend : 1; // kNonLinearBlending_ColorSpaceFlag
+    uint8_t fFlags          : 7; // Some combination of the flags listed above
 };
 
 size_t SkColorSpace::writeToMemory(void* memory) const {
@@ -339,19 +365,26 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
         if (this == gSRGB) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kSRGB_Named, gammaNamed, 0);
+                        k0_Version, SkColorSpace_Base::kSRGB_Named, gammaNamed, false, 0);
             }
             return sizeof(ColorSpaceHeader);
         } else if (this == gAdobeRGB) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kAdobeRGB_Named, gammaNamed, 0);
+                        k0_Version, SkColorSpace_Base::kAdobeRGB_Named, gammaNamed, false, 0);
             }
             return sizeof(ColorSpaceHeader);
         } else if (this == gSRGBLinear) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kSRGBLinear_Named, gammaNamed, 0);
+                        k0_Version, SkColorSpace_Base::kSRGBLinear_Named, gammaNamed, false, 0);
+            }
+            return sizeof(ColorSpaceHeader);
+        } else if (this == gSRGBNonLinearBlending) {
+            if (memory) {
+                *((ColorSpaceHeader*)memory) = ColorSpaceHeader::Pack(
+                        k0_Version, SkColorSpace_Base::kSRGB_NonLinearBlending_Named, gammaNamed,
+                        true, 0);
             }
             return sizeof(ColorSpaceHeader);
         }
@@ -364,6 +397,7 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
                             ColorSpaceHeader::Pack(k0_Version, 0, gammaNamed,
+                                                   thisXYZ->nonLinearBlending(),
                                                    ColorSpaceHeader::kMatrix_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
                     thisXYZ->toXYZD50()->as3x4RowMajorf((float*) memory);
@@ -382,6 +416,7 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
                             ColorSpaceHeader::Pack(k0_Version, 0, thisXYZ->fGammaNamed,
+                                                   thisXYZ->nonLinearBlending(),
                                                    ColorSpaceHeader::kTransferFn_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
@@ -411,6 +446,7 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
     if (memory) {
         *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(k0_Version, 0,
                                                                kNonStandard_SkGammaNamed,
+                                                               as_CSB(this)->nonLinearBlending(),
                                                                ColorSpaceHeader::kICC_Flag);
         memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
@@ -446,6 +482,8 @@ sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
         return SkColorSpace_Base::MakeNamed((SkColorSpace_Base::Named) header.fNamed);
     }
 
+    uint32_t colorSpaceFlags = header.fNonLinearBlend ? kNonLinearBlending_ColorSpaceFlag : 0;
+
     switch ((SkGammaNamed) header.fGammaNamed) {
         case kSRGB_SkGammaNamed:
         case k2Dot2Curve_SkGammaNamed:
@@ -456,7 +494,8 @@ sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
 
             SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
             toXYZ.set3x4RowMajorf((const float*) data);
-            return SkColorSpace_Base::MakeRGB((SkGammaNamed) header.fGammaNamed, toXYZ);
+            return SkColorSpace_Base::MakeRGB((SkGammaNamed) header.fGammaNamed, toXYZ,
+                                              colorSpaceFlags);
         }
         default:
             break;
@@ -494,7 +533,7 @@ sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
 
             SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
             toXYZ.set3x4RowMajorf((const float*) data);
-            return SkColorSpace::MakeRGB(transferFn, toXYZ);
+            return SkColorSpace::MakeRGB(transferFn, toXYZ, colorSpaceFlags);
         }
         default:
             return nullptr;
@@ -529,6 +568,9 @@ bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
     if (srcXYZ->gammaNamed() != dstXYZ->gammaNamed()) {
         return false;
     }
+    if (srcXYZ->nonLinearBlending() != dstXYZ->nonLinearBlending()) {
+        return false;
+    }
 
     switch (srcXYZ->gammaNamed()) {
         case kSRGB_SkGammaNamed:
diff --git a/src/core/SkColorSpace_A2B.cpp b/src/core/SkColorSpace_A2B.cpp
index 7e097ffa80..11df9cc06c 100644
--- a/src/core/SkColorSpace_A2B.cpp
+++ b/src/core/SkColorSpace_A2B.cpp
@@ -9,7 +9,7 @@
 
 SkColorSpace_A2B::SkColorSpace_A2B(ICCTypeFlag iccType, std::vector<Element> elements,
                                    PCS pcs, sk_sp<SkData> profileData)
-    : INHERITED(std::move(profileData))
+    : INHERITED(std::move(profileData), 0)
     , fICCType(iccType)
     , fElements(std::move(elements))
     , fPCS(pcs)
diff --git a/src/core/SkColorSpace_Base.h b/src/core/SkColorSpace_Base.h
index b1fa93aa7a..1d3c2729d0 100644
--- a/src/core/SkColorSpace_Base.h
+++ b/src/core/SkColorSpace_Base.h
@@ -184,6 +184,7 @@ public:
     };
 
     virtual Type type() const = 0;
+    bool nonLinearBlending() const { return SkToBool(fFlags & kNonLinearBlending_ColorSpaceFlag); }
 
     typedef uint8_t ICCTypeFlag;
     static constexpr ICCTypeFlag kRGB_ICCTypeFlag  = 1 << 0;
@@ -192,21 +193,24 @@ public:
 
     static sk_sp<SkColorSpace> MakeICC(const void* input, size_t len, ICCTypeFlag type);
 
-    static sk_sp<SkColorSpace> MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50);
+    static sk_sp<SkColorSpace> MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
+                                       uint32_t flags);
 
     enum Named : uint8_t {
         kSRGB_Named,
         kAdobeRGB_Named,
         kSRGBLinear_Named,
+        kSRGB_NonLinearBlending_Named,
     };
 
     static sk_sp<SkColorSpace> MakeNamed(Named);
 
 protected:
-    SkColorSpace_Base(sk_sp<SkData> profileData);
+    SkColorSpace_Base(sk_sp<SkData> profileData, uint32_t flags);
 
 private:
     sk_sp<SkData> fProfileData;
+    uint32_t fFlags;
 
     friend class SkColorSpace;
     friend class SkColorSpace_XYZ;
diff --git a/src/core/SkColorSpace_ICC.cpp b/src/core/SkColorSpace_ICC.cpp
index 9c2082af7f..3e080b273b 100644
--- a/src/core/SkColorSpace_ICC.cpp
+++ b/src/core/SkColorSpace_ICC.cpp
@@ -1410,10 +1410,11 @@ static sk_sp<SkColorSpace> make_xyz(const ICCProfileHeader& header, ICCTag* tags
     if (kNonStandard_SkGammaNamed == gammaNamed) {
         return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed,
                                                         std::move(gammas),
-                                                        mat, std::move(profileData)));
+                                                        mat, std::move(profileData),
+                                                        0 /* flags */));
     }
 
-    return SkColorSpace_Base::MakeRGB(gammaNamed, mat);
+    return SkColorSpace_Base::MakeRGB(gammaNamed, mat, 0 /* flags */);
 }
 
 static sk_sp<SkColorSpace> make_gray(const ICCProfileHeader& header, ICCTag* tags, int tagCount,
@@ -1438,7 +1439,7 @@ static sk_sp<SkColorSpace> make_gray(const ICCProfileHeader& header, ICCTag* tag
     toXYZD50.setFloat(1, 1, kWhitePointD50[1]);
     toXYZD50.setFloat(2, 2, kWhitePointD50[2]);
     if (SkGammas::Type::kNamed_Type == type) {
-        return SkColorSpace_Base::MakeRGB(data.fNamed, toXYZD50);
+        return SkColorSpace_Base::MakeRGB(data.fNamed, toXYZD50, 0 /* flags */);
     }
 
     size_t allocSize = sizeof(SkGammas);
@@ -1455,7 +1456,8 @@ static sk_sp<SkColorSpace> make_gray(const ICCProfileHeader& header, ICCTag* tag
 
     return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(kNonStandard_SkGammaNamed,
                                                     std::move(gammas),
-                                                    toXYZD50, std::move(profileData)));
+                                                    toXYZD50, std::move(profileData),
+                                                    0 /* flags */));
 }
 
 static sk_sp<SkColorSpace> make_a2b(SkColorSpace_Base::ICCTypeFlag iccType,
diff --git a/src/core/SkColorSpace_XYZ.cpp b/src/core/SkColorSpace_XYZ.cpp
index baf99694b3..a3377683fc 100644
--- a/src/core/SkColorSpace_XYZ.cpp
+++ b/src/core/SkColorSpace_XYZ.cpp
@@ -10,8 +10,9 @@
 #include "SkColorSpaceXform_Base.h"
 #include "SkOpts.h"
 
-SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
-    : INHERITED(nullptr)
+SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
+                                   uint32_t flags)
+    : INHERITED(nullptr, flags)
     , fGammaNamed(gammaNamed)
     , fGammas(nullptr)
     , fToXYZD50(toXYZD50)
@@ -20,8 +21,9 @@ SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& to
 {}
 
 SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, sk_sp<SkGammas> gammas,
-                                   const SkMatrix44& toXYZD50, sk_sp<SkData> profileData)
-    : INHERITED(std::move(profileData))
+                                   const SkMatrix44& toXYZD50, sk_sp<SkData> profileData,
+                                   uint32_t flags)
+    : INHERITED(std::move(profileData), flags)
     , fGammaNamed(gammaNamed)
     , fGammas(std::move(gammas))
     , fToXYZD50(toXYZD50)
@@ -86,14 +88,14 @@ sk_sp<SkColorSpace> SkColorSpace_XYZ::makeLinearGamma() {
     if (this->gammaIsLinear()) {
         return sk_ref_sp(this);
     }
-    return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, fToXYZD50);
+    return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, fToXYZD50, fFlags);
 }
 
 sk_sp<SkColorSpace> SkColorSpace_XYZ::makeSRGBGamma() {
     if (this->gammaCloseToSRGB()) {
         return sk_ref_sp(this);
     }
-    return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, fToXYZD50);
+    return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, fToXYZD50, fFlags);
 }
 
 void SkColorSpace_XYZ::toDstGammaTables(const uint8_t* tables[3], sk_sp<SkData>* storage,
diff --git a/src/core/SkColorSpace_XYZ.h b/src/core/SkColorSpace_XYZ.h
index d0ce0f813e..c1854525a1 100644
--- a/src/core/SkColorSpace_XYZ.h
+++ b/src/core/SkColorSpace_XYZ.h
@@ -36,10 +36,10 @@ public:
 
     void toDstGammaTables(const uint8_t* tables[3], sk_sp<SkData>* storage, int numTables) const;
 
-    SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZ);
+    SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZ, uint32_t flags);
 
     SkColorSpace_XYZ(SkGammaNamed gammaNamed, sk_sp<SkGammas> gammas,
-                     const SkMatrix44& toXYZ, sk_sp<SkData> profileData);
+                     const SkMatrix44& toXYZ, sk_sp<SkData> profileData, uint32_t flags);
 
 private:
     const SkGammaNamed     fGammaNamed;
diff --git a/tests/ColorSpaceXformTest.cpp b/tests/ColorSpaceXformTest.cpp
index f8a5c8fec4..03c8f494d2 100644
--- a/tests/ColorSpaceXformTest.cpp
+++ b/tests/ColorSpaceXformTest.cpp
@@ -23,7 +23,7 @@ public:
     static std::unique_ptr<SkColorSpaceXform> CreateIdentityXform(const sk_sp<SkGammas>& gammas) {
         // Logically we can pass any matrix here.  For simplicty, pass I(), i.e. D50 XYZ gamut.
         sk_sp<SkColorSpace> space(new SkColorSpace_XYZ(
-                kNonStandard_SkGammaNamed, gammas, SkMatrix::I(), nullptr));
+                kNonStandard_SkGammaNamed, gammas, SkMatrix::I(), nullptr, 0 /* flags */));
 
         // Use special testing entry point, so we don't skip the xform, even though src == dst.
         return SlowIdentityXform(static_cast<SkColorSpace_XYZ*>(space.get()));
@@ -53,7 +53,7 @@ public:
                                                     SkColorSpace_Base::kRGB_ICCTypeFlag,
                                                     std::move(srcElements));
         sk_sp<SkColorSpace> dstSpace(new SkColorSpace_XYZ(gammaNamed, gammas, arbitraryMatrix,
-                                                          nullptr));
+                                                          nullptr, 0 /* flags */));
 
         return SkColorSpaceXform::New(static_cast<SkColorSpace_A2B*>(srcSpace.get()),
                                       static_cast<SkColorSpace_XYZ*>(dstSpace.get()));
diff --git a/tests/ICCTest.cpp b/tests/ICCTest.cpp
index 5d541bdc27..e2f845c711 100644
--- a/tests/ICCTest.cpp
+++ b/tests/ICCTest.cpp
@@ -161,7 +161,7 @@ public:
     static sk_sp<SkICC> MakeICC(sk_sp<SkGammas> gammas) {
         return MakeICC(sk_sp<SkColorSpace>(new SkColorSpace_XYZ(
                 kNonStandard_SkGammaNamed, std::move(gammas),
-                SkMatrix44(SkMatrix44::kIdentity_Constructor), nullptr)));
+                SkMatrix44(SkMatrix44::kIdentity_Constructor), nullptr, 0 /* flags */)));
     }
 };