Remove SkColorSpace_Base::MakeNamed, along with most uses of Adobe RGB

Bug: skia:
Change-Id: Ic914aacc4c47200714d66cf4487932bcb8a7693a
Reviewed-on: https://skia-review.googlesource.com/85040
Commit-Queue: Mike Klein <mtklein@chromium.org>
Reviewed-by: Mike Klein <mtklein@chromium.org>

1 files changed, 25 insertions, 29 deletions

diff --git a/src/core/SkColorSpace.cpp b/src/core/SkColorSpace.cpp
index 06ec26d101..e9efffd96d 100644
--- a/src/core/SkColorSpace.cpp
+++ b/src/core/SkColorSpace.cpp
@@ -116,17 +116,19 @@ sk_sp<SkColorSpace> SkColorSpace_Base::MakeRGB(SkGammaNamed gammaNamed, const Sk
     switch (gammaNamed) {
         case kSRGB_SkGammaNamed:
             if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
-                return SkColorSpace_Base::MakeNamed(kSRGB_Named);
+                return SkColorSpace::MakeSRGB();
             }
             break;
         case k2Dot2Curve_SkGammaNamed:
             if (xyz_almost_equal(toXYZD50, gAdobeRGB_toXYZD50)) {
-                return SkColorSpace_Base::MakeNamed(kAdobeRGB_Named);
+                SkMatrix44 adobe44(SkMatrix44::kUninitialized_Constructor);
+                adobe44.set3x3RowMajorf(gAdobeRGB_toXYZD50);
+                return sk_sp<SkColorSpace>(new SkColorSpace_XYZ(k2Dot2Curve_SkGammaNamed, adobe44));
             }
             break;
         case kLinear_SkGammaNamed:
             if (xyz_almost_equal(toXYZD50, gSRGB_toXYZD50)) {
-                return SkColorSpace_Base::MakeNamed(kSRGBLinear_Named);
+                return SkColorSpace::MakeSRGBLinear();
             }
             break;
         case kNonStandard_SkGammaNamed:
@@ -201,10 +203,6 @@ static SkColorSpace* singleton_colorspace(SkGammaNamed gamma, const float to_xyz
     return new SkColorSpace_XYZ(gamma, m44);
 }
 
-static SkColorSpace* adobe_rgb() {
-    static SkColorSpace* cs = singleton_colorspace(k2Dot2Curve_SkGammaNamed, gAdobeRGB_toXYZD50);
-    return cs;
-}
 static SkColorSpace* srgb() {
     static SkColorSpace* cs = singleton_colorspace(kSRGB_SkGammaNamed, gSRGB_toXYZD50);
     return cs;
@@ -214,22 +212,12 @@ static SkColorSpace* srgb_linear() {
     return cs;
 }
 
-sk_sp<SkColorSpace> SkColorSpace_Base::MakeNamed(Named named) {
-    switch (named) {
-        case kSRGB_Named:       return sk_ref_sp(srgb());
-        case kAdobeRGB_Named:   return sk_ref_sp(adobe_rgb());
-        case kSRGBLinear_Named: return sk_ref_sp(srgb_linear());
-        default: break;
-    }
-    return nullptr;
-}
-
 sk_sp<SkColorSpace> SkColorSpace::MakeSRGB() {
-    return SkColorSpace_Base::MakeNamed(SkColorSpace_Base::kSRGB_Named);
+    return sk_ref_sp(srgb());
 }
 
 sk_sp<SkColorSpace> SkColorSpace::MakeSRGBLinear() {
-    return SkColorSpace_Base::MakeNamed(SkColorSpace_Base::kSRGBLinear_Named);
+    return sk_ref_sp(srgb_linear());
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -290,6 +278,13 @@ enum Version {
     k0_Version, // Initial version, header + flags for matrix and profile
 };
 
+enum NamedColorSpace {
+    kSRGB_NamedColorSpace,
+    // No longer a singleton, preserved to support reading data from branches m65 and older
+    kAdobeRGB_NamedColorSpace,
+    kSRGBLinear_NamedColorSpace,
+};
+
 struct ColorSpaceHeader {
     /**
      *  It is only valid to set zero or one flags.
@@ -322,7 +317,7 @@ struct ColorSpaceHeader {
         SkASSERT(k0_Version == version);
         header.fVersion = (uint8_t) version;
 
-        SkASSERT(named <= SkColorSpace_Base::kSRGBLinear_Named);
+        SkASSERT(named <= kSRGBLinear_NamedColorSpace);
         header.fNamed = (uint8_t) named;
 
         SkASSERT(gammaNamed <= kNonStandard_SkGammaNamed);
@@ -351,19 +346,13 @@ size_t SkColorSpace::writeToMemory(void* memory) const {
         if (this == srgb()) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kSRGB_Named, gammaNamed, 0);
-            }
-            return sizeof(ColorSpaceHeader);
-        } else if (this == adobe_rgb()) {
-            if (memory) {
-                *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kAdobeRGB_Named, gammaNamed, 0);
+                        k0_Version, kSRGB_NamedColorSpace, gammaNamed, 0);
             }
             return sizeof(ColorSpaceHeader);
         } else if (this == srgb_linear()) {
             if (memory) {
                 *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(
-                        k0_Version, SkColorSpace_Base::kSRGBLinear_Named, gammaNamed, 0);
+                        k0_Version, kSRGBLinear_NamedColorSpace, gammaNamed, 0);
             }
             return sizeof(ColorSpaceHeader);
         }
@@ -455,7 +444,14 @@ sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
     data = SkTAddOffset<const void>(data, sizeof(ColorSpaceHeader));
     length -= sizeof(ColorSpaceHeader);
     if (0 == header.fFlags) {
-        return SkColorSpace_Base::MakeNamed((SkColorSpace_Base::Named) header.fNamed);
+        switch ((NamedColorSpace)header.fNamed) {
+            case kSRGB_NamedColorSpace:
+                return SkColorSpace::MakeSRGB();
+            case kSRGBLinear_NamedColorSpace:
+                return SkColorSpace::MakeSRGBLinear();
+            case kAdobeRGB_NamedColorSpace:
+                return SkColorSpace::MakeRGB(g2Dot2_TransferFn, SkColorSpace::kAdobeRGB_Gamut);
+        }
     }
 
     switch ((SkGammaNamed) header.fGammaNamed) {