Delete SkColorSpace::ColorSpaceFlags

BUG=skia:

Change-Id: Ia0688876915cd773614ca0c4ccd467cf6e7c603e
Reviewed-on: https://skia-review.googlesource.com/10105
Commit-Queue: Matt Sarett <msarett@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>

14 files changed, 57 insertions, 169 deletions

diff --git a/src/codec/SkCodecPriv.h b/src/codec/SkCodecPriv.h
index 5bf0272f6e..af049b36d8 100644
--- a/src/codec/SkCodecPriv.h
+++ b/src/codec/SkCodecPriv.h
@@ -311,8 +311,7 @@ static inline bool needs_color_xform(const SkImageInfo& dstInfo, const SkImageIn
     bool isF16 = kRGBA_F16_SkColorType == dstInfo.colorType();
 
     // Need a color xform when dst space does not match the src.
-    bool srcDstNotEqual =
-            !SkColorSpace_Base::EqualsIgnoreFlags(srcInfo.colorSpace(), dstInfo.colorSpace());
+    bool srcDstNotEqual = !SkColorSpace::Equals(srcInfo.colorSpace(), dstInfo.colorSpace());
 
     return needsColorCorrectPremul || isF16 || srcDstNotEqual;
 }
diff --git a/src/core/SkColorSpace.cpp b/src/core/SkColorSpace.cpp
index b953ffa53d..9942406a0e 100644
--- a/src/core/SkColorSpace.cpp
+++ b/src/core/SkColorSpace.cpp
@@ -83,9 +83,8 @@ bool SkColorSpacePrimaries::toXYZD50(SkMatrix44* toXYZ_D50) const {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkData> profileData, uint32_t flags)
+SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkData> profileData)
     : fProfileData(std::move(profileData))
-    , fFlags(flags)
 {}
 
 /**
@@ -113,25 +112,21 @@ 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,
-                                               uint32_t flags)
+sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
 {
-    bool nonLinearBlending = SkToBool(flags & kNonLinearBlending_ColorSpaceFlag);
     switch (gammaNamed) {
         case kSRGB_SkGammaNamed:
             if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
-                return nonLinearBlending
-                    ? SkColorSpace_Base::MakeNamed(kSRGB_NonLinearBlending_Named)
-                    : SkColorSpace_Base::MakeNamed(kSRGB_Named);
+                return SkColorSpace_Base::MakeNamed(kSRGB_Named);
             }
             break;
         case k2Dot2Curve_SkGammaNamed:
-            if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50) && !nonLinearBlending) {
+            if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
                 return SkColorSpace_Base::MakeNamed(kAdobeRGB_Named);
             }
             break;
         case kLinear_SkGammaNamed:
-            if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50) && !nonLinearBlending) {
+            if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
                 return SkColorSpace_Base::MakeNamed(kSRGBLinear_Named);
             }
             break;
@@ -142,37 +137,36 @@ sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const Sk
             break;
     }
 
-    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, toXYZD50, flags));
+    return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(gammaNamed, toXYZD50));
 }
 
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50,
-                                          uint32_t flags) {
+sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50) {
     switch (gamma) {
         case kLinear_RenderTargetGamma:
-            return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50, flags);
+            return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50);
         case kSRGB_RenderTargetGamma:
-            return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, toXYZD50, flags);
+            return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, toXYZD50);
         default:
             return nullptr;
     }
 }
 
 sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs,
-                                          const SkMatrix44& toXYZD50, uint32_t flags) {
+                                          const SkMatrix44& toXYZD50) {
     if (!is_valid_transfer_fn(coeffs)) {
         return nullptr;
     }
 
     if (is_almost_srgb(coeffs)) {
-        return SkColorSpace::MakeRGB(kSRGB_RenderTargetGamma, toXYZD50, flags);
+        return SkColorSpace::MakeRGB(kSRGB_RenderTargetGamma, toXYZD50);
     }
 
     if (is_almost_2dot2(coeffs)) {
-        return SkColorSpace_Base::MakeRGB(k2Dot2Curve_SkGammaNamed, toXYZD50, flags);
+        return SkColorSpace_Base::MakeRGB(k2Dot2Curve_SkGammaNamed, toXYZD50);
     }
 
     if (is_almost_linear(coeffs)) {
-        return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50, flags);
+        return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, toXYZD50);
     }
 
     void* memory = sk_malloc_throw(sizeof(SkGammas) + sizeof(SkColorSpaceTransferFn));
@@ -186,32 +180,29 @@ 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, flags));
+                                                    std::move(gammas), toXYZD50, nullptr));
 }
 
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, Gamut gamut, uint32_t flags) {
+sk_sp<SkColorSpace> SkColorSpace::MakeRGB(RenderTargetGamma gamma, Gamut gamut) {
     SkMatrix44 toXYZD50(SkMatrix44::kUninitialized_Constructor);
     to_xyz_d50(&toXYZD50, gamut);
-    return SkColorSpace::MakeRGB(gamma, toXYZD50, flags);
+    return SkColorSpace::MakeRGB(gamma, toXYZD50);
 }
 
-sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs, Gamut gamut,
-                                          uint32_t flags) {
+sk_sp<SkColorSpace> SkColorSpace::MakeRGB(const SkColorSpaceTransferFn& coeffs, Gamut gamut) {
     SkMatrix44 toXYZD50(SkMatrix44::kUninitialized_Constructor);
     to_xyz_d50(&toXYZD50, gamut);
-    return SkColorSpace::MakeRGB(coeffs, toXYZD50, flags);
+    return SkColorSpace::MakeRGB(coeffs, toXYZD50);
 }
 
 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: {
@@ -221,7 +212,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, 0 /* flags */);
+                gSRGB = new SkColorSpace_XYZ(kSRGB_SkGammaNamed, srgbToxyzD50);
             });
             return sk_ref_sp<SkColorSpace>(gSRGB);
         }
