Simplify QColorSpace named presets

We don't need a getter for the 'preset' of a color-space, as color
spaces can be compared to the presets directly. This allows us to
remove the Undefined and Unknown values from the presets.

Internally we still distinguish known presets from unknown or undefined
presets via the magic 0-value. The validity of a QColorSpace is not
based on this preset, but on its actual values.

Fixes: QTBUG-77963
Change-Id: I1e0a2a4be83021b8c82b3c778019f680fd46455b
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>

src/gui/image/qimage.cpp

@@ -5025,7 +5025,7 @@ QImage QImage::convertedToColorSpace(const QColorSpace &colorSpace) const
 QColorSpace QImage::colorSpace() const
 {
     if (!d)
-        return QColorSpace::Undefined;
+        return QColorSpace();
     return d->colorSpace;
 }
 

src/gui/painting/qcolorspace.cpp

@@ -152,8 +152,7 @@ QColorMatrix QColorSpacePrimaries::toXyzMatrix() const
 }
 
 QColorSpacePrivate::QColorSpacePrivate()
-        : id(QColorSpace::Unknown)
+        : primaries(QColorSpace::Primaries::Custom)
-        , primaries(QColorSpace::Primaries::Custom)
         , transferFunction(QColorSpace::TransferFunction::Custom)
         , gamma(0.0f)
         , whitePoint(QColorVector::null())
@@ -161,16 +160,11 @@ QColorSpacePrivate::QColorSpacePrivate()
 {
 }
 
