Remove last traces of QV8Engine

Change-Id: I59f738402d51e39188bbbca2ef1fbc8a61612372
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

3 files changed, 344 insertions, 12 deletions

diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index b65a2f2dad..b04a879c7f 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -102,7 +102,6 @@
 #include "qv4dataview_p.h"
 #include "qv4promiseobject_p.h"
 #include "qv4typedarray_p.h"
-#include <private/qv8engine_p.h>
 #include <private/qjsvalue_p.h>
 #include <private/qqmltypewrapper_p.h>
 #include <private/qqmlvaluetypewrapper_p.h>
@@ -110,9 +109,16 @@
 #include <private/qqmllistwrapper_p.h>
 #include <private/qqmllist_p.h>
 #include <private/qqmltypeloader_p.h>
+#include <private/qqmlmemoryprofiler_p.h>
+#include <private/qqmlbuiltinfunctions_p.h>
 #if QT_CONFIG(qml_locale)
 #include <private/qqmllocale_p.h>
 #endif
+#if QT_CONFIG(qml_xml_http_request)
+#include <private/qv4domerrors_p.h>
+#include <private/qqmlxmlhttprequest_p.h>
+#endif
+#include <private/qv4sqlerrors_p.h>
 #include <qqmlfile.h>
 
 #if USE(PTHREADS)
@@ -129,6 +135,8 @@
 #include <valgrind/memcheck.h>
 #endif
 
+Q_DECLARE_METATYPE(QList<int>)
+
 QT_BEGIN_NAMESPACE
 
 using namespace QV4;
@@ -142,6 +150,43 @@ ReturnedValue throwTypeError(const FunctionObject *b, const QV4::Value *, const
 
 qint32 ExecutionEngine::maxCallDepth = -1;
 
+template <typename ReturnType>
+ReturnType convertJSValueToVariantType(const QJSValue &value)
+{
+    return value.toVariant().value<ReturnType>();
+}
+
+static void saveJSValue(QDataStream &stream, const void *data)
+{
+    const QJSValue *jsv = reinterpret_cast<const QJSValue *>(data);
+    quint32 isNullOrUndefined = 0;
+    if (jsv->isNull())
+        isNullOrUndefined |= 0x1;
+    if (jsv->isUndefined())
+        isNullOrUndefined |= 0x2;
+    stream << isNullOrUndefined;
+    if (!isNullOrUndefined)
+        reinterpret_cast<const QJSValue*>(data)->toVariant().save(stream);
+}
+
+static void restoreJSValue(QDataStream &stream, void *data)
+{
+    QJSValue *jsv = reinterpret_cast<QJSValue*>(data);
+
+    quint32 isNullOrUndefined;
+    stream >> isNullOrUndefined;
+
+    if (isNullOrUndefined & 0x1) {
+        *jsv = QJSValue(QJSValue::NullValue);
+    } else if (isNullOrUndefined & 0x2) {
+        *jsv = QJSValue();
+    } else {
+        QVariant v;
+        v.load(stream);
+        QJSValuePrivate::setVariant(jsv, v);
+    }
+}
+
 ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine)
     : executableAllocator(new QV4::ExecutableAllocator)
     , regExpAllocator(new QV4::ExecutableAllocator)
@@ -149,7 +194,6 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine)
     , jsStack(new WTF::PageAllocation)
     , gcStack(new WTF::PageAllocation)
     , globalCode(nullptr)
-    , v8Engine(nullptr)
     , publicEngine(jsEngine)
     , m_engineId(engineSerial.fetchAndAddOrdered(1))
     , regExpCache(nullptr)
@@ -157,6 +201,10 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine)
 #if QT_CONFIG(qml_jit)
     , m_canAllocateExecutableMemory(OSAllocator::canAllocateExecutableMemory())
 #endif
