Merge master -> api_changes

Includes fixes for tst_qfiledialog2, tst_qtextedit autotests on mac.

Change-Id: I49cac26894d31291a8339ccc1eb80b6a940f0827

1 files changed, 42 insertions, 56 deletions

diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp
index 2f67ae9287..5eaa93c7b0 100644
--- a/src/corelib/kernel/qvariant.cpp
+++ b/src/corelib/kernel/qvariant.cpp
@@ -279,7 +279,7 @@ inline bool qt_convertToBool(const QVariant::Private *const d)
 
  Converts \a d to type \a t, which is placed in \a result.
  */
-static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, bool *ok)
+static bool convert(const QVariant::Private *d, int t, void *result, bool *ok)
 {
     Q_ASSERT(d->type != uint(t));
     Q_ASSERT(result);
@@ -732,7 +732,7 @@ static bool convert(const QVariant::Private *d, QVariant::Type t, void *result,
     return true;
 }
 
-#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+#if !defined(QT_NO_DEBUG_STREAM)
 static void streamDebug(QDebug dbg, const QVariant &v)
 {
     QVariant::Private *d = const_cast<QVariant::Private *>(&v.data_ptr());
@@ -752,7 +752,7 @@ const QVariant::Handler qt_kernel_variant_handler = {
     compare,
     convert,
     0,
-#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+#if !defined(QT_NO_DEBUG_STREAM)
     streamDebug
 #else
     0
@@ -763,8 +763,8 @@ static void dummyConstruct(QVariant::Private *, const void *) { Q_ASSERT_X(false
 static void dummyClear(QVariant::Private *) { Q_ASSERT_X(false, "QVariant", "Trying to clear an unknown type"); }
 static bool dummyIsNull(const QVariant::Private *d) { Q_ASSERT_X(false, "QVariant::isNull", "Trying to call isNull on an unknown type"); return d->is_null; }
 static bool dummyCompare(const QVariant::Private *, const QVariant::Private *) { Q_ASSERT_X(false, "QVariant", "Trying to compare an unknown types"); return false; }
-static bool dummyConvert(const QVariant::Private *, QVariant::Type , void *, bool *) { Q_ASSERT_X(false, "QVariant", "Trying to convert an unknown type"); return false; }
-#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+static bool dummyConvert(const QVariant::Private *, int, void *, bool *) { Q_ASSERT_X(false, "QVariant", "Trying to convert an unknown type"); return false; }
+#if !defined(QT_NO_DEBUG_STREAM)
 static void dummyStreamDebug(QDebug, const QVariant &) { Q_ASSERT_X(false, "QVariant", "Trying to convert an unknown type"); }
 #endif
 const QVariant::Handler qt_dummy_variant_handler = {
@@ -778,7 +778,7 @@ const QVariant::Handler qt_dummy_variant_handler = {
     dummyCompare,
     dummyConvert,
     0,
-#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+#if !defined(QT_NO_DEBUG_STREAM)
     dummyStreamDebug
 #else
     0
@@ -840,14 +840,14 @@ static bool customCompare(const QVariant::Private *a, const QVariant::Private *b
     return !memcmp(a_ptr, b_ptr, QMetaType::sizeOf(a->type));
 }
 
-static bool customConvert(const QVariant::Private *, QVariant::Type, void *, bool *ok)
+static bool customConvert(const QVariant::Private *, int, void *, bool *ok)
 {
     if (ok)
         *ok = false;
     return false;
 }
 
-#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+#if !defined(QT_NO_DEBUG_STREAM)
 static void customStreamDebug(QDebug, const QVariant &) {}
 #endif
 
@@ -862,7 +862,7 @@ const QVariant::Handler qt_custom_variant_handler = {
     customCompare,
     customConvert,
     0,
-#if !defined(QT_NO_DEBUG_STREAM) && !defined(Q_BROKEN_DEBUG_STREAM)
+#if !defined(QT_NO_DEBUG_STREAM)
     customStreamDebug
 #else
     0
@@ -1062,9 +1062,9 @@ Q_CORE_EXPORT void QVariantPrivate::unregisterHandler(const int /* Modules::Name
 
 
 /*!
-    \fn QVariant::QVariant(int typeOrUserType, const void *copy)
+    \fn QVariant::QVariant(int typeId, const void *copy)
 
-    Constructs variant of type \a typeOrUserType, and initializes with
+    Constructs variant of type \a typeId, and initializes with
     \a copy if \a copy is not 0.
 
     Note that you have to pass the address of the variable you want stored.
@@ -1162,17 +1162,15 @@ QVariant::QVariant(QDataStream &s)
   \fn QVariant::QVariant(const char *val)
 
     Constructs a new variant with a string value of \a val.
-    The variant creates a deep copy of \a val, using the encoding
-    set by QTextCodec::setCodecForCStrings().
+    The variant creates a deep copy of \a val into a QString assuming
+    UTF-8 encoding on the input \a val.
 
     Note that \a val is converted to a QString for storing in the
-    variant and QVariant::type() will return QMetaType::QString for
+    variant and QVariant::userType() will return QMetaType::QString for
     the variant.
 
     You can disable this operator by defining \c
     QT_NO_CAST_FROM_ASCII when you compile your applications.
-
-    \sa QTextCodec::setCodecForCStrings()
 */
 
 #ifndef QT_NO_CAST_FROM_ASCII
@@ -1375,19 +1373,19 @@ QVariant::QVariant(const char *val)
 
 QVariant::QVariant(Type type)
 { create(type, 0); }
-QVariant::QVariant(int typeOrUserType, const void *copy)
-{ create(typeOrUserType, copy); d.is_null = false; }
+QVariant::QVariant(int typeId, const void *copy)
+{ create(typeId, copy); d.is_null = false; }
 
 /*! \internal
     flags is true if it is a pointer type
  */
-QVariant::QVariant(int typeOrUserType, const void *copy, uint flags)
+QVariant::QVariant(int typeId, const void *copy, uint flags)
 {
     if (flags) { //type is a pointer type
-        d.type = typeOrUserType;
+        d.type = typeId;
         d.data.ptr = *reinterpret_cast<void *const*>(copy);
     } else {
-        create(typeOrUserType, copy);
+        create(typeId, copy);
     }
     d.is_null = false;
 }
@@ -1565,7 +1563,7 @@ void QVariant::detach()
 */
 const char *QVariant::typeName() const
 {
-    return typeToName(Type(d.type));
+    return typeToName(d.type);
 }
 
 /*!
@@ -1582,17 +1580,17 @@ void QVariant::clear()
 }
 
 /*!
-    Converts the enum representation of the storage type, \a typ, to
+    Converts the int representation of the storage type, \a typeId, to
     its string representation.
 
     Returns a null pointer if the type is QVariant::Invalid or doesn't exist.
 */
-const char *QVariant::typeToName(Type typ)
+const char *QVariant::typeToName(int typeId)
 {
-    if (typ == Invalid)
+    if (typeId == Invalid)
         return 0;
 
-    return QMetaType::typeName(typ);
+    return QMetaType::typeName(typeId);
 }
 
 
@@ -1842,7 +1840,7 @@ QDataStream& operator<<(QDataStream &s, const QVariant::Type p)
 template <typename T>
 inline T qVariantToHelper(const QVariant::Private &d, const HandlersManager &handlerManager)
 {
-    const QVariant::Type targetType = static_cast<const QVariant::Type>(qMetaTypeId<T>());
+    const uint targetType = qMetaTypeId<T>();
     if (d.type == targetType)
         return *v_cast<T>(&d);
 
@@ -2163,7 +2161,7 @@ inline T qNumVariantToHelper(const QVariant::Private &d,
         return val;
 
     T ret = 0;
-    if (!handlerManager[d.type]->convert(&d, QVariant::Type(t), &ret, ok) && ok)
+    if (!handlerManager[d.type]->convert(&d, t, &ret, ok) && ok)
         *ok = false;
     return ret;
 }
@@ -2407,7 +2405,7 @@ static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
 
 /*!
     Returns true if the variant's type can be cast to the requested
-    type, \a t. Such casting is done automatically when calling the
+    type, \a targetTypeId. Such casting is done automatically when calling the
     toInt(), toBool(), ... methods.
 
     The following casts are done automatically:
@@ -2439,18 +2437,18 @@ static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] =
 
     \sa convert()
 */
-bool QVariant::canConvert(Type t) const
+bool QVariant::canConvert(int targetTypeId) const
 {
     // TODO Reimplement this function, currently it works but it is a historical mess.
     const uint currentType = ((d.type == QMetaType::Float) ? QVariant::Double : d.type);
-    if (uint(t) == uint(QMetaType::Float)) t = QVariant::Double;
+    if (uint(targetTypeId) == uint(QMetaType::Float)) targetTypeId = QVariant::Double;
 
-    if (currentType == uint(t))
+    if (currentType == uint(targetTypeId))
         return true;
 
     // FIXME It should be LastCoreType intead of Uuid
-    if (currentType > QVariant::Uuid || t > QVariant::Uuid) {
-        switch (uint(t)) {
+    if (currentType > int(QMetaType::QUuid) || targetTypeId > int(QMetaType::QUuid)) {
+        switch (uint(targetTypeId)) {
         case QVariant::Int:
             return currentType == QVariant::KeySequence
                    || currentType == QMetaType::ULong
@@ -2492,14 +2490,14 @@ bool QVariant::canConvert(Type t) const
         }
     }
 
-    if(t == String && currentType == StringList)
+    if (targetTypeId == String && currentType == StringList)
         return v_cast<QStringList>(&d)->count() == 1;
     else
-        return qCanConvertMatrix[t] & (1 << currentType);
+        return qCanConvertMatrix[targetTypeId] & (1 << currentType);
 }
 
 /*!
-    Casts the variant to the requested type, \a t. If the cast cannot be
+    Casts the variant to the requested type, \a targetTypeId. If the cast cannot be
     done, the variant is cleared. Returns true if the current type of
     the variant was successfully cast; otherwise returns false.
 
@@ -2510,23 +2508,23 @@ bool QVariant::canConvert(Type t) const
     \sa canConvert(), clear()
 */
 
-bool QVariant::convert(Type t)
+bool QVariant::convert(int targetTypeId)
 {
-    if (d.type == uint(t))
+    if (d.type == uint(targetTypeId))
         return true;
 
     QVariant oldValue = *this;
 
     clear();
-    if (!oldValue.canConvert(t))
+    if (!oldValue.canConvert(targetTypeId))
         return false;
 
-    create(t, 0);
+    create(targetTypeId, 0);
     if (oldValue.isNull())
         return false;
 
     bool isOk = true;
-    if (!handlerManager[d.type]->convert(&oldValue.d, t, data(), &isOk))
+    if (!handlerManager[d.type]->convert(&oldValue.d, targetTypeId, data(), &isOk))
         isOk = false;
     d.is_null = !isOk;
     return isOk;
@@ -2540,7 +2538,7 @@ bool QVariant::convert(Type t)
 bool QVariant::convert(const int type, void *ptr) const
 {
     Q_ASSERT(type < int(QMetaType::User));
-    return handlerManager[type]->convert(&d, QVariant::Type(type), ptr, 0);
+    return handlerManager[type]->convert(&d, type, ptr, 0);
 }
 
 
@@ -2607,7 +2605,7 @@ bool QVariant::cmp(const QVariant &v) const
             else
                 return toLongLong() == v.toLongLong();
         }
-        if (!v2.canConvert(Type(d.type)) || !v2.convert(Type(d.type)))
+        if (!v2.canConvert(d.type) || !v2.convert(d.type))
             return false;
     }
     return handlerManager[d.type]->compare(&d, &v2.d);
@@ -2646,28 +2644,16 @@ bool QVariant::isNull() const
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, const QVariant &v)
 {
-#ifndef Q_BROKEN_DEBUG_STREAM
     dbg.nospace() << "QVariant(" << QMetaType::typeName(v.userType()) << ", ";
     handlerManager[v.d.type]->debugStream(dbg, v);
     dbg.nospace() << ')';
     return dbg.space();
-#else
-    qWarning("This compiler doesn't support streaming QVariant to QDebug");
-    return dbg;
-    Q_UNUSED(v);
-#endif
 }
 
 QDebug operator<<(QDebug dbg, const QVariant::Type p)
 {
-#ifndef Q_BROKEN_DEBUG_STREAM
     dbg.nospace() << "QVariant::" << QMetaType::typeName(p);
     return dbg.space();
-#else
-    qWarning("This compiler doesn't support streaming QVariant::Type to QDebug");
-    return dbg;
-    Q_UNUSED(p);
-#endif
 }
 #endif