-QColorSpacePrivate::QColorSpacePrivate(QColorSpace::ColorSpaceId colorSpaceId)
+QColorSpacePrivate::QColorSpacePrivate(QColorSpace::NamedColorSpace namedColorSpace)
-        : id(colorSpaceId)
+        : namedColorSpace(namedColorSpace)
         , gamma(0.0f)
 {
-    switch (colorSpaceId) {
+    switch (namedColorSpace) {
-    case QColorSpace::Undefined:
-        primaries = QColorSpace::Primaries::Custom;
-        transferFunction = QColorSpace::TransferFunction::Custom;
-        description = QStringLiteral("Undefined");
-        break;
     case QColorSpace::SRgb:
         primaries = QColorSpace::Primaries::SRgb;
         transferFunction = QColorSpace::TransferFunction::SRgb;
@@ -202,9 +196,6 @@ QColorSpacePrivate::QColorSpacePrivate(QColorSpace::ColorSpaceId colorSpaceId)
         transferFunction = QColorSpace::TransferFunction::Bt2020;
         description = QStringLiteral("BT.2020");
         break;
-    case QColorSpace::Unknown:
-        qWarning("Can not create an unknown color space");
-        Q_FALLTHROUGH();
     default:
         Q_UNREACHABLE();
     }
@@ -216,8 +207,7 @@ QColorSpacePrivate::QColorSpacePrivate(QColorSpace::Primaries primaries, QColorS
         , transferFunction(fun)
         , gamma(gamma)
 {
-    if (!identifyColorSpace())
+    identifyColorSpace();
-        id = QColorSpace::Unknown;
     initialize();
 }
 
@@ -235,71 +225,71 @@ QColorSpacePrivate::QColorSpacePrivate(const QColorSpacePrimaries &primaries,
     setTransferFunction();
 }
 
-bool QColorSpacePrivate::identifyColorSpace()
+void QColorSpacePrivate::identifyColorSpace()
 {
     switch (primaries) {
     case QColorSpace::Primaries::SRgb:
         if (transferFunction == QColorSpace::TransferFunction::SRgb) {
-            id = QColorSpace::SRgb;
+            namedColorSpace = QColorSpace::SRgb;
             if (description.isEmpty())
                 description = QStringLiteral("sRGB");
-            return true;
+            return;
         }
         if (transferFunction == QColorSpace::TransferFunction::Linear) {
-            id = QColorSpace::SRgbLinear;
+            namedColorSpace = QColorSpace::SRgbLinear;
             if (description.isEmpty())
                 description = QStringLiteral("Linear sRGB");
-            return true;
+            return;
         }
         break;
     case QColorSpace::Primaries::AdobeRgb:
         if (transferFunction == QColorSpace::TransferFunction::Gamma) {
             if (qAbs(gamma - 2.19921875f) < (1/1024.0f)) {
-                id = QColorSpace::AdobeRgb;
+                namedColorSpace = QColorSpace::AdobeRgb;
                 if (description.isEmpty())
                     description = QStringLiteral("Adobe RGB");
-                return true;
+                return;
             }
         }
         break;
     case QColorSpace::Primaries::DciP3D65:
         if (transferFunction == QColorSpace::TransferFunction::SRgb) {
-            id = QColorSpace::DisplayP3;
+            namedColorSpace = QColorSpace::DisplayP3;
             if (description.isEmpty())
                 description = QStringLiteral("Display P3");
-            return true;
+            return;
         }
         break;
     case QColorSpace::Primaries::ProPhotoRgb:
         if (transferFunction == QColorSpace::TransferFunction::ProPhotoRgb) {
-            id = QColorSpace::ProPhotoRgb;
+            namedColorSpace = QColorSpace::ProPhotoRgb;
             if (description.isEmpty())
                 description = QStringLiteral("ProPhoto RGB");
-            return true;
+            return;
         }
         if (transferFunction == QColorSpace::TransferFunction::Gamma) {
             // ProPhoto RGB's curve is effectively gamma 1.8 for 8bit precision.
             if (qAbs(gamma - 1.8f) < (1/1024.0f)) {
-                id = QColorSpace::ProPhotoRgb;
+                namedColorSpace = QColorSpace::ProPhotoRgb;
                 if (description.isEmpty())
                     description = QStringLiteral("ProPhoto RGB");
-                return true;
+                return;
             }
         }
         break;
     case QColorSpace::Primaries::Bt2020:
         if (transferFunction == QColorSpace::TransferFunction::Bt2020) {
-            id = QColorSpace::Bt2020;
+            namedColorSpace = QColorSpace::Bt2020;
             if (description.isEmpty())
                 description = QStringLiteral("BT.2020");
-            return true;
+            return;
         }
         break;
     default:
         break;
     }
-    id = QColorSpace::Unknown;
+
-    return false;
+    namedColorSpace = Unknown;
 }
 
 void QColorSpacePrivate::initialize()
@@ -410,12 +400,10 @@ QColorTransform QColorSpacePrivate::transformationToColorSpace(const QColorSpace
 
 
 /*!
-    \enum QColorSpace::ColorSpaceId
+    \enum QColorSpace::NamedColorSpace
 
     Predefined color spaces.
 
-    \value Undefined An empty, invalid or unsupported color space.
-    \value Unknown A valid color space that doesn't match any of the predefined color spaces.
     \value SRgb The sRGB color space, which Qt operates in by default. It is a close approximation
     of how most classic monitors operate, and a mode most software and hardware support.
     \l{http://www.color.org/chardata/rgb/srgb.xalter}{ICC registration of sRGB}.
@@ -458,22 +446,25 @@ QColorTransform QColorSpacePrivate::transformationToColorSpace(const QColorSpace
 */
 
 /*!
-    Creates a new colorspace object that represents \a colorSpaceId.
+    Creates a new colorspace object that represents an undefined and invalid colorspace.
  */
-QColorSpace::QColorSpace(QColorSpace::ColorSpaceId colorSpaceId)
+QColorSpace::QColorSpace()
-        : d_ptr(nullptr)
 {
-    static QColorSpacePrivate *predefinedColorspacePrivates[QColorSpace::Bt2020];
+}
-    // Unknown and undefined both returns the static undefined colorspace
+
-    if (colorSpaceId > QColorSpace::Unknown) {
+/*!
-        if (!predefinedColorspacePrivates[colorSpaceId - 2]) {
+    Creates a new colorspace object that represents a \a namedColorSpace.
-            predefinedColorspacePrivates[colorSpaceId - 2] = new QColorSpacePrivate(colorSpaceId);
+ */
-            predefinedColorspacePrivates[colorSpaceId - 2]->ref.ref();
+QColorSpace::QColorSpace(NamedColorSpace namedColorSpace)
-        }
+{
-        d_ptr = predefinedColorspacePrivates[colorSpaceId - 2];
+    static QColorSpacePrivate *predefinedColorspacePrivates[QColorSpace::Bt2020 + 1];
-        d_ptr->ref.ref();
+    if (!predefinedColorspacePrivates[namedColorSpace]) {
-        Q_ASSERT(isValid());
+        predefinedColorspacePrivates[namedColorSpace] = new QColorSpacePrivate(namedColorSpace);
+        predefinedColorspacePrivates[namedColorSpace]->ref.ref();
     }
+    d_ptr = predefinedColorspacePrivates[namedColorSpace];
+    d_ptr->ref.ref();
+    Q_ASSERT(isValid());
 }
 
 /*!
@@ -544,17 +535,6 @@ QColorSpace &QColorSpace::operator=(const QColorSpace &colorSpace)
     never fails.
 */
 
-/*!
-    Returns the id of the predefined color space this object
-    represents or \c Unknown if it doesn't match any of them.
-*/
-QColorSpace::ColorSpaceId QColorSpace::colorSpaceId() const noexcept
-{
-    if (Q_UNLIKELY(!d_ptr))
-        return QColorSpace::Undefined;
-    return d_ptr->id;
-}
-
 /*!
     Returns the predefined primaries of the color space
     or \c primaries::Custom if it doesn't match any of them.
@@ -596,8 +576,6 @@ float QColorSpace::gamma() const noexcept
 /*!
     Sets the transfer function to \a transferFunction and \a gamma.
 
-    \note This also changes colorSpaceId().
-
     \sa transferFunction(), gamma(), withTransferFunction()
 */
 void QColorSpace::setTransferFunction(QColorSpace::TransferFunction transferFunction, float gamma)
@@ -634,8 +612,6 @@ QColorSpace QColorSpace::withTransferFunction(QColorSpace::TransferFunction tran
 /*!
     Sets the primaries to those of the \a primariesId set.
 
-    \note This also changes colorSpaceId().
-
     \sa primaries()
 */
 void QColorSpace::setPrimaries(QColorSpace::Primaries primariesId)
@@ -655,8 +631,6 @@ void QColorSpace::setPrimaries(QColorSpace::Primaries primariesId)
     Set primaries to the chromaticities of \a whitePoint, \a redPoint, \a greenPoint
     and \a bluePoint.
 
-    \note This also changes colorSpaceId().
-
     \sa primaries()
 */
 void QColorSpace::setPrimaries(const QPointF &whitePoint, const QPointF &redPoint,
@@ -718,7 +692,6 @@ QColorSpace QColorSpace::fromIccProfile(const QByteArray &iccProfile)
     if (QIcc::fromIccProfile(iccProfile, &colorSpace))
         return colorSpace;
     QColorSpacePrivate *d = QColorSpacePrivate::getWritable(colorSpace);
-    d->id = QColorSpace::Undefined;
     d->iccProfile = iccProfile;
     return colorSpace;
 }
@@ -728,7 +701,8 @@ QColorSpace QColorSpace::fromIccProfile(const QByteArray &iccProfile)
 */
 bool QColorSpace::isValid() const noexcept
 {
-    return d_ptr && d_ptr->id != QColorSpace::Undefined && d_ptr->toXyz.isValid()
+    return d_ptr
+        && d_ptr->toXyz.isValid()
         && d_ptr->trc[0].isValid() && d_ptr->trc[1].isValid() && d_ptr->trc[2].isValid();
 }
 
@@ -744,11 +718,17 @@ bool operator==(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2)
     if (!colorSpace1.d_ptr || !colorSpace2.d_ptr)
         return false;
 
-    if (colorSpace1.colorSpaceId() == QColorSpace::Undefined && colorSpace2.colorSpaceId() == QColorSpace::Undefined)
+    if (colorSpace1.d_ptr->namedColorSpace && colorSpace2.d_ptr->namedColorSpace)
-        return colorSpace1.d_ptr->iccProfile == colorSpace2.d_ptr->iccProfile;
+        return colorSpace1.d_ptr->namedColorSpace == colorSpace2.d_ptr->namedColorSpace;
 
-    if (colorSpace1.colorSpaceId() != QColorSpace::Unknown && colorSpace2.colorSpaceId() != QColorSpace::Unknown)
+    const bool valid1 = colorSpace1.isValid();
-        return colorSpace1.colorSpaceId() == colorSpace2.colorSpaceId();
+    const bool valid2 = colorSpace2.isValid();
+    if (!valid1 && !valid2)
+        return colorSpace1.d_ptr->iccProfile == colorSpace2.d_ptr->iccProfile;
+    else if (!valid1 || !valid2)
+        return false;
+
+    // At this point one or both color spaces are unknown but valid, and must be compared in detail instead
 
     if (colorSpace1.primaries() != QColorSpace::Primaries::Custom && colorSpace2.primaries() != QColorSpace::Primaries::Custom) {
         if (colorSpace1.primaries() != colorSpace2.primaries())
@@ -839,7 +819,9 @@ QDebug operator<<(QDebug dbg, const QColorSpace &colorSpace)
     QDebugStateSaver saver(dbg);
     dbg.nospace();
     dbg << "QColorSpace(";
-    dbg << colorSpace.colorSpaceId() << ", " << colorSpace.primaries() << ", " << colorSpace.transferFunction();
+    if (colorSpace.d_ptr->namedColorSpace)
+        dbg << colorSpace.d_ptr->namedColorSpace << ", ";
+    dbg << colorSpace.primaries() << ", " << colorSpace.transferFunction();
     dbg << ", gamma=" << colorSpace.gamma();
     dbg << ')';
     return dbg;

src/gui/painting/qcolorspace.h

@@ -54,17 +54,15 @@ class Q_GUI_EXPORT QColorSpace
 {
     Q_GADGET
 public:
-    enum ColorSpaceId {
+    enum NamedColorSpace {
-        Undefined = 0,
+        SRgb = 1,
-        Unknown = 1,
-        SRgb,
         SRgbLinear,
         AdobeRgb,
         DisplayP3,
         ProPhotoRgb,
         Bt2020,
     };
-    Q_ENUM(ColorSpaceId)
+    Q_ENUM(NamedColorSpace)
     enum class Primaries {
         Custom = 0,
         SRgb,
@@ -84,7 +82,8 @@ public:
     };
     Q_ENUM(TransferFunction)
 
-    QColorSpace(ColorSpaceId colorSpaceId = Undefined);
+    QColorSpace();
+    QColorSpace(NamedColorSpace namedColorSpace);
     QColorSpace(Primaries primaries, TransferFunction fun, float gamma = 0.0f);
     QColorSpace(Primaries primaries, float gamma);
     QColorSpace(const QPointF &whitePoint, const QPointF &redPoint,
@@ -108,7 +107,6 @@ public:
     void swap(QColorSpace &colorSpace) noexcept
     { qSwap(d_ptr, colorSpace.d_ptr); }
 
-    ColorSpaceId colorSpaceId() const noexcept;
     Primaries primaries() const noexcept;
     TransferFunction transferFunction() const noexcept;
     float gamma() const noexcept;
@@ -133,7 +131,11 @@ public:
 
 private:
     Q_DECLARE_PRIVATE(QColorSpace)
-    QColorSpacePrivate *d_ptr;
+    QColorSpacePrivate *d_ptr = nullptr;
+
+#ifndef QT_NO_DEBUG_STREAM
+    friend Q_GUI_EXPORT QDebug operator<<(QDebug dbg, const QColorSpace &colorSpace);
+#endif
 };
 
 bool Q_GUI_EXPORT operator==(const QColorSpace &colorSpace1, const QColorSpace &colorSpace2);

src/gui/painting/qcolorspace_p.h

@@ -90,7 +90,7 @@ class QColorSpacePrivate : public QSharedData
 {
 public:
     QColorSpacePrivate();
-    QColorSpacePrivate(QColorSpace::ColorSpaceId colorSpaceId);
+    QColorSpacePrivate(QColorSpace::NamedColorSpace namedColorSpace);
     QColorSpacePrivate(QColorSpace::Primaries primaries, QColorSpace::TransferFunction fun, float gamma);
     QColorSpacePrivate(const QColorSpacePrimaries &primaries, QColorSpace::TransferFunction fun, float gamma);
     QColorSpacePrivate(const QColorSpacePrivate &other) = default;
@@ -118,10 +118,12 @@ public:
     void initialize();
     void setToXyzMatrix();
     void setTransferFunction();
-    bool identifyColorSpace();
+    void identifyColorSpace();
     QColorTransform transformationToColorSpace(const QColorSpacePrivate *out) const;
 
-    QColorSpace::ColorSpaceId id;
+    static constexpr QColorSpace::NamedColorSpace Unknown = QColorSpace::NamedColorSpace(0);
+    QColorSpace::NamedColorSpace namedColorSpace = Unknown;
+
     QColorSpace::Primaries primaries;
     QColorSpace::TransferFunction transferFunction;
     float gamma;

src/gui/painting/qicc.cpp

@@ -765,10 +765,9 @@ bool fromIccProfile(const QByteArray &data, QColorSpace *colorSpace)
             qCDebug(lcIcc) << "fromIccProfile: Description" << colorspaceDPtr->description;
     }
 
-    if (!colorspaceDPtr->identifyColorSpace())
+    colorspaceDPtr->identifyColorSpace();
-        colorspaceDPtr->id = QColorSpace::Unknown;
+    if (colorspaceDPtr->namedColorSpace)
-    else
+        qCDebug(lcIcc) << "fromIccProfile: Named colorspace detected: " << QColorSpace::NamedColorSpace(colorspaceDPtr->namedColorSpace);
-        qCDebug(lcIcc) << "fromIccProfile: Named colorspace detected: " << colorSpace->colorSpaceId();
 
     colorspaceDPtr->iccProfile = data;
 

tests/auto/gui/image/qimagereader/tst_qimagereader.cpp

@@ -1890,9 +1890,8 @@ void tst_QImageReader::saveFormat()
 
 void tst_QImageReader::saveColorSpace_data()
 {
-    QTest::addColumn<QColorSpace::ColorSpaceId>("colorspaceId");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("namedColorSpace");
 
-    QTest::newRow("Undefined")    << QColorSpace::Undefined;
     QTest::newRow("sRGB")         << QColorSpace::SRgb;
     QTest::newRow("sRGB(linear)") << QColorSpace::SRgbLinear;
     QTest::newRow("AdobeRGB")     << QColorSpace::AdobeRgb;
@@ -1902,11 +1901,11 @@ void tst_QImageReader::saveColorSpace_data()
 
 void tst_QImageReader::saveColorSpace()
 {
-    QFETCH(QColorSpace::ColorSpaceId, colorspaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
 
     QImage orig(":/images/kollada.png");
 
-    orig.setColorSpace(colorspaceId);
+    orig.setColorSpace(namedColorSpace);
     QBuffer buf;
     buf.open(QIODevice::WriteOnly);
     QVERIFY(orig.save(&buf, "png"));

tests/auto/gui/painting/qcolorspace/tst_qcolorspace.cpp

@@ -35,7 +35,7 @@
 
 #include <private/qcolorspace_p.h>
 
-Q_DECLARE_METATYPE(QColorSpace::ColorSpaceId)
+Q_DECLARE_METATYPE(QColorSpace::NamedColorSpace)
 Q_DECLARE_METATYPE(QColorSpace::Primaries)
 Q_DECLARE_METATYPE(QColorSpace::TransferFunction)
 
@@ -82,25 +82,25 @@ void tst_QColorSpace::movable()
     QColorSpace cs2 = QColorSpace::SRgbLinear;
     QVERIFY(cs1.isValid());
     QVERIFY(cs2.isValid());
-    QCOMPARE(cs1.colorSpaceId(), QColorSpace::SRgb);
+    QCOMPARE(cs1, QColorSpace::SRgb);
 
     cs2 = std::move(cs1);
     QVERIFY(!cs1.isValid());
     QVERIFY(cs2.isValid());
-    QCOMPARE(cs2.colorSpaceId(), QColorSpace::SRgb);
+    QCOMPARE(cs2, QColorSpace::SRgb);
-    QCOMPARE(cs1.colorSpaceId(), QColorSpace::Undefined);
+    QVERIFY(cs1 != QColorSpace::SRgb);
     QCOMPARE(cs1, QColorSpace());
 
     QColorSpace cs3(std::move(cs2));
     QVERIFY(!cs2.isValid());
     QVERIFY(cs3.isValid());
-    QCOMPARE(cs3.colorSpaceId(), QColorSpace::SRgb);
+    QCOMPARE(cs3, QColorSpace::SRgb);
-    QCOMPARE(cs2.colorSpaceId(), QColorSpace::Undefined);
+    QCOMPARE(cs2, QColorSpace());
 }
 
 void tst_QColorSpace::namedColorSpaces_data()
 {
-    QTest::addColumn<QColorSpace::ColorSpaceId>("colorSpaceId");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("namedColorSpace");
     QTest::addColumn<QColorSpace::Primaries>("primariesId");
     QTest::addColumn<QColorSpace::TransferFunction>("transferFunctionId");
 
@@ -126,15 +126,15 @@ void tst_QColorSpace::namedColorSpaces_data()
 
 void tst_QColorSpace::namedColorSpaces()
 {
-    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
     QFETCH(QColorSpace::Primaries, primariesId);
     QFETCH(QColorSpace::TransferFunction, transferFunctionId);
 
-    QColorSpace colorSpace = colorSpaceId;
+    QColorSpace colorSpace = namedColorSpace;
 
     QVERIFY(colorSpace.isValid());
 
-    QCOMPARE(colorSpace.colorSpaceId(), colorSpaceId);
+    QCOMPARE(colorSpace, namedColorSpace);
     QCOMPARE(colorSpace.primaries(), primariesId);
     QCOMPARE(colorSpace.transferFunction(), transferFunctionId);
 }
@@ -147,14 +147,14 @@ void tst_QColorSpace::toIccProfile_data()
 
 void tst_QColorSpace::toIccProfile()
 {
-    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
     QFETCH(QColorSpace::Primaries, primariesId);
     QFETCH(QColorSpace::TransferFunction, transferFunctionId);
 
     Q_UNUSED(primariesId);
     Q_UNUSED(transferFunctionId);
 
-    QColorSpace colorSpace = colorSpaceId;
+    QColorSpace colorSpace = namedColorSpace;
     QByteArray iccProfile = colorSpace.iccProfile();
     QVERIFY(!iccProfile.isEmpty());
 
@@ -172,7 +172,7 @@ void tst_QColorSpace::toIccProfile()
 void tst_QColorSpace::fromIccProfile_data()
 {
     QTest::addColumn<QString>("testProfile");
-    QTest::addColumn<QColorSpace::ColorSpaceId>("colorSpaceId");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("namedColorSpace");
     QTest::addColumn<QColorSpace::TransferFunction>("transferFunction");
     QTest::addColumn<QString>("description");
 
@@ -181,14 +181,14 @@ void tst_QColorSpace::fromIccProfile_data()
     QTest::newRow("sRGB2014 (ICCv2)") << prefix + "sRGB2014.icc" << QColorSpace::SRgb
                                            << QColorSpace::TransferFunction::SRgb << QString("sRGB2014");
     // My monitor's profile:
-    QTest::newRow("HP ZR30w (ICCv4)") << prefix + "HP_ZR30w.icc" << QColorSpace::Unknown
+    QTest::newRow("HP ZR30w (ICCv4)") << prefix + "HP_ZR30w.icc" << QColorSpace::NamedColorSpace(0)
                                       << QColorSpace::TransferFunction::Gamma << QString("HP Z30i");
 }
 
 void tst_QColorSpace::fromIccProfile()
 {
     QFETCH(QString, testProfile);
-    QFETCH(QColorSpace::ColorSpaceId, colorSpaceId);
+    QFETCH(QColorSpace::NamedColorSpace, namedColorSpace);
     QFETCH(QColorSpace::TransferFunction, transferFunction);
     QFETCH(QString, description);
 
@@ -198,15 +198,17 @@ void tst_QColorSpace::fromIccProfile()
     QColorSpace fileColorSpace = QColorSpace::fromIccProfile(iccProfile);
     QVERIFY(fileColorSpace.isValid());
 
-    QCOMPARE(fileColorSpace.colorSpaceId(), colorSpaceId);
+    if (namedColorSpace)
+        QCOMPARE(fileColorSpace, namedColorSpace);
+
     QCOMPARE(fileColorSpace.transferFunction(), transferFunction);
     QCOMPARE(QColorSpacePrivate::get(fileColorSpace)->description, description);
 }
 
 void tst_QColorSpace::imageConversion_data()
 {
-    QTest::addColumn<QColorSpace::ColorSpaceId>("fromColorSpace");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("fromColorSpace");
-    QTest::addColumn<QColorSpace::ColorSpaceId>("toColorSpace");
+    QTest::addColumn<QColorSpace::NamedColorSpace>("toColorSpace");
     QTest::addColumn<int>("tolerance");
 
     QTest::newRow("sRGB -> Display-P3") << QColorSpace::SRgb << QColorSpace::DisplayP3 << 0;
@@ -220,8 +222,8 @@ void tst_QColorSpace::imageConversion_data()
 
 void tst_QColorSpace::imageConversion()
 {
-    QFETCH(QColorSpace::ColorSpaceId, fromColorSpace);
+    QFETCH(QColorSpace::NamedColorSpace, fromColorSpace);
-    QFETCH(QColorSpace::ColorSpaceId, toColorSpace);
+    QFETCH(QColorSpace::NamedColorSpace, toColorSpace);
     QFETCH(int, tolerance);
 
     QImage testImage(256, 1, QImage::Format_RGB32);
@@ -275,7 +277,7 @@ void tst_QColorSpace::loadImage()
 
     QVERIFY(!image.isNull());
     QVERIFY(image.colorSpace().isValid());
-    QCOMPARE(image.colorSpace().colorSpaceId(), QColorSpace::ProPhotoRgb);
+    QCOMPARE(image.colorSpace(), QColorSpace::ProPhotoRgb);
     QVERIFY(!image.colorSpace().iccProfile().isEmpty());
 
     QColorSpace defaultProPhotoRgb = QColorSpace::ProPhotoRgb;
@@ -398,7 +400,6 @@ void tst_QColorSpace::invalidPrimaries()
 {
     QColorSpace custom(QPointF(), QPointF(), QPointF(), QPointF(), QColorSpace::TransferFunction::Linear);
     QVERIFY(!custom.isValid());
-    QCOMPARE(custom.colorSpaceId(), QColorSpace::Undefined);
 }
 
 void tst_QColorSpace::changeTransferFunction()
@@ -409,7 +410,7 @@ void tst_QColorSpace::changeTransferFunction()
     QCOMPARE(sRgbLinear.transferFunction(), QColorSpace::TransferFunction::Linear);
     QCOMPARE(sRgbLinear.gamma(), 1.0f);
     QCOMPARE(sRgbLinear.primaries(), QColorSpace::Primaries::SRgb);
-    QCOMPARE(sRgbLinear.colorSpaceId(), QColorSpace::SRgbLinear);
+    QCOMPARE(sRgbLinear, QColorSpace::SRgbLinear);
     QCOMPARE(sRgbLinear, QColorSpace(QColorSpace::SRgbLinear));
     QVERIFY(sRgbLinear != sRgb);
     QCOMPARE(sRgbLinear.withTransferFunction(QColorSpace::TransferFunction::SRgb), sRgb);
@@ -418,7 +419,6 @@ void tst_QColorSpace::changeTransferFunction()
     aRgb.setTransferFunction(QColorSpace::TransferFunction::SRgb);
     QCOMPARE(aRgb.transferFunction(), QColorSpace::TransferFunction::SRgb);
     QCOMPARE(aRgb.primaries(), QColorSpace::Primaries::AdobeRgb);
-    QCOMPARE(aRgb.colorSpaceId(), QColorSpace::Unknown);
     QVERIFY(aRgb != QColorSpace(QColorSpace::AdobeRgb));
     QVERIFY(aRgb != sRgb);
     QCOMPARE(aRgb.withTransferFunction(QColorSpace::TransferFunction::Gamma, 2.2f),