Delete SkColorSpace::kUnknown_Named, remove fNamed field

src/core/SkColorSpace.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorSpace.h"
 #include "SkColorSpace_Base.h"
 #include "SkColorSpacePriv.h"
 #include "SkOnce.h"
 
-SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
+SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50)
     : fGammaNamed(gammaNamed)
     , fToXYZD50(toXYZD50)
-    , fNamed(named)
 {}
 
-SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
-    : INHERITED(gammaNamed, toXYZD50, named)
+SkColorSpace_Base::SkColorSpace_Base(GammaNamed gammaNamed, const SkMatrix44& toXYZD50)
+    : INHERITED(gammaNamed, toXYZD50)
     , fGammas(nullptr)
     , fProfileData(nullptr)
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, GammaNamed gammaNamed,
                                      sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
                                      sk_sp<SkData> profileData)
-    : INHERITED(gammaNamed, toXYZD50, kUnknown_Named)
+    : INHERITED(gammaNamed, toXYZD50)
     , fColorLUT(std::move(colorLUT))
     , fGammas(std::move(gammas))
     , fProfileData(std::move(profileData))
 {}
 
 static constexpr float gSRGB_toXYZD50[] {
     0.4358f, 0.2224f, 0.0139f,    // * R
     0.3853f, 0.7170f, 0.0971f,    // * G
     0.1430f, 0.0606f, 0.7139f,    // * B
 };
@@ skipping 72 matching lines @@
                 return SkColorSpace::NewNamed(kAdobeRGB_Named);
             }
             break;
         case kNonStandard_GammaNamed:
             // This is not allowed.
             return nullptr;
         default:
             break;
     }
 
-    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammaNamed, toXYZD50, kUnknown_Named));
+    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammaNamed, toXYZD50));
 }
 
 sk_sp<SkColorSpace> SkColorSpace::NewRGB(GammaNamed gammaNamed, const SkMatrix44& toXYZD50) {
     return SkColorSpace_Base::NewRGB(gammaNamed, toXYZD50);
 }
 
+static SkColorSpace* gAdobeRGB;
+static SkColorSpace* gSRGB;
+
 sk_sp<SkColorSpace> SkColorSpace::NewNamed(Named named) {
     static SkOnce sRGBOnce;
-    static sk_sp<SkColorSpace> sRGB;
     static SkOnce adobeRGBOnce;
-    static sk_sp<SkColorSpace> adobeRGB;
 
     switch (named) {
         case kSRGB_Named: {
             sRGBOnce([] {
                 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 srgbToxyzD50.set3x3RowMajorf(gSRGB_toXYZD50);
 
                 // Force the mutable type mask to be computed.  This avoids races.
                 (void)srgbToxyzD50.getType();
-                sRGB.reset(new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50, kSRGB_Named));
+                gSRGB = new SkColorSpace_Base(kSRGB_GammaNamed, srgbToxyzD50);
             });
-            return sRGB;
+            return sk_ref_sp<SkColorSpace>(gSRGB);
         }
         case kAdobeRGB_Named: {
             adobeRGBOnce([] {
                 SkMatrix44 adobergbToxyzD50(SkMatrix44::kUninitialized_Constructor);
                 adobergbToxyzD50.set3x3RowMajorf(gAdobeRGB_toXYZD50);
 
                 // Force the mutable type mask to be computed.  This avoids races.
                 (void)adobergbToxyzD50.getType();
-                adobeRGB.reset(new SkColorSpace_Base(k2Dot2Curve_GammaNamed, adobergbToxyzD50,
-                                                     kAdobeRGB_Named));
+                gAdobeRGB = new SkColorSpace_Base(k2Dot2Curve_GammaNamed, adobergbToxyzD50);
             });
-            return adobeRGB;
+            return sk_ref_sp<SkColorSpace>(gAdobeRGB);
         }
         default:
             break;
     }
     return nullptr;
 }
 
 sk_sp<SkColorSpace> SkColorSpace::makeLinearGamma() {
     return SkColorSpace_Base::NewRGB(kLinear_GammaNamed, fToXYZD50);
 }
@@ skipping 20 matching lines @@
     static constexpr uint8_t kICC_Flag        = 1 << 1;
 
     /**
      *  If kFloatGamma_Flag is set, we will write 15 floats after the header.
      *  The first three are the gamma values, and the next twelve are the
      *  matrix.
      *  Should not be set at the same time as the kICC_Flag or kMatrix_Flag.
      */
     static constexpr uint8_t kFloatGamma_Flag = 1 << 2;
 
