Move data of some Qml related objects into Heap namespace.

Change-Id: I6e6b24466de1e49efd5f3eaa67db82873170445b
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

src/qml/qml/qqmlcontextwrapper.cpp

@@ -53,7 +53,7 @@ using namespace QV4;
 
 DEFINE_OBJECT_VTABLE(QmlContextWrapper);
 
-QmlContextWrapper::Data::Data(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext)
+Heap::QmlContextWrapper::QmlContextWrapper(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext)
     : Heap::Object(QV8Engine::getV4(engine))
     , readOnly(true)
     , ownsContext(ownsContext)
@@ -61,10 +61,10 @@ QmlContextWrapper::Data::Data(QV8Engine *engine, QQmlContextData *context, QObje
     , context(context)
     , scopeObject(scopeObject)
 {
-    setVTable(staticVTable());
+    setVTable(QV4::QmlContextWrapper::staticVTable());
 }
 
-QmlContextWrapper::Data::~Data()
+Heap::QmlContextWrapper::~QmlContextWrapper()
 {
     if (context && ownsContext)
         context->destroy();
@@ -432,16 +432,16 @@ ReturnedValue QmlContextWrapper::qmlSingletonWrapper(QV8Engine *v8, String *name
 
 DEFINE_OBJECT_VTABLE(QQmlIdObjectsArray);
 
-QQmlIdObjectsArray::Data::Data(ExecutionEngine *engine, QmlContextWrapper *contextWrapper)
+Heap::QQmlIdObjectsArray::QQmlIdObjectsArray(ExecutionEngine *engine, QV4::QmlContextWrapper *contextWrapper)
     : Heap::Object(engine)
     , contextWrapper(contextWrapper)
 {
-    setVTable(staticVTable());
+    setVTable(QV4::QQmlIdObjectsArray::staticVTable());
 }
 
 ReturnedValue QQmlIdObjectsArray::getIndexed(Managed *m, uint index, bool *hasProperty)
 {
-    QQmlIdObjectsArray *This = static_cast<QQmlIdObjectsArray*>(m);
+    QQmlIdObjectsArray *This = static_cast<QV4::QQmlIdObjectsArray*>(m);
     QQmlContextData *context = This->d()->contextWrapper->getContext();
     if (!context) {
         if (hasProperty)

src/qml/qml/qqmlcontextwrapper_p.h

@@ -62,21 +62,32 @@ struct Function;
 }
 
 struct QQmlIdObjectsArray;
+struct QmlContextWrapper;
+
+namespace Heap {
+
+struct QmlContextWrapper : Object {
+    QmlContextWrapper(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext = false);
+    ~QmlContextWrapper();
+    bool readOnly;
+    bool ownsContext;
+    bool isNullWrapper;
+
+    QQmlGuardedContextData context;
+    QPointer<QObject> scopeObject;
+    QQmlIdObjectsArray *idObjectsWrapper;
+};
+
+struct QQmlIdObjectsArray : Object {
+    QQmlIdObjectsArray(QV4::ExecutionEngine *engine, QV4::QmlContextWrapper *contextWrapper);
+    QV4::QmlContextWrapper *contextWrapper;
+};
+
+}
 
 struct Q_QML_EXPORT QmlContextWrapper : Object
 {
-    struct Data : Heap::Object {
+    V4_OBJECT2(QmlContextWrapper, Object)
-        Data(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext = false);
-        ~Data();
-        bool readOnly;
-        bool ownsContext;
-        bool isNullWrapper;
-
-        QQmlGuardedContextData context;
-        QPointer<QObject> scopeObject;
-        QQmlIdObjectsArray *idObjectsWrapper;
-    };
-    V4_OBJECT(Object)
 
     static ReturnedValue qmlScope(QV8Engine *e, QQmlContextData *ctxt, QObject *scope);
     static ReturnedValue urlScope(QV8Engine *e, const QUrl &);
@@ -104,11 +115,7 @@ struct Q_QML_EXPORT QmlContextWrapper : Object
 
 struct QQmlIdObjectsArray : public Object
 {
-    struct Data : Heap::Object {
+    V4_OBJECT2(QQmlIdObjectsArray, Object)
-        Data(ExecutionEngine *engine, QmlContextWrapper *contextWrapper);
-        QmlContextWrapper *contextWrapper;
-    };
-    V4_OBJECT(Object)
 
     static ReturnedValue getIndexed(Managed *m, uint index, bool *hasProperty);
     static void markObjects(Heap::Base *that, ExecutionEngine *engine);

src/qml/qml/qqmlvaluetypewrapper.cpp

@@ -47,50 +47,59 @@
 
 QT_BEGIN_NAMESPACE
 
-using namespace QV4;
 
-DEFINE_OBJECT_VTABLE(QmlValueTypeWrapper);
+DEFINE_OBJECT_VTABLE(QV4::QmlValueTypeWrapper);
+
+namespace QV4 {
+namespace Heap {
+
+struct QmlValueTypeReference : QmlValueTypeWrapper
+{
+    QmlValueTypeReference(QV8Engine *engine);
+    QPointer<QObject> object;
+    int property;
+};
+
+struct QmlValueTypeCopy : QmlValueTypeWrapper
+{
+    QmlValueTypeCopy(QV8Engine *engine);
+    QVariant value;
+};
+
+}
+}
+
+using namespace QV4;
 
 struct QmlValueTypeReference : public QmlValueTypeWrapper
 {
-    struct Data : QmlValueTypeWrapper::Data
+    V4_OBJECT2(QmlValueTypeReference, QmlValueTypeWrapper)
-    {
-        Data(QV8Engine *engine);
-        QPointer<QObject> object;
-        int property;
-    };
-    V4_OBJECT(QmlValueTypeWrapper)
 };
 
 DEFINE_OBJECT_VTABLE(QmlValueTypeReference);
 
 struct QmlValueTypeCopy : public QmlValueTypeWrapper
 {
-    struct Data : QmlValueTypeWrapper::Data
+    V4_OBJECT2(QmlValueTypeCopy, QmlValueTypeWrapper)
-    {
-        Data(QV8Engine *engine);
-        QVariant value;
-    };
-    V4_OBJECT(QmlValueTypeWrapper)
 };
 
 DEFINE_OBJECT_VTABLE(QmlValueTypeCopy);
 
-QmlValueTypeWrapper::Data::Data(QV8Engine *engine, ObjectType objectType)
+Heap::QmlValueTypeWrapper::QmlValueTypeWrapper(QV8Engine *engine, ObjectType objectType)
     : Heap::Object(QV8Engine::getV4(engine))
     , v8(engine)
     , objectType(objectType)
 {
-    setVTable(staticVTable());
+    setVTable(QV4::QmlValueTypeWrapper::staticVTable());
 }
 
-QmlValueTypeReference::Data::Data(QV8Engine *engine)
+Heap::QmlValueTypeReference::QmlValueTypeReference(QV8Engine *engine)
-    : QmlValueTypeWrapper::Data(engine, Reference)
+    : Heap::QmlValueTypeWrapper(engine, Reference)
 {
 }
 
-QmlValueTypeCopy::Data::Data(QV8Engine *engine)
+Heap::QmlValueTypeCopy::QmlValueTypeCopy(QV8Engine *engine)
-    : QmlValueTypeWrapper::Data(engine, Copy)
+    : Heap::QmlValueTypeWrapper(engine, Copy)
 {
 }
 
@@ -164,7 +173,7 @@ ReturnedValue QmlValueTypeWrapper::create(QV8Engine *v8, const QVariant &value,
 
 QVariant QmlValueTypeWrapper::toVariant() const
 {
-    if (d()->objectType == QmlValueTypeWrapper::Reference) {
+    if (d()->objectType == Heap::QmlValueTypeWrapper::Reference) {
         const QmlValueTypeReference *reference = static_cast<const QmlValueTypeReference *>(this);
 
         if (reference->d()->object && readReferenceValue(reference)) {
@@ -173,7 +182,7 @@ QVariant QmlValueTypeWrapper::toVariant() const
             return QVariant();
         }
     } else {
-        Q_ASSERT(d()->objectType == QmlValueTypeWrapper::Copy);
+        Q_ASSERT(d()->objectType == Heap::QmlValueTypeWrapper::Copy);
         return static_cast<const QmlValueTypeCopy *>(this)->d()->value;
     }
 }
@@ -182,10 +191,10 @@ void QmlValueTypeWrapper::destroy(Managed *that)
 {
     Q_ASSERT(that->as<QmlValueTypeWrapper>());
     QmlValueTypeWrapper *w = static_cast<QmlValueTypeWrapper *>(that);
-    if (w->d()->objectType == Reference)
+    if (w->d()->objectType == Heap::QmlValueTypeWrapper::Reference)
-        static_cast<QmlValueTypeReference *>(w)->d()->~Data();
+        static_cast<QmlValueTypeReference *>(w)->d()->Heap::QmlValueTypeReference::~QmlValueTypeReference();
     else
-        static_cast<QmlValueTypeCopy *>(w)->d()->~Data();
+        static_cast<QmlValueTypeCopy *>(w)->d()->Heap::QmlValueTypeCopy::~QmlValueTypeCopy();
 }
 
 bool QmlValueTypeWrapper::isEqualTo(Managed *m, Managed *other)
@@ -221,7 +230,7 @@ PropertyAttributes QmlValueTypeWrapper::query(const Managed *m, String *name)
 
 bool QmlValueTypeWrapper::isEqual(const QVariant& value)
 {
-    if (d()->objectType == QmlValueTypeWrapper::Reference) {
+    if (d()->objectType == Heap::QmlValueTypeWrapper::Reference) {
         QmlValueTypeReference *reference = static_cast<QmlValueTypeReference *>(this);
         if (reference->d()->object && readReferenceValue(reference)) {
             return reference->d()->type->isEqual(value);
@@ -229,7 +238,7 @@ bool QmlValueTypeWrapper::isEqual(const QVariant& value)
             return false;
         }
     } else {
-        Q_ASSERT(d()->objectType == QmlValueTypeWrapper::Copy);
+        Q_ASSERT(d()->objectType == Heap::QmlValueTypeWrapper::Copy);
         QmlValueTypeCopy *copy = static_cast<QmlValueTypeCopy *>(this);
         d()->type->setValue(copy->d()->value);
         if (d()->type->isEqual(value))
@@ -247,7 +256,7 @@ ReturnedValue QmlValueTypeWrapper::method_toString(CallContext *ctx)
     if (!w)
         return ctx->engine()->throwTypeError();
 
-    if (w->d()->objectType == QmlValueTypeWrapper::Reference) {
+    if (w->d()->objectType == Heap::QmlValueTypeWrapper::Reference) {
         QmlValueTypeReference *reference = static_cast<QmlValueTypeReference *>(w);
         if (reference->d()->object && readReferenceValue(reference)) {
             return w->d()->v8->toString(w->d()->type->toString());
@@ -255,7 +264,7 @@ ReturnedValue QmlValueTypeWrapper::method_toString(CallContext *ctx)
             return QV4::Encode::undefined();
         }
     } else {
-        Q_ASSERT(w->d()->objectType == QmlValueTypeWrapper::Copy);
+        Q_ASSERT(w->d()->objectType == Heap::QmlValueTypeWrapper::Copy);
         QmlValueTypeCopy *copy = static_cast<QmlValueTypeCopy *>(w);
         w->d()->type->setValue(copy->d()->value);
         return w->d()->v8->toString(w->d()->type->toString());
@@ -269,14 +278,14 @@ ReturnedValue QmlValueTypeWrapper::get(Managed *m, String *name, bool *hasProper
     QV4::ExecutionEngine *v4 = m->engine();
 
     // Note: readReferenceValue() can change the reference->type.
-    if (r->d()->objectType == QmlValueTypeWrapper::Reference) {
+    if (r->d()->objectType == Heap::QmlValueTypeWrapper::Reference) {
         QmlValueTypeReference *reference = static_cast<QmlValueTypeReference *>(r);
 
         if (!reference->d()->object || !readReferenceValue(reference))
             return Primitive::undefinedValue().asReturnedValue();
 
     } else {
-        Q_ASSERT(r->d()->objectType == QmlValueTypeWrapper::Copy);
+        Q_ASSERT(r->d()->objectType == Heap::QmlValueTypeWrapper::Copy);
 
         QmlValueTypeCopy *copy = static_cast<QmlValueTypeCopy *>(r);
 
@@ -334,7 +343,7 @@ void QmlValueTypeWrapper::put(Managed *m, String *name, const ValueRef value)
     Scoped<QmlValueTypeWrapper> r(scope, static_cast<QmlValueTypeWrapper *>(m));
 
     QByteArray propName = name->toQString().toUtf8();
-    if (r->d()->objectType == QmlValueTypeWrapper::Reference) {
+    if (r->d()->objectType == Heap::QmlValueTypeWrapper::Reference) {
         QmlValueTypeReference *reference = static_cast<QmlValueTypeReference *>(r.getPointer());
         QMetaProperty writebackProperty = reference->d()->object->metaObject()->property(reference->d()->property);
 
@@ -399,7 +408,7 @@ void QmlValueTypeWrapper::put(Managed *m, String *name, const ValueRef value)
         }
 
     } else {
-        Q_ASSERT(r->d()->objectType == QmlValueTypeWrapper::Copy);
+        Q_ASSERT(r->d()->objectType == Heap::QmlValueTypeWrapper::Copy);
 
         QmlValueTypeCopy *copy = static_cast<QmlValueTypeCopy *>(r.getPointer());
 

src/qml/qml/qqmlvaluetypewrapper_p.h

@@ -58,16 +58,21 @@ class QV8Engine;
 
 namespace QV4 {
 
+namespace Heap {
+
+struct QmlValueTypeWrapper : Object {
+    enum ObjectType { Reference, Copy };
+    QmlValueTypeWrapper(QV8Engine *engine, ObjectType type);
+    QV8Engine *v8;
+    ObjectType objectType;
+    mutable QQmlValueType *type;
+};
+
+}
+
 struct Q_QML_EXPORT QmlValueTypeWrapper : Object
 {
-    enum ObjectType { Reference, Copy };
+    V4_OBJECT2(QmlValueTypeWrapper, Object)
-    struct Data : Heap::Object {
-        Data(QV8Engine *engine, ObjectType type);
-        QV8Engine *v8;
-        ObjectType objectType;
-        mutable QQmlValueType *type;
-    };
-    V4_OBJECT(Object)
 
 public:
 

src/qml/types/qqmldelegatemodel.cpp

@@ -1860,7 +1860,7 @@ QV4::ReturnedValue QQmlDelegateModelItem::get_index(QQmlDelegateModelItem *thisI
 
 DEFINE_OBJECT_VTABLE(QQmlDelegateModelItemObject);
 
-QQmlDelegateModelItemObject::Data::~Data()
+QV4::Heap::QQmlDelegateModelItemObject::~QQmlDelegateModelItemObject()
 {
     item->Dispose();
 }

src/qml/types/qqmldelegatemodel_p_p.h

@@ -151,23 +151,31 @@ protected:
     void objectDestroyed(QObject *);
 };
 
+namespace QV4 {
+namespace Heap {
+struct QQmlDelegateModelItemObject : Object {
+    inline QQmlDelegateModelItemObject(QV4::ExecutionEngine *engine, QQmlDelegateModelItem *item);
+    ~QQmlDelegateModelItemObject();
+    QQmlDelegateModelItem *item;
+};
+
+}
+}
+
 struct QQmlDelegateModelItemObject : QV4::Object
 {
-    struct Data : QV4::Heap::Object {
+    V4_OBJECT2(QQmlDelegateModelItemObject, QV4::Object)
-        Data(QV4::ExecutionEngine *engine, QQmlDelegateModelItem *item)
-            : QV4::Heap::Object(engine)
-            , item(item)
-        {
-            setVTable(staticVTable());
-        }
-        ~Data();
-        QQmlDelegateModelItem *item;
-    };
-    V4_OBJECT(QV4::Object)
 
     static void destroy(Managed *that);
 };
 
+QV4::Heap::QQmlDelegateModelItemObject::QQmlDelegateModelItemObject(QV4::ExecutionEngine *engine, QQmlDelegateModelItem *item)
+    : QV4::Heap::Object(engine)
+    , item(item)
+{
+    setVTable(::QQmlDelegateModelItemObject::staticVTable());
+}
+
 
 
 class QQmlDelegateModelPrivate;