Remove usages of qVariantFromValue

Task-number: QTBUG-76491
Change-Id: Iabb97fe7cb168a421b690bc71e826e1b90b955f9
Reviewed-by: Jędrzej Nowacki <jedrzej.nowacki@qt.io>

5 files changed, 44 insertions, 44 deletions

diff --git a/tests/auto/qscriptclass/tst_qscriptclass.cpp b/tests/auto/qscriptclass/tst_qscriptclass.cpp
index 8242611..d7b9440 100644
--- a/tests/auto/qscriptclass/tst_qscriptclass.cpp
+++ b/tests/auto/qscriptclass/tst_qscriptclass.cpp
@@ -366,17 +366,17 @@ QVariant TestClass::extension(Extension extension,
             }
             return sum;
         } else if (m_callableMode == CallableReturnsArgument) {
-            return qVariantFromValue(ctx->argument(0));
+            return QVariant::fromValue(ctx->argument(0));
         } else if (m_callableMode == CallableReturnsInvalidVariant) {
             return QVariant();
         } else if (m_callableMode == CallableReturnsGlobalObject) {
-            return qVariantFromValue(engine()->globalObject());
+            return QVariant::fromValue(engine()->globalObject());
         } else if (m_callableMode == CallableReturnsThisObject) {
-            return qVariantFromValue(ctx->thisObject());
+            return QVariant::fromValue(ctx->thisObject());
         } else if (m_callableMode == CallableReturnsCallee) {
-            return qVariantFromValue(ctx->callee());
+            return QVariant::fromValue(ctx->callee());
         } else if (m_callableMode == CallableReturnsArgumentsObject) {
-            return qVariantFromValue(ctx->argumentsObject());
+            return QVariant::fromValue(ctx->argumentsObject());
         } else if (m_callableMode == CallableInitializesThisObject) {
             engine()->newQObject(ctx->thisObject(), engine());
             return QVariant();
diff --git a/tests/auto/qscriptengine/tst_qscriptengine.cpp b/tests/auto/qscriptengine/tst_qscriptengine.cpp
index e7ad7f8..434f35b 100644
--- a/tests/auto/qscriptengine/tst_qscriptengine.cpp
+++ b/tests/auto/qscriptengine/tst_qscriptengine.cpp
@@ -2057,13 +2057,13 @@ void tst_QScriptEngine::getSetDefaultPrototype_customType()
     QCOMPARE(eng.defaultPrototype(qMetaTypeId<Foo>()).isValid(), false);
     eng.setDefaultPrototype(qMetaTypeId<Foo>(), object);
     QCOMPARE(eng.defaultPrototype(qMetaTypeId<Foo>()).strictlyEquals(object), true);
-    QScriptValue value = eng.newVariant(qVariantFromValue(Foo()));
+    QScriptValue value = eng.newVariant(QVariant::fromValue(Foo()));
     QCOMPARE(value.prototype().isObject(), true);
     QCOMPARE(value.prototype().strictlyEquals(object), true);
 
     eng.setDefaultPrototype(qMetaTypeId<Foo>(), QScriptValue());
     QCOMPARE(eng.defaultPrototype(qMetaTypeId<Foo>()).isValid(), false);
-    QScriptValue value2 = eng.newVariant(qVariantFromValue(Foo()));
+    QScriptValue value2 = eng.newVariant(QVariant::fromValue(Foo()));
     QCOMPARE(value2.prototype().strictlyEquals(object), false);
 }
 