+#if QT_CONFIG(qml_xml_http_request)
+    , m_xmlHttpRequestData(nullptr)
+#endif
+    , m_qmlEngine(nullptr)
 {
     memoryManager = new QV4::MemoryManager(this);
 
@@ -643,11 +691,28 @@ ExecutionEngine::ExecutionEngine(QJSEngine *jsEngine)
     pd->set = thrower();
     functionPrototype()->insertMember(id_caller(), pd, Attr_Accessor|Attr_ReadOnly_ButConfigurable);
     functionPrototype()->insertMember(id_arguments(), pd, Attr_Accessor|Attr_ReadOnly_ButConfigurable);
+
+    QML_MEMORY_SCOPE_STRING("QV4Engine::QV4Engine");
+    qMetaTypeId<QJSValue>();
+    qMetaTypeId<QList<int> >();
+
+    if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QVariantMap>())
+        QMetaType::registerConverter<QJSValue, QVariantMap>(convertJSValueToVariantType<QVariantMap>);
+    if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QVariantList>())
+        QMetaType::registerConverter<QJSValue, QVariantList>(convertJSValueToVariantType<QVariantList>);
+    if (!QMetaType::hasRegisteredConverterFunction<QJSValue, QStringList>())
+        QMetaType::registerConverter<QJSValue, QStringList>(convertJSValueToVariantType<QStringList>);
+    QMetaType::registerStreamOperators(qMetaTypeId<QJSValue>(), saveJSValue, restoreJSValue);
+
+    QV4::QObjectWrapper::initializeBindings(this);
+
+    m_delayedCallQueue.init(this);
 }
 
 ExecutionEngine::~ExecutionEngine()
 {
     modules.clear();
+    qDeleteAll(m_extensionData);
     delete m_multiplyWrappedQObjects;
     m_multiplyWrappedQObjects = nullptr;
     delete identifierTable;
@@ -664,6 +729,11 @@ ExecutionEngine::~ExecutionEngine()
     delete jsStack;
     gcStack->deallocate();
     delete gcStack;
+
+#if QT_CONFIG(qml_xml_http_request)
+    qt_rem_qmlxmlhttprequest(this, m_xmlHttpRequestData);
+    m_xmlHttpRequestData = nullptr;
+#endif
 }
 
 ExecutionContext *ExecutionEngine::currentContext() const
@@ -1750,6 +1820,133 @@ QQmlRefPointer<CompiledData::CompilationUnit> ExecutionEngine::loadModule(const
     return newModule;
 }
 
+void ExecutionEngine::initQmlGlobalObject()
+{
+    initializeGlobal();
+    freezeObject(*globalObject);
+}
+
+void ExecutionEngine::initializeGlobal()
+{
+    QV4::Scope scope(this);
+    QV4::GlobalExtensions::init(globalObject, QJSEngine::AllExtensions);
+
+    QV4::ScopedObject qt(scope, memoryManager->allocate<QV4::QtObject>(qmlEngine()));
+    globalObject->defineDefaultProperty(QStringLiteral("Qt"), qt);
+
+#if QT_CONFIG(qml_locale)
+    QQmlLocale::registerStringLocaleCompare(this);
+    QQmlDateExtension::registerExtension(this);
+    QQmlNumberExtension::registerExtension(this);
+#endif
+
+#if QT_CONFIG(qml_xml_http_request)
+    qt_add_domexceptions(this);
+    m_xmlHttpRequestData = qt_add_qmlxmlhttprequest(this);
+#endif
+
+    qt_add_sqlexceptions(this);
+
+    {
+        for (uint i = 0; i < globalObject->internalClass()->size; ++i) {
+            if (globalObject->internalClass()->nameMap.at(i).isString()) {
+                QV4::PropertyKey id = globalObject->internalClass()->nameMap.at(i);
+                m_illegalNames.insert(id.toQString());
+            }
+        }
+    }
+}
+
+const QSet<QString> &ExecutionEngine::illegalNames() const
+{
+    return m_illegalNames;
+}
+
+void ExecutionEngine::setQmlEngine(QQmlEngine *engine)
+{
+    m_qmlEngine = engine;
+    initQmlGlobalObject();
+}
+
+static void freeze_recursive(QV4::ExecutionEngine *v4, QV4::Object *object)
+{
+    if (object->as<QV4::QObjectWrapper>())
+        return;
+
+    QV4::Scope scope(v4);
+
+    bool instanceOfObject = false;
+    QV4::ScopedObject p(scope, object->getPrototypeOf());
+    while (p) {
+        if (p->d() == v4->objectPrototype()->d()) {
+            instanceOfObject = true;
+            break;
+        }
+        p = p->getPrototypeOf();
+    }
+    if (!instanceOfObject)
+        return;
+
+    QV4::Heap::InternalClass *frozen = object->internalClass()->propertiesFrozen();
+    if (object->internalClass() == frozen)
+        return;
+    object->setInternalClass(frozen);
+
+    QV4::ScopedObject o(scope);
+    for (uint i = 0; i < frozen->size; ++i) {
+        if (!frozen->nameMap.at(i).isStringOrSymbol())
+            continue;
+        o = *object->propertyData(i);
+        if (o)
+            freeze_recursive(v4, o);
+    }
+}
+
+void ExecutionEngine::freezeObject(const QV4::Value &value)
+{
+    QV4::Scope scope(this);
+    QV4::ScopedObject o(scope, value);
+    freeze_recursive(this, o);
+}
+
+void ExecutionEngine::startTimer(const QString &timerName)
+{
+    if (!m_time.isValid())
+        m_time.start();
+    m_startedTimers[timerName] = m_time.elapsed();
+}
+
+qint64 ExecutionEngine::stopTimer(const QString &timerName, bool *wasRunning)
+{
+    if (!m_startedTimers.contains(timerName)) {
+        *wasRunning = false;
+        return 0;
+    }
+    *wasRunning = true;
+    qint64 startedAt = m_startedTimers.take(timerName);
+    return m_time.elapsed() - startedAt;
+}
+
+int ExecutionEngine::consoleCountHelper(const QString &file, quint16 line, quint16 column)
+{
+    const QString key = file + QString::number(line) + QString::number(column);
+    int number = m_consoleCount.value(key, 0);
+    number++;
+    m_consoleCount.insert(key, number);
+    return number;
+}
+
+void ExecutionEngine::setExtensionData(int index, Deletable *data)
+{
+    if (m_extensionData.count() <= index)
+        m_extensionData.resize(index + 1);
+
+    if (m_extensionData.at(index))
+        delete m_extensionData.at(index);
+
+    m_extensionData[index] = data;
+}
+
 // Converts a JS value to a meta-type.
 // data must point to a place that can store a value of the given type.
 // Returns true if conversion succeeded, false otherwise.