-    static ColorSpaceHeader Pack(Version version, SkColorSpace::Named named,
-                                 SkColorSpace::GammaNamed gammaNamed, uint8_t flags) {
+    static ColorSpaceHeader Pack(Version version, uint8_t named, uint8_t gammaNamed, uint8_t flags)
+    {
         ColorSpaceHeader header;
 
         SkASSERT(k0_Version == version);
         header.fVersion = (uint8_t) version;
 
         SkASSERT(named <= SkColorSpace::kAdobeRGB_Named);
         header.fNamed = (uint8_t) named;
 
         SkASSERT(gammaNamed <= SkColorSpace::kNonStandard_GammaNamed);
         header.fGammaNamed = (uint8_t) gammaNamed;
 
         SkASSERT(flags <= kFloatGamma_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 SkColorSpace::GammaNamed
     uint8_t fFlags;      // Some combination of the flags listed above
 };
 
 size_t SkColorSpace::writeToMemory(void* memory) const {
     // Start by trying the serialization fast path.  If we haven't saved ICC profile data,
     // we must have a profile that we can serialize easily.
     if (!as_CSB(this)->fProfileData) {
         // If we have a named profile, only write the enum.
-        switch (fNamed) {
-            case kSRGB_Named:
-            case kAdobeRGB_Named: {
-                if (memory) {
-                    *((ColorSpaceHeader*) memory) =
-                            ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed, 0);
-                }
-                return sizeof(ColorSpaceHeader);
+        if (this == gSRGB) {
+            if (memory) {
+                *((ColorSpaceHeader*) memory) =
+                        ColorSpaceHeader::Pack(k0_Version, kSRGB_Named, fGammaNamed, 0);
             }
-            default:
-                break;
+            return sizeof(ColorSpaceHeader);
+        } else if (this == gAdobeRGB) {
+            if (memory) {
+                *((ColorSpaceHeader*) memory) =
+                        ColorSpaceHeader::Pack(k0_Version, kAdobeRGB_Named, fGammaNamed, 0);
+            }
         }
 
         // If we have a named gamma, write the enum and the matrix.
         switch (fGammaNamed) {
             case kSRGB_GammaNamed:
             case k2Dot2Curve_GammaNamed:
             case kLinear_GammaNamed: {
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
-                            ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed,
+                            ColorSpaceHeader::Pack(k0_Version, 0, fGammaNamed,
                                                    ColorSpaceHeader::kMatrix_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
                     fToXYZD50.as4x3ColMajorf((float*) memory);
                 }
                 return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
             }
             default:
                 // Otherwise, write the gamma values and the matrix.
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
-                            ColorSpaceHeader::Pack(k0_Version, fNamed, fGammaNamed,
+                            ColorSpaceHeader::Pack(k0_Version, 0, fGammaNamed,
                                                    ColorSpaceHeader::kFloatGamma_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
                     const SkGammas* gammas = as_CSB(this)->gammas();
                     SkASSERT(gammas);
                     SkASSERT(SkGammas::Type::kValue_Type == gammas->fRedType &&
                              SkGammas::Type::kValue_Type == gammas->fGreenType &&
                              SkGammas::Type::kValue_Type == gammas->fBlueType);
                     *(((float*) memory) + 0) = gammas->fRedData.fValue;
                     *(((float*) memory) + 1) = gammas->fGreenData.fValue;
                     *(((float*) memory) + 2) = gammas->fBlueData.fValue;
                     memory = SkTAddOffset<void>(memory, 3 * sizeof(float));
 
                     fToXYZD50.as4x3ColMajorf((float*) memory);
                 }
                 return sizeof(ColorSpaceHeader) + 15 * sizeof(float);
         }
     }
 
     // Otherwise, serialize the ICC data.
     size_t profileSize = as_CSB(this)->fProfileData->size();
     if (SkAlign4(profileSize) != (uint32_t) SkAlign4(profileSize)) {
         return 0;
     }
 
     if (memory) {
-        *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(k0_Version, kUnknown_Named,
+        *((ColorSpaceHeader*) memory) = ColorSpaceHeader::Pack(k0_Version, 0,
                                                                kNonStandard_GammaNamed,
                                                                ColorSpaceHeader::kICC_Flag);
         memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
         *((uint32_t*) memory) = (uint32_t) SkAlign4(profileSize);
         memory = SkTAddOffset<void>(memory, sizeof(uint32_t));
 
         memcpy(memory, as_CSB(this)->fProfileData->data(), profileSize);
         memset(SkTAddOffset<void>(memory, profileSize), 0, SkAlign4(profileSize) - profileSize);
     }
@@ skipping 12 matching lines @@
 }
 
 sk_sp<SkColorSpace> SkColorSpace::Deserialize(const void* data, size_t length) {
     if (length < sizeof(ColorSpaceHeader)) {
         return nullptr;
     }
 
     ColorSpaceHeader header = *((const ColorSpaceHeader*) data);
     data = SkTAddOffset<const void>(data, sizeof(ColorSpaceHeader));
     length -= sizeof(ColorSpaceHeader);
-    switch ((Named) header.fNamed) {
-        case kSRGB_Named:
-        case kAdobeRGB_Named:
-            return NewNamed((Named) header.fNamed);
-        default:
-            break;
+    if (0 == header.fFlags) {
+        return NewNamed((Named) header.fNamed);
     }
 
     switch ((GammaNamed) header.fGammaNamed) {
         case kSRGB_GammaNamed:
         case k2Dot2Curve_GammaNamed:
         case kLinear_GammaNamed: {
             if (ColorSpaceHeader::kMatrix_Flag != header.fFlags || length < 12 * sizeof(float)) {
                 return nullptr;
             }
 
@@ skipping 42 matching lines @@
 
 bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
     if (src == dst) {
         return true;
     }
 
     if (!src || !dst) {
         return false;
     }
 
-    switch (src->fNamed) {
-        case kSRGB_Named:
-        case kAdobeRGB_Named:
-            return src->fNamed == dst->fNamed;
-        case kUnknown_Named:
-            if (kUnknown_Named != dst->fNamed) {
-                return false;
-            }
-            break;
-    }
-
     SkData* srcData = as_CSB(src)->fProfileData.get();
     SkData* dstData = as_CSB(dst)->fProfileData.get();
     if (srcData || dstData) {
         if (srcData && dstData) {
             return srcData->size() == dstData->size() &&
                    0 == memcmp(srcData->data(), dstData->data(), srcData->size());
         }
 
         return false;
     }
@@ skipping 49 matching lines @@
            gammas->fBlueType == SkGammas::Type::kTable_Type;
 }
 
 bool SkColorSpace::gammasAreParams() const {
     const SkGammas* gammas = as_CSB(this)->gammas();
     SkASSERT(gammas);
     return gammas->fRedType == SkGammas::Type::kParam_Type &&
            gammas->fGreenType == SkGammas::Type::kParam_Type &&
            gammas->fBlueType == SkGammas::Type::kParam_Type;
 }