isolate calls to the QtScript libraries to an interface we control

Heather Anderson committed 5 years ago

Commit 1e018db1 parent 713b29e260 files · +6904 −5064Browse files

Showing the changes to libraries/script-engine/src/RecordingScriptingInterface.cpp (1 of 260 files). Show all

Unified · Split

libraries/script-engine/src/RecordingScriptingInterface.cpp+36−20

 #include <QStandardPaths>
 #include <QtCore/QThread>
 #include <QtCore/QUrl>
-#include <QtScript/QScriptValue>
 #include <QtWidgets/QFileDialog>
 #include <shared/QtHelpers.h>
 #include <recording/Frame.h>
 #include <recording/ClipCache.h>
+#include "ScriptEngine.h"
 #include "ScriptEngineLogging.h"
+#include "ScriptManager.h"
+#include "ScriptValue.h"
 using namespace recording;
     return _player->length();
 }
-void RecordingScriptingInterface::playClip(NetworkClipLoaderPointer clipLoader, const QString& url, QScriptValue callback) {
+void RecordingScriptingInterface::playClip(NetworkClipLoaderPointer clipLoader, const QString& url, ScriptValuePointer callback) {
     _player->queueClip(clipLoader->getClip());
-    if (callback.isFunction()) {
+    if (callback->isFunction()) {
-        QScriptValueList args { true, url };
+        auto engine = callback->engine();
-        callback.call(QScriptValue(), args);
+        ScriptValueList args{ engine->newValue(true), engine->newValue(url) };
+        callback->call(ScriptValuePointer(), args);
     }
 }
-void RecordingScriptingInterface::loadRecording(const QString& url, QScriptValue callback) {
+void RecordingScriptingInterface::loadRecording(const QString& url, ScriptValuePointer callback) {
     if (QThread::currentThread() != thread()) {
-        BLOCKING_INVOKE_METHOD(this, "loadRecording", Q_ARG(const QString&, url), Q_ARG(QScriptValue, callback));
+        BLOCKING_INVOKE_METHOD(this, "loadRecording", Q_ARG(const QString&, url), Q_ARG(ScriptValuePointer, callback));
         return;
     }
     auto weakClipLoader = clipLoader.toWeakRef();
+    auto manager = callback->engine()->manager();
+    if (!manager) {
+        qWarning() << "This script does not belong to a ScriptManager";
+        return;
+    }
     // when clip loaded, call the callback with the URL and success boolean
-    connect(clipLoader.data(), &recording::NetworkClipLoader::clipLoaded, callback.engine(),
+    connect(clipLoader.data(), &recording::NetworkClipLoader::clipLoaded, manager,
             [this, weakClipLoader, url, callback]() mutable {
         if (auto clipLoader = weakClipLoader.toStrongRef()) {
     });
     // when clip load fails, call the callback with the URL and failure boolean
-    connect(clipLoader.data(), &recording::NetworkClipLoader::failed, callback.engine(), [this, weakClipLoader, url, callback](QNetworkReply::NetworkError error) mutable {
+    connect(clipLoader.data(), &recording::NetworkClipLoader::failed, manager,
+            [this, weakClipLoader, url, callback](QNetworkReply::NetworkError error) mutable {
         qCDebug(scriptengine) << "Failed to load recording from\"" << url << '"';
-        if (callback.isFunction()) {
+        if (callback->isFunction()) {
-            QScriptValueList args { false, url };
+            auto engine = callback->engine();
-            callback.call(QScriptValue(), args);
+            ScriptValueList args{ engine->newValue(false), engine->newValue(url) };
+            callback->call(ScriptValuePointer(), args);
         }
         if (auto clipLoader = weakClipLoader.toStrongRef()) {
     recording::Clip::toFile(filename, _lastClip);
 }
-bool RecordingScriptingInterface::saveRecordingToAsset(QScriptValue getClipAtpUrl) {
+bool RecordingScriptingInterface::saveRecordingToAsset(ScriptValuePointer getClipAtpUrl) {
-    if (!getClipAtpUrl.isFunction()) {
+    if (!getClipAtpUrl->isFunction()) {
         qCWarning(scriptengine) << "The argument is not a function.";
         return false;
     }
         bool result;
         BLOCKING_INVOKE_METHOD(this, "saveRecordingToAsset",
             Q_RETURN_ARG(bool, result),
-            Q_ARG(QScriptValue, getClipAtpUrl));
+            Q_ARG(ScriptValuePointer, getClipAtpUrl));
         return result;
     }
         return false;
     }
+    auto manager = getClipAtpUrl->engine()->manager();
+    if (!manager) {
+        qWarning() << "This script does not belong to a ScriptManager";
+        return false;
+    }
     if (auto upload = DependencyManager::get<AssetClient>()->createUpload(recording::Clip::toBuffer(_lastClip))) {
-        QObject::connect(upload, &AssetUpload::finished,
+        QObject::connect(upload, &AssetUpload::finished, manager, [=](AssetUpload* upload, const QString& hash) mutable {
-                         getClipAtpUrl.engine(), [=](AssetUpload* upload, const QString& hash) mutable {
             QString clip_atp_url = "";
             if (upload->getError() == AssetUpload::NoError) {
                 qCWarning(scriptengine) << "Error during the Asset upload.";
             }
-            QScriptValueList args;
+            ScriptValueList args;
-            args << clip_atp_url;
+            args << getClipAtpUrl->engine()->newValue(clip_atp_url);
-            getClipAtpUrl.call(QScriptValue(), args);
+            getClipAtpUrl->call(ScriptValuePointer(), args);
         });
         upload->start();
         return true;