@@ -2361,13 +2361,13 @@ void tst_QScriptEngine::valueConversion_QVariant()
         QCOMPARE(val.toString(), str);
     }
     {
-        QScriptValue val = qScriptValueFromValue(&eng, qVariantFromValue((QObject*)this));
+        QScriptValue val = qScriptValueFromValue(&eng, QVariant::fromValue((QObject*)this));
         QVERIFY(!val.isVariant());
         QVERIFY(val.isQObject());
         QCOMPARE(val.toQObject(), (QObject*)this);
     }
     {
-        QVariant var = qVariantFromValue(QPoint(123, 456));
+        QVariant var = QVariant::fromValue(QPoint(123, 456));
         QScriptValue val = qScriptValueFromValue(&eng, var);
         QVERIFY(val.isVariant());
         QCOMPARE(val.toVariant(), var);
diff --git a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
index 58fee07..9d6c2fb 100644
--- a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
+++ b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
@@ -271,7 +271,7 @@ public:
     Q_INVOKABLE QObject *myInvokableReturningQObjectStar()
         { m_qtFunctionInvoked = 13; return this; }
     Q_INVOKABLE QObjectList myInvokableWithQObjectListArg(const QObjectList &lst)
-        { m_qtFunctionInvoked = 14; m_actuals << qVariantFromValue(lst); return lst; }
+        { m_qtFunctionInvoked = 14; m_actuals << QVariant::fromValue(lst); return lst; }
     Q_INVOKABLE QVariant myInvokableWithVariantArg(const QVariant &v)
         { m_qtFunctionInvoked = 15; m_actuals << v; return v; }
     Q_INVOKABLE QVariantMap myInvokableWithVariantMapArg(const QVariantMap &vm)
@@ -279,37 +279,37 @@ public:
     Q_INVOKABLE QVariantList myInvokableWithVariantListArg(const QVariantList &lst)
         { m_qtFunctionInvoked = 62; m_actuals.append(QVariant(lst)); return lst; }
     Q_INVOKABLE QList<int> myInvokableWithListOfIntArg(const QList<int> &lst)
-        { m_qtFunctionInvoked = 17; m_actuals << qVariantFromValue(lst); return lst; }
+        { m_qtFunctionInvoked = 17; m_actuals << QVariant::fromValue(lst); return lst; }
     Q_INVOKABLE QObject* myInvokableWithQObjectStarArg(QObject *obj)
-        { m_qtFunctionInvoked = 18; m_actuals << qVariantFromValue(obj); return obj; }
+        { m_qtFunctionInvoked = 18; m_actuals << QVariant::fromValue(obj); return obj; }
     Q_INVOKABLE QBrush myInvokableWithQBrushArg(const QBrush &brush)
-        { m_qtFunctionInvoked = 19; m_actuals << qVariantFromValue(brush); return brush; }
+        { m_qtFunctionInvoked = 19; m_actuals << QVariant::fromValue(brush); return brush; }
     Q_INVOKABLE void myInvokableWithBrushStyleArg(Qt::BrushStyle style)
-        { m_qtFunctionInvoked = 43; m_actuals << qVariantFromValue(style); }
+        { m_qtFunctionInvoked = 43; m_actuals << QVariant::fromValue(style); }
     Q_INVOKABLE void myInvokableWithVoidStarArg(void *arg)
-        { m_qtFunctionInvoked = 44; m_actuals << qVariantFromValue(arg); }
+        { m_qtFunctionInvoked = 44; m_actuals << QVariant::fromValue(arg); }
     Q_INVOKABLE void myInvokableWithAmbiguousArg(int arg)
-        { m_qtFunctionInvoked = 45; m_actuals << qVariantFromValue(arg); }
+        { m_qtFunctionInvoked = 45; m_actuals << QVariant::fromValue(arg); }
     Q_INVOKABLE void myInvokableWithAmbiguousArg(uint arg)
-        { m_qtFunctionInvoked = 46; m_actuals << qVariantFromValue(arg); }
+        { m_qtFunctionInvoked = 46; m_actuals << QVariant::fromValue(arg); }
     Q_INVOKABLE void myInvokableWithDefaultArgs(int arg1, const QString &arg2 = "")
-        { m_qtFunctionInvoked = 47; m_actuals << qVariantFromValue(arg1) << qVariantFromValue(arg2); }
+        { m_qtFunctionInvoked = 47; m_actuals << QVariant::fromValue(arg1) << QVariant::fromValue(arg2); }
     Q_INVOKABLE QObject& myInvokableReturningRef()
         { m_qtFunctionInvoked = 48; return *this; }
     Q_INVOKABLE const QObject& myInvokableReturningConstRef() const
         { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 49; return *this; }
     Q_INVOKABLE void myInvokableWithPointArg(const QPoint &arg)
-        { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 50; m_actuals << qVariantFromValue(arg); }
+        { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 50; m_actuals << QVariant::fromValue(arg); }
     Q_INVOKABLE void myInvokableWithPointArg(const QPointF &arg)
-        { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 51; m_actuals << qVariantFromValue(arg); }
+        { const_cast<MyQObject*>(this)->m_qtFunctionInvoked = 51; m_actuals << QVariant::fromValue(arg); }
     Q_INVOKABLE void myInvokableWithMyQObjectArg(MyQObject *arg)
-        { m_qtFunctionInvoked = 52; m_actuals << qVariantFromValue((QObject*)arg); }
+        { m_qtFunctionInvoked = 52; m_actuals << QVariant::fromValue((QObject*)arg); }
     Q_INVOKABLE MyQObject* myInvokableReturningMyQObject()
         { m_qtFunctionInvoked = 53; return this; }
     Q_INVOKABLE void myInvokableWithConstMyQObjectArg(const MyQObject *arg)
-        { m_qtFunctionInvoked = 54; m_actuals << qVariantFromValue((QObject*)arg); }
+        { m_qtFunctionInvoked = 54; m_actuals << QVariant::fromValue((QObject*)arg); }
     Q_INVOKABLE void myInvokableWithQDirArg(const QDir &arg)
-        { m_qtFunctionInvoked = 55; m_actuals << qVariantFromValue(arg); }
+        { m_qtFunctionInvoked = 55; m_actuals << QVariant::fromValue(arg); }
     Q_INVOKABLE QScriptValue myInvokableWithScriptValueArg(const QScriptValue &arg)
         { m_qtFunctionInvoked = 56; return arg; }
     Q_INVOKABLE QObject* myInvokableReturningMyQObjectAsQObject()
@@ -319,21 +319,21 @@ public:
     Q_INVOKABLE MyQObject::Ability myInvokableWithQualifiedFlagsArg(MyQObject::Ability arg)
         { m_qtFunctionInvoked = 59; m_actuals << int(arg); return arg; }
     Q_INVOKABLE QWidget *myInvokableWithQWidgetStarArg(QWidget *arg)
-        { m_qtFunctionInvoked = 63; m_actuals << qVariantFromValue((QWidget*)arg); return arg; }
+        { m_qtFunctionInvoked = 63; m_actuals << QVariant::fromValue((QWidget*)arg); return arg; }
     Q_INVOKABLE short myInvokableWithShortArg(short arg)
-        { m_qtFunctionInvoked = 64; m_actuals << qVariantFromValue(arg); return arg; }
+        { m_qtFunctionInvoked = 64; m_actuals << QVariant::fromValue(arg); return arg; }
     Q_INVOKABLE unsigned short myInvokableWithUShortArg(unsigned short arg)
-        { m_qtFunctionInvoked = 65; m_actuals << qVariantFromValue(arg); return arg; }
+        { m_qtFunctionInvoked = 65; m_actuals << QVariant::fromValue(arg); return arg; }
     Q_INVOKABLE char myInvokableWithCharArg(char arg)
-        { m_qtFunctionInvoked = 66; m_actuals << qVariantFromValue(arg); return arg; }
+        { m_qtFunctionInvoked = 66; m_actuals << QVariant::fromValue(arg); return arg; }
     Q_INVOKABLE unsigned char myInvokableWithUCharArg(unsigned char arg)
-        { m_qtFunctionInvoked = 67; m_actuals << qVariantFromValue(arg); return arg; }
+        { m_qtFunctionInvoked = 67; m_actuals << QVariant::fromValue(arg); return arg; }
     Q_INVOKABLE qulonglong myInvokableWithULonglongArg(qulonglong arg)
-        { m_qtFunctionInvoked = 68; m_actuals << qVariantFromValue(arg); return arg; }
+        { m_qtFunctionInvoked = 68; m_actuals << QVariant::fromValue(arg); return arg; }
     Q_INVOKABLE long myInvokableWithLongArg(long arg)
-        { m_qtFunctionInvoked = 69; m_actuals << qVariantFromValue(arg); return arg; }
+        { m_qtFunctionInvoked = 69; m_actuals << QVariant::fromValue(arg); return arg; }
     Q_INVOKABLE unsigned long myInvokableWithULongArg(unsigned long arg)
-        { m_qtFunctionInvoked = 70; m_actuals << qVariantFromValue(arg); return arg; }
+        { m_qtFunctionInvoked = 70; m_actuals << QVariant::fromValue(arg); return arg; }
 
     Q_INVOKABLE QObjectList findObjects() const
     {  return findChildren<QObject *>();  }
@@ -378,7 +378,7 @@ public Q_SLOTS:
     void myOverloadedSlot()
         { m_qtFunctionInvoked = 24; }
     void myOverloadedSlot(QObject *arg)
-        { m_qtFunctionInvoked = 41; m_actuals << qVariantFromValue(arg); }
+        { m_qtFunctionInvoked = 41; m_actuals << QVariant::fromValue(arg); }
     void myOverloadedSlot(bool arg)
         { m_qtFunctionInvoked = 25; m_actuals << arg; }
     void myOverloadedSlot(const QStringList &arg)
@@ -723,7 +723,7 @@ void tst_QScriptExtQObject::getSetStaticProperty_changeInCpp()
     m_myObject->setVariantProperty(42);
     QCOMPARE(m_engine->evaluate("myObject.variantProperty")
              .toVariant(), QVariant(42));
-    m_myObject->setVariantProperty(qVariantFromValue(QBrush()));
+    m_myObject->setVariantProperty(QVariant::fromValue(QBrush()));
     QVERIFY(m_engine->evaluate("myObject.variantProperty").isVariant());
 
     m_myObject->setStringProperty(QLatin1String("baz"));
@@ -837,7 +837,7 @@ void tst_QScriptExtQObject::getSetStaticProperty_compatibleVariantTypes()
         QScriptValue mobj = m_engine->globalObject().property("myObject");
 
         QVERIFY(m_myObject->propWithCustomType().string.isEmpty());
-        mobj.setProperty("propWithCustomType", m_engine->newVariant(qVariantFromValue(t)));
+        mobj.setProperty("propWithCustomType", m_engine->newVariant(QVariant::fromValue(t)));
         QVERIFY(m_myObject->propWithCustomType().string == t.string);
     }
 }