@@ -232,8 +223,7 @@ 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,
-                                                 0 /* flags */);
+                gAdobeRGB = new SkColorSpace_XYZ(k2Dot2Curve_SkGammaNamed, adobergbToxyzD50);
             });
             return sk_ref_sp<SkColorSpace>(gAdobeRGB);
         }
@@ -244,23 +234,10 @@ 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,
-                                                   0 /* flags */);
+                gSRGBLinear = new SkColorSpace_XYZ(kLinear_SkGammaNamed, srgbToxyzD50);
             });
             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;
     }
@@ -300,35 +277,7 @@ bool SkColorSpace::toXYZD50(SkMatrix44* toXYZD50) const {
 }
 
 bool SkColorSpace::isSRGB() const {
-    return gSRGB == this || gSRGBNonLinearBlending == this;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-sk_sp<SkColorSpace> SkColorSpace_Base::makeWithoutFlags() {
-    if (!fFlags) {
-        return sk_ref_sp(this);
-    }
-
-    SkASSERT(Type::kXYZ == this->type());
-    SkColorSpaceTransferFn fn;
-    SkAssertResult(this->onIsNumericalTransferFn(&fn));
-    return SkColorSpace::MakeRGB(fn, *this->toXYZD50(), 0);
-}
-
-sk_sp<SkColorSpace> SkColorSpace_Base::makeWithNonLinearBlending() {
-    if (SkToBool(SkColorSpace::kNonLinearBlending_ColorSpaceFlag & fFlags)) {
-        return sk_ref_sp(this);
-    }
-
-    // This should only be called on XYZ color spaces.  A2B color spaces are never
-    // allowed to be destinations - which means that this flag does not make any
-    // sense for them.
-    SkASSERT(Type::kXYZ == this->type());
-    SkColorSpaceTransferFn fn;
-    SkAssertResult(this->onIsNumericalTransferFn(&fn));
-    return SkColorSpace::MakeRGB(fn, *this->toXYZD50(),
-                                 SkColorSpace::kNonLinearBlending_ColorSpaceFlag);
+    return gSRGB == this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -362,8 +311,7 @@ struct ColorSpaceHeader {
      */
     static constexpr uint8_t kTransferFn_Flag = 1 << 3;
 
-    static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed,
-                                 bool nonLinearBlending, uint8_t flags)
+    static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed, uint8_t flags)
     {
         ColorSpaceHeader header;
 
@@ -376,8 +324,6 @@ 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;
@@ -386,8 +332,7 @@ struct ColorSpaceHeader {
     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
+    uint8_t fFlags;
 };
 
 size_t SkColorSpace::writeToMemory(void* memory) const {
@@ -402,26 +347,19 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
         if (this == gSRGB) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kSRGB_Named, gammaNamed, false, 0);
+                        k0_Version, SkColorSpace_Base::kSRGB_Named, gammaNamed, 0);
             }
             return sizeof(ColorSpaceHeader);
         } else if (this == gAdobeRGB) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kAdobeRGB_Named, gammaNamed, false, 0);
