History

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/ScriptEngines.cpp (1 of 260 files). Show all

Unified · Split

libraries/script-engine/src/ScriptEngines.cpp+75−74
@@ -12,6 +12,7 @@ · 11 unmodified lines
1212 #include <QtCore/QSharedPointer>
1313
1414 #include <QtWidgets/QApplication>
15+#include <QtCore/QThread>
1516
1617 #include <shared/QtHelpers.h>
1718 #include <SettingHandle.h>
@@ -19,6 +20,7 @@ · 1 unmodified line
1920 #include <PathUtils.h>
2021 #include <shared/FileUtils.h>
2122
23+#include "ScriptCache.h"
2224 #include "ScriptEngine.h"
2325 #include "ScriptEngineLogging.h"
2426
@@ -65,7 +67,7 @@ void ScriptEngines::onErrorLoadingScript(const QString& url) { · 40 unmodified lines
6567 emit errorLoadingScript(url);
6668 }
6769
68−ScriptEngines::ScriptEngines(ScriptEngine::Context context, const QUrl& defaultScriptsOverride)
70+ScriptEngines::ScriptEngines(ScriptManager::Context context, const QUrl& defaultScriptsOverride)
6971 : _context(context), _defaultScriptsOverride(defaultScriptsOverride)
7072 {
7173 scriptGatekeeper.initialize();
@@ -138,53 +140,53 @@ QUrl expandScriptUrl(const QUrl& rawScriptURL) { · 66 unmodified lines
138140
139141 QObject* scriptsModel();
140142
141−void ScriptEngines::addScriptEngine(ScriptEnginePointer engine) {
143+void ScriptEngines::addScriptEngine(ScriptManagerPointer manager) {
142144 if (!_isStopped) {
143145 QMutexLocker locker(&_allScriptsMutex);
144− _allKnownScriptEngines.insert(engine);
146+ _allKnownScriptManagers.insert(manager);
145147 }
146148 }
147149
148−void ScriptEngines::removeScriptEngine(ScriptEnginePointer engine) {
150+void ScriptEngines::removeScriptEngine(ScriptManagerPointer manager) {
149151 // If we're not already in the middle of stopping all scripts, then we should remove ourselves
150152 // from the list of running scripts. We don't do this if we're in the process of stopping all scripts
151153 // because that method removes scripts from its list as it iterates them
152154 if (!_isStopped) {
153155 QMutexLocker locker(&_allScriptsMutex);
154− _allKnownScriptEngines.remove(engine);
156+ _allKnownScriptManagers.remove(manager);
155157 }
156158 }
157159
158160 void ScriptEngines::shutdownScripting() {
159161 _isStopped = true;
160162 QMutexLocker locker(&_allScriptsMutex);
161− qCDebug(scriptengine) << "Stopping all scripts.... currently known scripts:" << _allKnownScriptEngines.size();
163+ qCDebug(scriptengine) << "Stopping all scripts.... currently known scripts:" << _allKnownScriptManagers.size();
162164
163− QMutableSetIterator<ScriptEnginePointer> i(_allKnownScriptEngines);
165+ QMutableSetIterator<ScriptManagerPointer> i(_allKnownScriptManagers);
164166 while (i.hasNext()) {
165− ScriptEnginePointer scriptEngine = i.next();
166− QString scriptName = scriptEngine->getFilename();
167+ ScriptManagerPointer scriptManager = i.next();
168+ QString scriptName = scriptManager->getFilename();
167169
168170 // NOTE: typically all script engines are running. But there's at least one known exception to this, the
169171 // "entities sandbox" which is only used to evaluate entities scripts to test their validity before using
170172 // them. We don't need to stop scripts that aren't running.
171173 // TODO: Scripts could be shut down faster if we spread them across a threadpool.
172− if (scriptEngine->isRunning()) {
174+ if (scriptManager->isRunning()) {
173175 qCDebug(scriptengine) << "about to shutdown script:" << scriptName;
174176
175177 // We disconnect any script engine signals from the application because we don't want to do any
176178 // extra stopScript/loadScript processing that the Application normally does when scripts start
177179 // and stop. We can safely short circuit this because we know we're in the "quitting" process
178− scriptEngine->disconnect(this);
180+ scriptManager->disconnect(this);
179181
180182 // Gracefully stop the engine's scripting thread
181− scriptEngine->stop();
183+ scriptManager->stop();
182184
183185 // We need to wait for the engine to be done running before we proceed, because we don't
184186 // want any of the scripts final "scriptEnding()" or pending "update()" methods from accessing
185187 // any application state after we leave this stopAllScripts() method
186188 qCDebug(scriptengine) << "waiting on script:" << scriptName;
187− scriptEngine->waitTillDoneRunning(true);
189+ scriptManager->waitTillDoneRunning(true);
188190 qCDebug(scriptengine) << "done waiting on script:" << scriptName;
189191 }
190192 // Once the script is stopped, we can remove it from our set
@@ -372,8 +374,8 @@ void ScriptEngines::saveScripts() { · 181 unmodified lines
372374 QVariantList list;
373375
374376 {
375− QReadLocker lock(&_scriptEnginesHashLock);
376− for (auto it = _scriptEnginesHash.begin(); it != _scriptEnginesHash.end(); ++it) {
377+ QReadLocker lock(&_scriptManagersHashLock);
378+ for (auto it = _scriptManagersHash.begin(); it != _scriptManagersHash.end(); ++it) {
377379 // Save user-loaded scripts, only if they are set to quit when finished
378380 if (it.value() && it.value()->isUserLoaded() && !it.value()->isQuitWhenFinished()) {
379381 auto normalizedUrl = normalizeScriptURL(it.key());
@@ -390,8 +392,8 @@ void ScriptEngines::saveScripts() { · 10 unmodified lines
390392 }
391393
392394 QStringList ScriptEngines::getRunningScripts() {
393− QReadLocker lock(&_scriptEnginesHashLock);
394− QList<QUrl> urls = _scriptEnginesHash.keys();
395+ QReadLocker lock(&_scriptManagersHashLock);
396+ QList<QUrl> urls = _scriptManagersHash.keys();
395397 QStringList result;
396398 for (auto url : urls) {
397399 result.append(url.toString());
@@ -400,33 +402,33 @@ QStringList ScriptEngines::getRunningScripts() { · 2 unmodified lines
400402 }
401403
402404 void ScriptEngines::stopAllScripts(bool restart) {
403− QReadLocker lock(&_scriptEnginesHashLock);
405+ QReadLocker lock(&_scriptManagersHashLock);
404406
405407 if (_isReloading) {
406408 return;
407409 }
408410
409− for (QHash<QUrl, ScriptEnginePointer>::const_iterator it = _scriptEnginesHash.constBegin();
410− it != _scriptEnginesHash.constEnd(); it++) {
411− ScriptEnginePointer scriptEngine = it.value();
411+ for (QHash<QUrl, ScriptManagerPointer>::const_iterator it = _scriptManagersHash.constBegin();
412+ it != _scriptManagersHash.constEnd(); it++) {
413+ ScriptManagerPointer scriptManager = it.value();
412414 // skip already stopped scripts
413− if (scriptEngine->isFinished() || scriptEngine->isStopping()) {
415+ if (scriptManager->isFinished() || scriptManager->isStopping()) {
414416 continue;
415417 }
416418
417419 bool isOverrideScript = it.key().toString().compare(this->_defaultScriptsOverride.toString()) == 0;
418420 // queue user scripts if restarting
419− if (restart && (scriptEngine->isUserLoaded() || isOverrideScript)) {
421+ if (restart && (scriptManager->isUserLoaded() || isOverrideScript)) {
420422 _isReloading = true;
421− ScriptEngine::Type type = scriptEngine->getType();
423+ ScriptManager::Type type = scriptManager->getType();
422424
423− connect(scriptEngine.data(), &ScriptEngine::finished, this, [this, type, isOverrideScript] (QString scriptName) {
425+ connect(scriptManager.data(), &ScriptManager::finished, this, [this, type, isOverrideScript](QString scriptName) {
424426 reloadScript(scriptName, !isOverrideScript)->setType(type);
425427 });
426428 }
427429
428430 // stop all scripts
429− scriptEngine->stop();
431+ scriptManager->stop();
430432 }
431433
432434 if (restart) {
@@ -446,23 +448,23 @@ bool ScriptEngines::stopScript(const QString& rawScriptURL, bool restart) { · 13 unmodified lines
446448 scriptURL = normalizeScriptURL(QUrl::fromLocalFile(rawScriptURL));
447449 }
448450
449− QReadLocker lock(&_scriptEnginesHashLock);
450− if (_scriptEnginesHash.contains(scriptURL)) {
451− ScriptEnginePointer scriptEngine = _scriptEnginesHash.value(scriptURL);
451+ QReadLocker lock(&_scriptManagersHashLock);
452+ if (_scriptManagersHash.contains(scriptURL)) {
453+ ScriptManagerPointer scriptManager = _scriptManagersHash.value(scriptURL);
452454 if (restart) {
453− bool isUserLoaded = scriptEngine->isUserLoaded();
454− ScriptEngine::Type type = scriptEngine->getType();
455+ bool isUserLoaded = scriptManager->isUserLoaded();
456+ ScriptManager::Type type = scriptManager->getType();
455457 auto scriptCache = DependencyManager::get<ScriptCache>();
456458 scriptCache->deleteScript(scriptURL);
457459
458− if (!scriptEngine->isStopping()) {
459− connect(scriptEngine.data(), &ScriptEngine::finished,
460− this, [this, isUserLoaded, type](QString scriptName, ScriptEnginePointer engine) {
460+ if (!scriptManager->isStopping()) {
461+ connect(scriptManager.data(), &ScriptManager::finished,
462+ this, [this, isUserLoaded, type](QString scriptName, ScriptManagerPointer manager) {
461463 reloadScript(scriptName, isUserLoaded)->setType(type);
462464 });
463465 }
464466 }
465− scriptEngine->stop();
467+ scriptManager->stop();
466468 stoppedScript = true;
467469 }
468470 }
@@ -480,11 +482,11 @@ void ScriptEngines::reloadAllScripts() { · 11 unmodified lines
480482 stopAllScripts(true);
481483 }
482484
483−ScriptEnginePointer ScriptEngines::loadScript(const QUrl& scriptFilename, bool isUserLoaded, bool loadScriptFromEditor,
485+ScriptManagerPointer ScriptEngines::loadScript(const QUrl& scriptFilename, bool isUserLoaded, bool loadScriptFromEditor,
484486 bool activateMainWindow, bool reload, bool quitWhenFinished) {
485487 if (thread() != QThread::currentThread()) {
486− ScriptEnginePointer result { nullptr };
487− BLOCKING_INVOKE_METHOD(this, "loadScript", Q_RETURN_ARG(ScriptEnginePointer, result),
488+ ScriptManagerPointer result { nullptr };
489+ BLOCKING_INVOKE_METHOD(this, "loadScript", Q_RETURN_ARG(ScriptManagerPointer, result),
488490 Q_ARG(QUrl, scriptFilename),
489491 Q_ARG(bool, isUserLoaded),
490492 Q_ARG(bool, loadScriptFromEditor),
@@ -508,41 +510,41 @@ ScriptEnginePointer ScriptEngines::loadScript(const QUrl& scriptFilename, bool i · 17 unmodified lines
508510
509511 scriptUrl = QUrl(FileUtils::selectFile(scriptUrl.toString()));
510512
511− auto scriptEngine = getScriptEngine(scriptUrl);
512− if (scriptEngine && !scriptEngine->isStopping()) {
513− return scriptEngine;
513+ auto scriptManager = getScriptEngine(scriptUrl);
514+ if (scriptManager && !scriptManager->isStopping()) {
515+ return scriptManager;
514516 }
515517
516− scriptEngine = scriptEngineFactory(_context, NO_SCRIPT, "about:" + scriptFilename.fileName());
517− scriptEngine->setUserLoaded(isUserLoaded);
518− scriptEngine->setQuitWhenFinished(quitWhenFinished);
518+ scriptManager = scriptManagerFactory(_context, NO_SCRIPT, "about:" + scriptFilename.fileName());
519+ scriptManager->setUserLoaded(isUserLoaded);
520+ scriptManager->setQuitWhenFinished(quitWhenFinished);
519521
520522 if (scriptFilename.isEmpty() || !scriptUrl.isValid()) {
521− launchScriptEngine(scriptEngine);
523+ launchScriptEngine(scriptManager);
522524 } else {
523525 // connect to the appropriate signals of this script engine
524− connect(scriptEngine.data(), &ScriptEngine::scriptLoaded, this, &ScriptEngines::onScriptEngineLoaded);
525− connect(scriptEngine.data(), &ScriptEngine::errorLoadingScript, this, &ScriptEngines::onScriptEngineError);
526+ connect(scriptManager.data(), &ScriptManager::scriptLoaded, this, &ScriptEngines::onScriptEngineLoaded);
527+ connect(scriptManager.data(), &ScriptManager::errorLoadingScript, this, &ScriptEngines::onScriptEngineError);
526528
527529 // Shutdown Interface when script finishes, if requested
528530 if (quitWhenFinished) {
529− connect(scriptEngine.data(), &ScriptEngine::finished, this, &ScriptEngines::quitWhenFinished);
531+ connect(scriptManager.data(), &ScriptManager::finished, this, &ScriptEngines::quitWhenFinished);
530532 }
531533
532534 // get the script engine object to load the script at the designated script URL
533− scriptEngine->loadURL(scriptUrl, reload);
535+ scriptManager->loadURL(scriptUrl, reload);
534536 }
535537
536− return scriptEngine;
538+ return scriptManager;
537539 }
538540
539−ScriptEnginePointer ScriptEngines::getScriptEngine(const QUrl& rawScriptURL) {
540− ScriptEnginePointer result;
541+ScriptManagerPointer ScriptEngines::getScriptEngine(const QUrl& rawScriptURL) {
542+ ScriptManagerPointer result;
541543 {
542− QReadLocker lock(&_scriptEnginesHashLock);
544+ QReadLocker lock(&_scriptManagersHashLock);
543545 const QUrl scriptURL = normalizeScriptURL(rawScriptURL);
544− auto it = _scriptEnginesHash.find(scriptURL);
545− if (it != _scriptEnginesHash.end()) {
546+ auto it = _scriptManagersHash.find(scriptURL);
547+ if (it != _scriptManagersHash.end()) {
546548 result = it.value();
547549 }
548550 }
@@ -552,16 +554,15 @@ ScriptEnginePointer ScriptEngines::getScriptEngine(const QUrl& rawScriptURL) { · 3 unmodified lines
552554 // FIXME - change to new version of ScriptCache loading notification
553555 void ScriptEngines::onScriptEngineLoaded(const QString& rawScriptURL) {
554556 UserActivityLogger::getInstance().loadedScript(rawScriptURL);
555− QSharedPointer<BaseScriptEngine> baseScriptEngine = qobject_cast<ScriptEngine*>(sender())->sharedFromThis();
556− ScriptEnginePointer scriptEngine = qSharedPointerCast<ScriptEngine>(baseScriptEngine);
557+ ScriptManagerPointer scriptEngine = qobject_cast<ScriptManager*>(sender())->sharedFromThis();
557558
558559 launchScriptEngine(scriptEngine);
559560
560561 {
561− QWriteLocker lock(&_scriptEnginesHashLock);
562+ QWriteLocker lock(&_scriptManagersHashLock);
562563 QUrl url = QUrl(rawScriptURL);
563564 QUrl normalized = normalizeScriptURL(url);
564− _scriptEnginesHash.insert(normalized, scriptEngine);
565+ _scriptManagersHash.insert(normalized, scriptEngine);
565566 }
566567
567568 // Update settings with new script
@@ -573,40 +574,40 @@ void ScriptEngines::quitWhenFinished() { · 5 unmodified lines
573574 qApp->quit();
574575 }
575576
576−int ScriptEngines::runScriptInitializers(ScriptEnginePointer scriptEngine) {
577− auto nativeCount = DependencyManager::get<ScriptInitializers>()->runScriptInitializers(scriptEngine.data());
578− return nativeCount + ScriptInitializerMixin<ScriptEnginePointer>::runScriptInitializers(scriptEngine);
577+int ScriptEngines::runScriptInitializers(ScriptManagerPointer scriptManager) {
578+ auto nativeCount = DependencyManager::get<ScriptInitializers>()->runScriptInitializers(scriptManager->engine().data());
579+ return nativeCount + ScriptInitializerMixin<ScriptManagerPointer>::runScriptInitializers(scriptManager);
579580 }
580581
581−void ScriptEngines::launchScriptEngine(ScriptEnginePointer scriptEngine) {
582− connect(scriptEngine.data(), &ScriptEngine::finished, this, &ScriptEngines::onScriptFinished, Qt::DirectConnection);
583− connect(scriptEngine.data(), &ScriptEngine::loadScript, [this](const QString& scriptName, bool userLoaded) {
582+void ScriptEngines::launchScriptEngine(ScriptManagerPointer scriptManager) {
583+ connect(scriptManager.data(), &ScriptManager::finished, this, &ScriptEngines::onScriptFinished, Qt::DirectConnection);
584+ connect(scriptManager.data(), &ScriptManager::loadScript, [this](const QString& scriptName, bool userLoaded) {
584585 loadScript(scriptName, userLoaded);
585586 });
586− connect(scriptEngine.data(), &ScriptEngine::reloadScript, [this](const QString& scriptName, bool userLoaded) {
587+ connect(scriptManager.data(), &ScriptManager::reloadScript, [this](const QString& scriptName, bool userLoaded) {
587588 loadScript(scriptName, userLoaded, false, false, true);
588589 });
589590
590591 // register our application services and set it off on its own thread
591− runScriptInitializers(scriptEngine);
592− scriptEngine->runInThread();
592+ runScriptInitializers(scriptManager);
593+ scriptManager->runInThread();
593594 }
594595
595−void ScriptEngines::onScriptFinished(const QString& rawScriptURL, ScriptEnginePointer engine) {
596+void ScriptEngines::onScriptFinished(const QString& rawScriptURL, ScriptManagerPointer manager) {
596597 bool removed = false;
597598 {
598− QWriteLocker lock(&_scriptEnginesHashLock);
599+ QWriteLocker lock(&_scriptManagersHashLock);
599600 const QUrl scriptURL = normalizeScriptURL(QUrl(rawScriptURL));
600− for (auto it = _scriptEnginesHash.find(scriptURL); it != _scriptEnginesHash.end(); ++it) {
601− if (it.value() == engine) {
602− _scriptEnginesHash.erase(it);
601+ for (auto it = _scriptManagersHash.find(scriptURL); it != _scriptManagersHash.end(); ++it) {
602+ if (it.value() == manager) {
603+ _scriptManagersHash.erase(it);
603604 removed = true;
604605 break;
605606 }
606607 }
607608 }
608609
609− removeScriptEngine(engine);
610+ removeScriptEngine(manager);
610611
611612 if (removed && !_isReloading) {
612613 // Update settings with removed script

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t