@@ -1996,4 +2193,23 @@ static QObject *qtObjectFromJS(QV4::ExecutionEngine *engine, const QV4::Value &v
     return wrapper->object();
 }
 
+struct QV4EngineRegistrationData
+{
+    QV4EngineRegistrationData() : extensionCount(0) {}
+
+    QMutex mutex;
+    int extensionCount;
+};
+Q_GLOBAL_STATIC(QV4EngineRegistrationData, registrationData);
+
+QMutex *ExecutionEngine::registrationMutex()
+{
+    return &registrationData()->mutex;
+}
+
+int ExecutionEngine::registerExtension()
+{
+    return registrationData()->extensionCount++;
+}
+
 QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index 4ce854bc52..0d113754c0 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -53,13 +53,16 @@
 #include "qv4global_p.h"
 #include "qv4managed_p.h"
 #include "qv4context_p.h"
+#include "qv4stackframe_p.h"
 #include <private/qintrusivelist_p.h>
 #include "qv4enginebase_p.h"
 #include <private/qqmlrefcount_p.h>
 #include <private/qqmljsengine_p.h>
+#include <private/qqmldelayedcallqueue_p.h>
+#include <QtCore/qelapsedtimer.h>
+#include <QtCore/qmutex.h>
 
 #include "qv4function_p.h"
-#include <private/qv8engine_p.h>
 #include <private/qv4compileddata_p.h>
 
 namespace WTF {
@@ -67,9 +70,65 @@ class BumpPointerAllocator;
 class PageAllocation;
 }
 
+#define V4_DEFINE_EXTENSION(dataclass, datafunction) \
+    static inline dataclass *datafunction(QV4::ExecutionEngine *engine) \
+    { \
+        static int extensionId = -1; \
+        if (extensionId == -1) { \
+            QV4::ExecutionEngine::registrationMutex()->lock(); \
+            if (extensionId == -1) \
+                extensionId = QV4::ExecutionEngine::registerExtension(); \
+            QV4::ExecutionEngine::registrationMutex()->unlock(); \
+        } \
+        dataclass *rv = (dataclass *)engine->extensionData(extensionId); \
+        if (!rv) { \
+            rv = new dataclass(engine); \
+            engine->setExtensionData(extensionId, rv); \
+        } \
+        return rv; \
+    } \
+
+
 QT_BEGIN_NAMESPACE
 
-class QV8Engine;
+namespace QV4 { struct QObjectMethod; }
+
+// Used to allow a QObject method take and return raw V4 handles without having to expose
+// 48 in the public API.
+// Use like this:
+//     class MyClass : public QObject {
+//         Q_OBJECT
+//         ...
+//         Q_INVOKABLE void myMethod(QQmlV4Function*);
+//     };
+// The QQmlV8Function - and consequently the arguments and return value - only remains
+// valid during the call.  If the return value isn't set within myMethod(), the will return
+// undefined.
+
+class QQmlV4Function
+{
+public:
+    int length() const { return callData->argc(); }
+    QV4::ReturnedValue operator[](int idx) const { return (idx < callData->argc() ? callData->args[idx].asReturnedValue() : QV4::Encode::undefined()); }
+    void setReturnValue(QV4::ReturnedValue rv) { *retVal = rv; }
+    QV4::ExecutionEngine *v4engine() const { return e; }
+private:
+    friend struct QV4::QObjectMethod;
+    QQmlV4Function();
+    QQmlV4Function(const QQmlV4Function &);
+    QQmlV4Function &operator=(const QQmlV4Function &);
+
+    QQmlV4Function(QV4::CallData *callData, QV4::Value *retVal, QV4::ExecutionEngine *e)
+        : callData(callData), retVal(retVal), e(e)
+    {
+        callData->thisObject = QV4::Encode::undefined();
+    }
+
+    QV4::CallData *callData;
+    QV4::Value *retVal;
+    QV4::ExecutionEngine *e;
+};
+
 class QQmlError;
 class QJSEngine;
 class QQmlEngine;