+                        k0_Version, SkColorSpace_Base::kAdobeRGB_Named, gammaNamed, 0);
             }
             return sizeof(ColorSpaceHeader);
         } else if (this == gSRGBLinear) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        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);
+                        k0_Version, SkColorSpace_Base::kSRGBLinear_Named, gammaNamed, 0);
             }
             return sizeof(ColorSpaceHeader);
         }
@@ -434,7 +372,6 @@ 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);
@@ -453,7 +390,6 @@ 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));
 
@@ -483,7 +419,6 @@ 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));
 
@@ -519,8 +454,6 @@ 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:
@@ -531,8 +464,7 @@ 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,
-                                              colorSpaceFlags);
+            return SkColorSpace_Base::MakeRGB((SkGammaNamed) header.fGammaNamed, toXYZ);
         }
         default:
             break;
@@ -570,22 +502,13 @@ 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, colorSpaceFlags);
+            return SkColorSpace::MakeRGB(transferFn, toXYZ);
         }
         default:
             return nullptr;
     }
 }
 
-bool SkColorSpace_Base::EqualsIgnoreFlags(SkColorSpace* src, SkColorSpace* dst) {
-    if (!src || !dst) {
-        return src == dst;
-    }
-
-    return SkColorSpace::Equals(as_CSB(src)->makeWithoutFlags().get(),
-                                as_CSB(dst)->makeWithoutFlags().get());
-}
-
 bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
     if (src == dst) {
         return true;
@@ -614,9 +537,6 @@ 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/SkColorSpaceXform.cpp b/src/core/SkColorSpaceXform.cpp
index 317992036d..62cde5c393 100644
--- a/src/core/SkColorSpaceXform.cpp
+++ b/src/core/SkColorSpaceXform.cpp
@@ -318,7 +318,7 @@ std::unique_ptr<SkColorSpaceXform> SkColorSpaceXform_Base::New(SkColorSpace* src
 
     ColorSpaceMatch csm = kNone_ColorSpaceMatch;
     SkMatrix44 srcToDst(SkMatrix44::kUninitialized_Constructor);
-    if (SkColorSpace_Base::EqualsIgnoreFlags(srcSpace, dstSpace)) {
+    if (SkColorSpace::Equals(srcSpace, dstSpace)) {
         srcToDst.setIdentity();
         csm = kFull_ColorSpaceMatch;
     } else {
diff --git a/src/core/SkColorSpace_A2B.cpp b/src/core/SkColorSpace_A2B.cpp
index 11df9cc06c..7e097ffa80 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), 0)
+    : INHERITED(std::move(profileData))
     , fICCType(iccType)
     , fElements(std::move(elements))
     , fPCS(pcs)
diff --git a/src/core/SkColorSpace_Base.h b/src/core/SkColorSpace_Base.h
index f9ef360706..61f65a5983 100644
--- a/src/core/SkColorSpace_Base.h
+++ b/src/core/SkColorSpace_Base.h
@@ -180,16 +180,12 @@ public:
      */
     virtual sk_sp<SkColorSpace> makeSRGBGamma() = 0;
 
-    sk_sp<SkColorSpace> makeWithoutFlags();
-    sk_sp<SkColorSpace> makeWithNonLinearBlending();
-
     enum class Type : uint8_t {
         kXYZ,
         kA2B
     };
 
     virtual Type type() const = 0;
-    bool nonLinearBlending() const { return SkToBool(fFlags & kNonLinearBlending_ColorSpaceFlag); }
 
     typedef uint8_t ICCTypeFlag;
     static constexpr ICCTypeFlag kRGB_ICCTypeFlag  = 1 << 0;
@@ -198,8 +194,7 @@ public:
 
     static sk_sp<SkColorSpace> MakeICC(const void* input, size_t len, ICCTypeFlag type);
 
-    static sk_sp<SkColorSpace> MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
-                                       uint32_t flags);
+    static sk_sp<SkColorSpace> MakeRGB(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50);
 
     enum Named : uint8_t {
         kSRGB_Named,
@@ -210,14 +205,11 @@ public:
 
     static sk_sp<SkColorSpace> MakeNamed(Named);
 
-    static bool EqualsIgnoreFlags(SkColorSpace* src, SkColorSpace* dst);
-
 protected:
-    SkColorSpace_Base(sk_sp<SkData> profileData, uint32_t flags);
+    SkColorSpace_Base(sk_sp<SkData> profileData);
 
 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 3e080b273b..9c2082af7f 100644
--- a/src/core/SkColorSpace_ICC.cpp
+++ b/src/core/SkColorSpace_ICC.cpp
@@ -1410,11 +1410,10 @@ 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),
-                                                        0 /* flags */));
+                                                        mat, std::move(profileData)));
     }
 