@@ -965,7 +965,7 @@ void tst_QScriptExtQObject::getSetStaticProperty_pointerDeref()
     {
         QBrush b = QColor(0xCA, 0xFE, 0xBA, 0xBE);
         QBrush *bp = &b;
-        QScriptValue bpValue = m_engine->newVariant(qVariantFromValue(bp));
+        QScriptValue bpValue = m_engine->newVariant(QVariant::fromValue(bp));
         m_engine->globalObject().setProperty("brushPointer", bpValue);
         {
             QScriptValue ret = m_engine->evaluate("myObject.setBrushProperty(brushPointer)");
@@ -1413,7 +1413,7 @@ void tst_QScriptExtQObject::callQtInvokable3()
 
     m_myObject->resetQtFunctionInvoked();
     {
-        m_myObject->setVariantProperty(qVariantFromValue(QBrush()));
+        m_myObject->setVariantProperty(QVariant::fromValue(QBrush()));
         QScriptValue ret = m_engine->evaluate("myObject.myInvokableWithVariantArg(myObject.variantProperty)");
         QVERIFY(ret.isVariant());
         QCOMPARE(m_myObject->qtFunctionInvoked(), 15);
diff --git a/tests/auto/qscriptvalue/tst_qscriptvalue.cpp b/tests/auto/qscriptvalue/tst_qscriptvalue.cpp
index 35f0555..0875fe6 100644
--- a/tests/auto/qscriptvalue/tst_qscriptvalue.cpp
+++ b/tests/auto/qscriptvalue/tst_qscriptvalue.cpp
@@ -1352,7 +1352,7 @@ void tst_QScriptValue::toQObject_nonQObject_data()
     QTest::newRow("array") << engine->newArray();
     QTest::newRow("date") << engine->newDate(124);
     QTest::newRow("variant(12345)") << engine->newVariant(12345);
-    QTest::newRow("variant((QObject*)0)") << engine->newVariant(qVariantFromValue((QObject*)0));
+    QTest::newRow("variant((QObject*)0)") << engine->newVariant(QVariant::fromValue((QObject*)0));
     QTest::newRow("newQObject(0)") << engine->newQObject(0);
 }
 
@@ -1390,19 +1390,19 @@ void tst_QScriptValue::toQObject()
     QCOMPARE(qscriptvalue_cast<QPushButton*>(qbutton), &button);
 
     // wrapping a QObject* as variant
-    QScriptValue variant = eng.newVariant(qVariantFromValue((QObject*)&button));
+    QScriptValue variant = eng.newVariant(QVariant::fromValue((QObject*)&button));
     QCOMPARE(variant.toQObject(), (QObject*)&button);
     QCOMPARE(qscriptvalue_cast<QObject*>(variant), (QObject*)&button);
     QCOMPARE(qscriptvalue_cast<QWidget*>(variant), (QWidget*)&button);
     QCOMPARE(qscriptvalue_cast<QPushButton*>(variant), &button);
 
-    QScriptValue variant2 = eng.newVariant(qVariantFromValue((QWidget*)&button));
+    QScriptValue variant2 = eng.newVariant(QVariant::fromValue((QWidget*)&button));
     QCOMPARE(variant2.toQObject(), (QObject*)&button);
     QCOMPARE(qscriptvalue_cast<QObject*>(variant2), (QObject*)&button);
     QCOMPARE(qscriptvalue_cast<QWidget*>(variant2), (QWidget*)&button);
     QCOMPARE(qscriptvalue_cast<QPushButton*>(variant2), &button);
 
-    QScriptValue variant3 = eng.newVariant(qVariantFromValue(&button));
+    QScriptValue variant3 = eng.newVariant(QVariant::fromValue(&button));
     QVERIFY(variant3.isQObject());
     QCOMPARE(variant3.toQObject(), (QObject*)&button);
     QCOMPARE(qscriptvalue_cast<QObject*>(variant3), (QObject*)&button);
@@ -3580,7 +3580,7 @@ void tst_QScriptValue::castToPointer()
         double *dp = qscriptvalue_cast<double*>(v);
         QVERIFY(dp == 0);
 
-        QScriptValue v2 = eng.newVariant(qVariantFromValue(ip));
+        QScriptValue v2 = eng.newVariant(QVariant::fromValue(ip));
         QCOMPARE(qscriptvalue_cast<int*>(v2), ip);
     }
     {
@@ -3593,7 +3593,7 @@ void tst_QScriptValue::castToPointer()
         QBrush *bp = qscriptvalue_cast<QBrush*>(v);
         QVERIFY(bp == 0);
 
-        QScriptValue v2 = eng.newVariant(qVariantFromValue(cp));
+        QScriptValue v2 = eng.newVariant(QVariant::fromValue(cp));
         QCOMPARE(qscriptvalue_cast<QColor*>(v2), cp);
     }
 }
diff --git a/tests/benchmarks/script/qscriptqobject/tst_qscriptqobject.cpp b/tests/benchmarks/script/qscriptqobject/tst_qscriptqobject.cpp
index bdb5e1e..a8826a2 100644
--- a/tests/benchmarks/script/qscriptqobject/tst_qscriptqobject.cpp
+++ b/tests/benchmarks/script/qscriptqobject/tst_qscriptqobject.cpp
@@ -565,8 +565,8 @@ void tst_QScriptQObject::readDynamicProperty_data()
     QTest::newRow("int") << QVariant(123);
     QTest::newRow("double") << QVariant(double(123.0));
     QTest::newRow("string") << QVariant(QString::fromLatin1("hello"));
-    QTest::newRow("QObject*") << qVariantFromValue((QObject*)this);
-    QTest::newRow("CustomType") << qVariantFromValue(CustomType());
+    QTest::newRow("QObject*") << QVariant::fromValue((QObject*)this);
+    QTest::newRow("CustomType") << QVariant::fromValue(CustomType());
 }
 
 // Reads a dynamic property from JS. The purpose of this benchmark is