@@ -127,8 +186,7 @@ public:
     Function *globalCode;
 
     QJSEngine *jsEngine() const { return publicEngine; }
-    QQmlEngine *qmlEngine() const { return v8Engine ? v8Engine->engine() : nullptr; }
-    QV8Engine *v8Engine;
+    QQmlEngine *qmlEngine() const { return m_qmlEngine; }
     QJSEngine *publicEngine;
 
     enum JSObjects {
@@ -599,6 +657,44 @@ public:
     }
 
     QV4::ReturnedValue global();
+    void initQmlGlobalObject();
+    void initializeGlobal();
+
+    void freezeObject(const QV4::Value &value);
+
+    // Return the list of illegal id names (the names of the properties on the global object)
+    const QSet<QString> &illegalNames() const;
+
+#if QT_CONFIG(qml_xml_http_request)
+    void *xmlHttpRequestData() const { return m_xmlHttpRequestData; }
+#endif
+
+    void setQmlEngine(QQmlEngine *engine);
+
+    QQmlDelayedCallQueue *delayedCallQueue() { return &m_delayedCallQueue; }
+
+    // used for console.time(), console.timeEnd()
+    void startTimer(const QString &timerName);
+    qint64 stopTimer(const QString &timerName, bool *wasRunning);
+
+    // used for console.count()
+    int consoleCountHelper(const QString &file, quint16 line, quint16 column);
+
+    struct Deletable {
+        virtual ~Deletable() {}
+    };
+
+    static QMutex *registrationMutex();
+    static int registerExtension();
+
+    void setExtensionData(int, Deletable *);
+    Deletable *extensionData(int index) const
+    {
+        if (index < m_extensionData.count())
+            return m_extensionData[index];
+        else
+            return nullptr;
+    }
 
     double localTZA = 0.0; // local timezone, initialized at startup
 
@@ -616,10 +712,26 @@ private:
     QScopedPointer<QV4::Debugging::Debugger> m_debugger;
     QScopedPointer<QV4::Profiling::Profiler> m_profiler;
 #endif
+    QSet<QString> m_illegalNames;
     int jitCallCountThreshold;
 
     // used by generated Promise objects to handle 'then' events
     QScopedPointer<QV4::Promise::ReactionHandler> m_reactionHandler;
+
+#if QT_CONFIG(qml_xml_http_request)
+    void *m_xmlHttpRequestData;
+#endif
+
+    QQmlEngine *m_qmlEngine;
+
+    QQmlDelayedCallQueue m_delayedCallQueue;
+
+    QElapsedTimer m_time;
+    QHash<QString, qint64> m_startedTimers;
+
+    QHash<QString, quint32> m_consoleCount;
+
+    QVector<Deletable *> m_extensionData;
 };
 
 #define CHECK_STACK_LIMITS(v4) if ((v4)->checkStackLimits()) return Encode::undefined(); \
diff --git a/src/qml/jsruntime/qv4include.cpp b/src/qml/jsruntime/qv4include.cpp
index 3c732bc555..c0885a418c 100644
--- a/src/qml/jsruntime/qv4include.cpp
+++ b/src/qml/jsruntime/qv4include.cpp
@@ -72,13 +72,17 @@ QV4Include::QV4Include(const QUrl &url, QV4::ExecutionEngine *engine,
     m_resultObject.set(v4, resultValue(v4));
 
 #if QT_CONFIG(qml_network)
-    m_network = engine->v8Engine->networkAccessManager();
+    if (QQmlEngine *qmlEngine = engine->qmlEngine()) {
+        m_network = qmlEngine->networkAccessManager();
 
-    QNetworkRequest request;
-    request.setUrl(url);
+        QNetworkRequest request;
+        request.setUrl(url);
 
-    m_reply = m_network->get(request);
-    QObject::connect(m_reply, SIGNAL(finished()), this, SLOT(finished()));
+        m_reply = m_network->get(request);
+        QObject::connect(m_reply, SIGNAL(finished()), this, SLOT(finished()));
+    } else {
+        finished();
+    }
 #else
     finished();
 #endif
@@ -197,7 +201,7 @@ void QV4Include::finished()
 }
 
 /*
-    Documented in qv8engine.cpp
+    Documented in qv4engine.cpp
 */
 QV4::ReturnedValue QV4Include::method_include(const QV4::FunctionObject *b, const QV4::Value *, const QV4::Value *argv, int argc)
 {