-    return SkColorSpace_Base::MakeRGB(gammaNamed, mat, 0 /* flags */);
+    return SkColorSpace_Base::MakeRGB(gammaNamed, mat);
 }
 
 static sk_sp<SkColorSpace> make_gray(const ICCProfileHeader& header, ICCTag* tags, int tagCount,
@@ -1439,7 +1438,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, 0 /* flags */);
+        return SkColorSpace_Base::MakeRGB(data.fNamed, toXYZD50);
     }
 
     size_t allocSize = sizeof(SkGammas);
@@ -1456,8 +1455,7 @@ 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),
-                                                    0 /* flags */));
+                                                    toXYZD50, std::move(profileData)));
 }
 
 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 a3377683fc..baf99694b3 100644
--- a/src/core/SkColorSpace_XYZ.cpp
+++ b/src/core/SkColorSpace_XYZ.cpp
@@ -10,9 +10,8 @@
 #include "SkColorSpaceXform_Base.h"
 #include "SkOpts.h"
 
-SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50,
-                                   uint32_t flags)
-    : INHERITED(nullptr, flags)
+SkColorSpace_XYZ::SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
+    : INHERITED(nullptr)
     , fGammaNamed(gammaNamed)
     , fGammas(nullptr)
     , fToXYZD50(toXYZD50)
@@ -21,9 +20,8 @@ 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,
-                                   uint32_t flags)
-    : INHERITED(std::move(profileData), flags)
+                                   const SkMatrix44& toXYZD50, sk_sp<SkData> profileData)
+    : INHERITED(std::move(profileData))
     , fGammaNamed(gammaNamed)
     , fGammas(std::move(gammas))
     , fToXYZD50(toXYZD50)
@@ -88,14 +86,14 @@ sk_sp<SkColorSpace> SkColorSpace_XYZ::makeLinearGamma() {
     if (this->gammaIsLinear()) {
         return sk_ref_sp(this);
     }
-    return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, fToXYZD50, fFlags);
+    return SkColorSpace_Base::MakeRGB(kLinear_SkGammaNamed, fToXYZD50);
 }
 
 sk_sp<SkColorSpace> SkColorSpace_XYZ::makeSRGBGamma() {
     if (this->gammaCloseToSRGB()) {
         return sk_ref_sp(this);
     }
-    return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, fToXYZD50, fFlags);
+    return SkColorSpace_Base::MakeRGB(kSRGB_SkGammaNamed, fToXYZD50);
 }
 
 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 c1854525a1..d0ce0f813e 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, uint32_t flags);
+    SkColorSpace_XYZ(SkGammaNamed gammaNamed, const SkMatrix44& toXYZ);
 
     SkColorSpace_XYZ(SkGammaNamed gammaNamed, sk_sp<SkGammas> gammas,
-                     const SkMatrix44& toXYZ, sk_sp<SkData> profileData, uint32_t flags);
+                     const SkMatrix44& toXYZ, sk_sp<SkData> profileData);
 
 private:
     const SkGammaNamed     fGammaNamed;
