Method createRuntime

valdi/src/valdi/runtime/RuntimeManager.cpp:172–250

    _debuggerService = nullptr;
}

SharedRuntime RuntimeManager::createRuntime(const Shared<IResourceLoader>& resourceLoader,
                                            double displayScale,
                                            const Ref<MainThreadManager>& mainThreadManagerOverride,
                                            std::optional<PlatformType> platformType) {
    auto runtime = Valdi::makeShared<Runtime>(_attributeIds,
                                              platformType ? platformType.value() : _platformType,
                                              mainThreadManagerOverride != nullptr ? mainThreadManagerOverride :
                                                                                     _mainThreadManager,
                                              _jsBridge,
                                              _workerQueue,
                                              _jsThreadQoS,
                                              _userSession,
                                              _keychain,
                                              resourceLoader,
                                              _assetLoaderManager,
                                              _requestManager,
                                              _colorPalette,
                                              _diskCache,
                                              _yogaConfig,
                                              _runtimeMessageHandler,
                                              _anrDetector,
                                              displayScale,
                                              _debuggerService != nullptr,
                                              _logger);

    std::vector<std::shared_ptr<::snap::valdi_core::ModuleFactory>> moduleFactories;
    std::vector<RegisteredTypeConverter> typeConverters;
    std::vector<Ref<IRuntimeManagerListener>> listeners;
    Ref<AttributionResolver> attributionResolver;
    Ref<Metrics> metrics;

    bool shouldInit = true;
    bool autoRenderDisabled;
    {
        std::lock_guard<Mutex> guard(_mutex);
        removeExpiredRuntimes();
        _runtimes.emplace_back(runtime);
        shouldInit = !_disableRuntimeAutoInit;
        moduleFactories = _registeredModuleFactories;
        typeConverters = _registeredTypeConverters;
        listeners = _listeners;
        attributionResolver = _attributionResolver;
        metrics = _metrics;
        autoRenderDisabled = _loadOperationsCount > 0;
        // Apply state that has a peer RuntimeManager::set*() iterating runtimes
        // while still holding _mutex. If we read into a local and applied after
        // releasing the lock, a concurrent setter could interleave: it would
        // see the just-added runtime in its snapshot and apply the new value
        // to it, and we would then overwrite with our stale local copy.
        //
        // Runtime::set*() below only takes the ResourceManager's mutex (a
        // different one), so there is no lock-inversion risk. This mirrors how
        // the peer setters (e.g. setMmapCacheDirectory, setTweakValueProvider)
        // already operate on runtimes they iterate.
        runtime->setMmapCacheDirectory(_mmapCacheDirectory);
        runtime->setRuntimeTweaks(_runtimeTweaks);
    }