diff --git a/src/core/SkRasterPipelineBlitter.cpp b/src/core/SkRasterPipelineBlitter.cpp
index fc69bf4c55..a926b43efa 100644
--- a/src/core/SkRasterPipelineBlitter.cpp
+++ b/src/core/SkRasterPipelineBlitter.cpp
@@ -23,12 +23,10 @@ public:
     static SkBlitter* Create(const SkPixmap&, const SkPaint&, const SkMatrix& ctm,
                              SkArenaAlloc*);
 
-    SkRasterPipelineBlitter(SkPixmap dst, SkBlendMode blend, SkPM4f paintColor,
-                            bool nonLinearBlending)
+    SkRasterPipelineBlitter(SkPixmap dst, SkBlendMode blend, SkPM4f paintColor)
         : fDst(dst)
         , fBlend(blend)
         , fPaintColor(paintColor)
-        , fNonLinearBlending(nonLinearBlending)
     {}
 
     void blitH    (int x, int y, int w)                            override;
@@ -49,7 +47,6 @@ private:
     SkBlendMode      fBlend;
     SkPM4f           fPaintColor;
     SkRasterPipeline fShader;
-    bool             fNonLinearBlending;
 
     // We may be able to specialize blitH() into a memset.
     bool     fCanMemsetInBlitH = false;
@@ -92,12 +89,10 @@ SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
                                            const SkPaint& paint,
                                            const SkMatrix& ctm,
                                            SkArenaAlloc* alloc) {
-    bool nonLinearBlending = dst.colorSpace() && as_CSB(dst.colorSpace())->nonLinearBlending();
     auto blitter = alloc->make<SkRasterPipelineBlitter>(
             dst,
             paint.getBlendMode(),
-            SkPM4f_from_SkColor(paint.getColor(), dst.colorSpace()),
-            nonLinearBlending);
+            SkPM4f_from_SkColor(paint.getColor(), dst.colorSpace()));
 
 
     SkBlendMode*      blend       = &blitter->fBlend;
@@ -130,11 +125,6 @@ SkBlitter* SkRasterPipelineBlitter::Create(const SkPixmap& dst,
         pipeline->append(SkRasterPipeline::constant_color, paintColor);
     }
 
-    // Some people want the rest of the pipeline to operate on sRGB encoded color channels...
-    if (nonLinearBlending && dst.info().gammaCloseToSRGB()) {
-        pipeline->append(SkRasterPipeline::to_srgb);
-    }
-
     if (colorFilter) {
         if (!colorFilter->appendStages(pipeline, dst.colorSpace(), alloc, is_opaque)) {
             return nullptr;
@@ -191,7 +181,7 @@ void SkRasterPipelineBlitter::append_load_d(SkRasterPipeline* p) const {
 }
 
 void SkRasterPipelineBlitter::append_store(SkRasterPipeline* p) const {
-    if (!fNonLinearBlending && fDst.info().gammaCloseToSRGB()) {
+    if (fDst.info().gammaCloseToSRGB()) {
         p->append(SkRasterPipeline::to_srgb);
     }
     if (fDst.info().colorType() == kBGRA_8888_SkColorType) {
diff --git a/src/gpu/GrSurfaceContext.cpp b/src/gpu/GrSurfaceContext.cpp
index d3225e3225..a28c27a649 100644
--- a/src/gpu/GrSurfaceContext.cpp
+++ b/src/gpu/GrSurfaceContext.cpp
@@ -28,7 +28,3 @@ GrSurfaceContext::GrSurfaceContext(GrContext* context,
 #endif
     , fDrawingManager(drawingMgr) {
 }
-
-bool GrSurfaceContext::isGammaCorrect() const {
-    return fColorSpace && !as_CSB(fColorSpace)->nonLinearBlending();
-}
diff --git a/src/gpu/GrSurfaceContext.h b/src/gpu/GrSurfaceContext.h
index 109c4a0ffa..88badc1c6e 100644
--- a/src/gpu/GrSurfaceContext.h
+++ b/src/gpu/GrSurfaceContext.h
@@ -34,7 +34,7 @@ public:
 
     SkColorSpace* getColorSpace() const { return fColorSpace.get(); }
     sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; }
-    bool isGammaCorrect() const;
+    bool isGammaCorrect() const { return fColorSpace; }
 
     // TODO: these two calls would be way cooler if this object had a GrSurfaceProxy pointer
     int width() const { return this->asSurfaceProxy()->width(); }
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 27fe79635e..155199812d 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -116,8 +116,7 @@ static const SkPixmap* compute_desc(const GrCaps& caps, const SkPixmap& pixmap,
     SkColorSpace* colorSpace = pixmap.colorSpace();
 
     if (caps.srgbSupport() &&
-        colorSpace && colorSpace->gammaCloseToSRGB() && !as_CSB(colorSpace)->nonLinearBlending() &&
-        !GrPixelConfigIsSRGB(desc->fConfig)) {
+        colorSpace && colorSpace->gammaCloseToSRGB() && !GrPixelConfigIsSRGB(desc->fConfig)) {
         // We were supplied an sRGB-like color space, but we don't have a suitable pixel config.
         // Convert to 8888 sRGB so we can handle the data correctly. The raster backend doesn't
         // handle sRGB Index8 -> sRGB 8888 correctly (yet), so lie about both the source and
@@ -365,12 +364,10 @@ GrPixelConfig SkImageInfo2GrPixelConfig(const SkImageInfo& info, const GrCaps& c
         case kARGB_4444_SkColorType:
             return kRGBA_4444_GrPixelConfig;
         case kRGBA_8888_SkColorType:
-            return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB() &&
-                    !as_CSB(cs)->nonLinearBlending())
+            return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB())
                    ? kSRGBA_8888_GrPixelConfig : kRGBA_8888_GrPixelConfig;
         case kBGRA_8888_SkColorType:
-            return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB() &&
-                    !as_CSB(cs)->nonLinearBlending())
+            return (caps.srgbSupport() && cs && cs->gammaCloseToSRGB())
                    ? kSBGRA_8888_GrPixelConfig : kBGRA_8888_GrPixelConfig;
         case kIndex_8_SkColorType:
             return kSkia8888_GrPixelConfig;
@@ -423,7 +420,7 @@ bool GrPixelConfigToColorType(GrPixelConfig config, SkColorType* ctOut) {
 }
 
 GrPixelConfig GrRenderableConfigForColorSpace(const SkColorSpace* colorSpace) {
-    if (!colorSpace || as_CSB(colorSpace)->nonLinearBlending()) {
+    if (!colorSpace) {
         return kRGBA_8888_GrPixelConfig;
     } else if (colorSpace->gammaIsLinear()) {
         return kRGBA_half_GrPixelConfig;
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index 566bdc092f..e45bbd7cf3 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -312,7 +312,7 @@ sk_sp<SkImage> SkImage_Base::makeColorSpace(sk_sp<SkColorSpace> target) const {
     // (1) The color spaces are equal (nullptr is considered to be sRGB).
     // (2) The color type is kAlpha8.
     if ((!this->colorSpace() && target->isSRGB()) ||
-            SkColorSpace_Base::EqualsIgnoreFlags(this->colorSpace(), target.get()) ||
+            SkColorSpace::Equals(this->colorSpace(), target.get()) ||
             kAlpha_8_SkColorType == this->onImageInfo().colorType()) {
         return sk_ref_sp(const_cast<SkImage_Base*>(this));
     }
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index fdbbf82779..cef355e091 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -186,15 +186,13 @@ bool SkSurface_Gpu::Valid(GrContext* context, GrPixelConfig config, SkColorSpace
             return !colorSpace || colorSpace->gammaIsLinear();
         case kSRGBA_8888_GrPixelConfig:
         case kSBGRA_8888_GrPixelConfig:
-            return context->caps()->srgbSupport() && colorSpace && colorSpace->gammaCloseToSRGB() &&
-                   !as_CSB(colorSpace)->nonLinearBlending();
+            return context->caps()->srgbSupport() && colorSpace && colorSpace->gammaCloseToSRGB();
         case kRGBA_8888_GrPixelConfig:
         case kBGRA_8888_GrPixelConfig:
             // If we don't have sRGB support, we may get here with a color space. It still needs
             // to be sRGB-like (so that the application will work correctly on sRGB devices.)
             return !colorSpace ||
-                (colorSpace->gammaCloseToSRGB() && (!context->caps()->srgbSupport() ||
-                                                    !as_CSB(colorSpace)->nonLinearBlending()));
+                (colorSpace->gammaCloseToSRGB() && !context->caps()->srgbSupport());
         default:
             return !colorSpace;
     }