void SuspendableScriptExecutor::run() { ExecutionContext* context = getExecutionContext(); DCHECK(context); if (!context->activeDOMObjectsAreSuspended()) { suspendIfNeeded(); executeAndDestroySelf(); return; } startOneShot(0, BLINK_FROM_HERE); suspendIfNeeded(); }
FontFace::FontFace(ExecutionContext* context) : ActiveScriptWrappable(this) , ActiveDOMObject(context) , m_status(Unloaded) { suspendIfNeeded(); }
ExceptionOr<Ref<Worker>> Worker::create(ScriptExecutionContext& context, const String& url, JSC::RuntimeFlags runtimeFlags) { ASSERT(isMainThread()); // We don't currently support nested workers, so workers can only be created from documents. ASSERT_WITH_SECURITY_IMPLICATION(context.isDocument()); auto worker = adoptRef(*new Worker(context, runtimeFlags)); worker->suspendIfNeeded(); bool shouldBypassMainWorldContentSecurityPolicy = context.shouldBypassMainWorldContentSecurityPolicy(); auto scriptURL = worker->resolveURL(url, shouldBypassMainWorldContentSecurityPolicy); if (scriptURL.hasException()) return scriptURL.releaseException(); worker->m_shouldBypassMainWorldContentSecurityPolicy = shouldBypassMainWorldContentSecurityPolicy; // The worker context does not exist while loading, so we must ensure that the worker object is not collected, nor are its event listeners. worker->setPendingActivity(worker.ptr()); worker->m_scriptLoader = WorkerScriptLoader::create(); auto contentSecurityPolicyEnforcement = shouldBypassMainWorldContentSecurityPolicy ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceChildSrcDirective; worker->m_scriptLoader->loadAsynchronously(&context, scriptURL.releaseReturnValue(), FetchOptions::Mode::SameOrigin, contentSecurityPolicyEnforcement, worker->m_identifier, worker.ptr()); return WTFMove(worker); }
IDBTransaction::IDBTransaction(IDBDatabase& database, const IDBTransactionInfo& info) : WebCore::IDBTransaction(database.scriptExecutionContext()) , m_database(database) , m_info(info) , m_operationTimer(*this, &IDBTransaction::operationTimerFired) { relaxAdoptionRequirement(); if (m_info.mode() == IndexedDB::TransactionMode::VersionChange) { m_originalDatabaseInfo = std::make_unique<IDBDatabaseInfo>(m_database->info()); m_startedOnServer = true; } else { activate(); RefPtr<IDBTransaction> self; JSC::VM& vm = JSDOMWindowBase::commonVM(); vm.whenIdle([self, this]() { deactivate(); }); establishOnServer(); } suspendIfNeeded(); }
LoaderClient(ExecutionContext* executionContext, BodyStreamBuffer* buffer, FetchDataLoader::Client* client) : ActiveDOMObject(executionContext) , m_buffer(buffer) , m_client(client) { suspendIfNeeded(); }
IDBOpenDBRequest::IDBOpenDBRequest(IDBConnectionToServer& connection, ScriptExecutionContext* context, const IDBDatabaseIdentifier& databaseIdentifier, uint64_t version) : IDBRequest(connection, context) , m_databaseIdentifier(databaseIdentifier) , m_version(version) { suspendIfNeeded(); }
IDBRequest::IDBRequest(IDBConnectionToServer& connection, ScriptExecutionContext* context) : IDBOpenDBRequest(context) , m_connection(connection) , m_resourceIdentifier(connection) { suspendIfNeeded(); }
IDBTransaction::IDBTransaction(IDBDatabase& database, const IDBTransactionInfo& info, IDBOpenDBRequest* request) : WebCore::IDBTransaction(database.scriptExecutionContext()) , m_database(database) , m_info(info) , m_operationTimer(*this, &IDBTransaction::operationTimerFired) , m_openDBRequest(request) { LOG(IndexedDB, "IDBTransaction::IDBTransaction - %s", m_info.loggingString().utf8().data()); relaxAdoptionRequirement(); if (m_info.mode() == IndexedDB::TransactionMode::VersionChange) { ASSERT(m_openDBRequest); m_openDBRequest->setVersionChangeTransaction(*this); m_startedOnServer = true; } else { activate(); RefPtr<IDBTransaction> self; JSC::VM& vm = JSDOMWindowBase::commonVM(); vm.whenIdle([self, this]() { deactivate(); }); establishOnServer(); } suspendIfNeeded(); }
RefPtr<EventSource> EventSource::create(ScriptExecutionContext& context, const String& url, const Init& eventSourceInit, ExceptionCode& ec) { if (url.isEmpty()) { ec = SYNTAX_ERR; return nullptr; } URL fullURL = context.completeURL(url); if (!fullURL.isValid()) { ec = SYNTAX_ERR; return nullptr; } // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved. if (!context.contentSecurityPolicy()->allowConnectToSource(fullURL, context.shouldBypassMainWorldContentSecurityPolicy())) { // FIXME: Should this be throwing an exception? ec = SECURITY_ERR; return nullptr; } auto source = adoptRef(*new EventSource(context, fullURL, eventSourceInit)); source->setPendingActivity(source.ptr()); source->scheduleInitialConnect(); source->suspendIfNeeded(); return WTFMove(source); }
IDBIndex::IDBIndex(ScriptExecutionContext& context, const IDBIndexInfo& info, IDBObjectStore& objectStore) : ActiveDOMObject(&context) , m_info(info) , m_objectStore(objectStore) { suspendIfNeeded(); }
FontFaceSet::FontFaceSet(Document& document) : ActiveDOMObject(&document) , m_shouldFireLoadingEvent(false) , m_asyncRunner(this, &FontFaceSet::handlePendingEventsAndPromises) { suspendIfNeeded(); }
void SuspendableScriptExecutor::run() { suspendIfNeeded(); ExecutionContext* context = executionContext(); ASSERT(context); if (context && !context->activeDOMObjectsAreSuspended()) executeAndDestroySelf(); }
ScriptedIdleTaskController::ScriptedIdleTaskController(ExecutionContext* context) : ActiveDOMObject(context) , m_scheduler(Platform::current()->currentThread()->scheduler()) , m_nextCallbackId(0) , m_suspended(false) { suspendIfNeeded(); }
ReadableStream::ReadableStream(ScriptExecutionContext& scriptExecutionContext) : ActiveDOMObject(&scriptExecutionContext) { #ifndef NDEBUG readableStreamCounter.increment(); #endif suspendIfNeeded(); }
IDBRequest::IDBRequest(ScriptExecutionContext& context, IDBObjectStore& objectStore, IDBTransaction& transaction) : IDBOpenDBRequest(&context) , m_transaction(&transaction) , m_connection(transaction.serverConnection()) , m_resourceIdentifier(transaction.serverConnection()) , m_source(IDBAny::create(objectStore)) { suspendIfNeeded(); }
IDBDatabase::IDBDatabase(ScriptExecutionContext& context, IDBConnectionToServer& connection, const IDBResultData& resultData) : WebCore::IDBDatabase(&context) , m_connection(connection) , m_info(resultData.databaseInfo()) { suspendIfNeeded(); relaxAdoptionRequirement(); m_connection->registerDatabaseConnection(*this); }
FontLoader::FontLoader(Document* document) : ActiveDOMObject(document) , m_document(document) , m_numLoadingFromCSS(0) , m_numLoadingFromJS(0) , m_pendingEventsTimer(*this, &FontLoader::pendingEventsTimerFired) { suspendIfNeeded(); }
CanvasCaptureMediaStreamTrack::CanvasCaptureMediaStreamTrack( const CanvasCaptureMediaStreamTrack& track, MediaStreamComponent* component) : MediaStreamTrack(track.m_canvasElement->getExecutionContext(), component), m_canvasElement(track.m_canvasElement), m_drawListener(track.m_drawListener) { suspendIfNeeded(); m_canvasElement->addListener(m_drawListener.get()); }
FontFaceSet::FontFaceSet(Document& document) : ActiveDOMObject(&document) , m_shouldFireLoadingEvent(false) , m_isLoading(false) , m_ready(new ReadyProperty(executionContext(), this, ReadyProperty::Ready)) , m_asyncRunner(this, &FontFaceSet::handlePendingEventsAndPromises) { suspendIfNeeded(); }
CanvasCaptureMediaStreamTrack::CanvasCaptureMediaStreamTrack( MediaStreamComponent* component, HTMLCanvasElement* element, std::unique_ptr<WebCanvasCaptureHandler> handler) : MediaStreamTrack(element->getExecutionContext(), component), m_canvasElement(element) { suspendIfNeeded(); m_drawListener = AutoCanvasDrawListener::create(std::move(handler)); m_canvasElement->addListener(m_drawListener.get()); }
IDBObjectStore::IDBObjectStore(ScriptExecutionContext& context, const IDBObjectStoreInfo& info, IDBTransaction& transaction) : ActiveDOMObject(&context) , m_info(info) , m_originalInfo(info) , m_transaction(transaction) { ASSERT(currentThread() == m_transaction->database().originThreadID()); suspendIfNeeded(); }
IDBDatabase::IDBDatabase(ScriptExecutionContext& context, IDBClient::IDBConnectionProxy& connectionProxy, const IDBResultData& resultData) : IDBActiveDOMObject(&context) , m_connectionProxy(connectionProxy) , m_info(resultData.databaseInfo()) , m_databaseConnectionIdentifier(resultData.databaseConnectionIdentifier()) { LOG(IndexedDB, "IDBDatabase::IDBDatabase - Creating database %s with version %" PRIu64 " connection %" PRIu64 " (%p)", m_info.name().utf8().data(), m_info.version(), m_databaseConnectionIdentifier, this); suspendIfNeeded(); m_connectionProxy->registerDatabaseConnection(*this); }
IDBIndex::IDBIndex(ScriptExecutionContext& context, const IDBIndexInfo& info, IDBObjectStore& objectStore) : ActiveDOMObject(&context) , m_info(info) , m_originalInfo(info) , m_objectStore(objectStore) { ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID()); suspendIfNeeded(); }
MediaStreamTrack::MediaStreamTrack(MediaStreamTrack* other) : ActiveDOMObject(other->scriptExecutionContext()) , m_privateTrack(*other->privateTrack().clone()) , m_eventDispatchScheduled(false) , m_stoppingTrack(false) { suspendIfNeeded(); m_privateTrack->setClient(this); }
ReadableStream::ReadableStream(ScriptExecutionContext& scriptExecutionContext, Ref<ReadableStreamSource>&& source) : ActiveDOMObject(&scriptExecutionContext) , m_state(State::Readable) , m_source(WTF::move(source)) { #ifndef NDEBUG readableStreamCounter.increment(); #endif suspendIfNeeded(); }
IDBDatabase::IDBDatabase(ScriptExecutionContext& context, IDBConnectionToServer& connection, const IDBResultData& resultData) : WebCore::IDBDatabase(&context) , m_serverConnection(connection) , m_info(resultData.databaseInfo()) , m_databaseConnectionIdentifier(resultData.databaseConnectionIdentifier()) { LOG(IndexedDB, "IDBDatabase::IDBDatabase - Creating database %s with version %" PRIu64, m_info.name().utf8().data(), m_info.version()); suspendIfNeeded(); relaxAdoptionRequirement(); m_serverConnection->registerDatabaseConnection(*this); }
ReadableStreamReader::ReadableStreamReader(ReadableStream& stream) : ActiveDOMObject(stream.scriptExecutionContext()) { #ifndef NDEBUG readableStreamReaderCounter.increment(); #endif suspendIfNeeded(); ASSERT_WITH_MESSAGE(!stream.reader(), "A ReadableStream cannot be locked by two readers at the same time."); m_stream = &stream; stream.lock(*this); }
ExceptionOr<Ref<OfflineAudioContext>> OfflineAudioContext::create(ScriptExecutionContext& context, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate) { // FIXME: Add support for workers. if (!is<Document>(context)) return Exception { NOT_SUPPORTED_ERR }; if (!numberOfChannels || numberOfChannels > 10 || !numberOfFrames || !isSampleRateRangeGood(sampleRate)) return Exception { SYNTAX_ERR }; auto audioContext = adoptRef(*new OfflineAudioContext(downcast<Document>(context), numberOfChannels, numberOfFrames, sampleRate)); audioContext->suspendIfNeeded(); return WTFMove(audioContext); }
MediaStreamTrack::MediaStreamTrack(ScriptExecutionContext& context, MediaStreamTrackPrivate& privateTrack) : RefCounted() , ActiveDOMObject(&context) , m_privateTrack(privateTrack) , m_eventDispatchScheduled(false) , m_stoppingTrack(false) { suspendIfNeeded(); m_privateTrack->setClient(this); }
ReadableStream::ReadableStream(ExecutionContext* executionContext, UnderlyingSource* source) : ActiveDOMObject(executionContext) , m_source(source) , m_isStarted(false) , m_isDraining(false) , m_isPulling(false) , m_state(Waiting) , m_ready(new WaitPromise(executionContext, this, WaitPromise::Ready)) , m_closed(new ClosedPromise(executionContext, this, ClosedPromise::Closed)) { suspendIfNeeded(); }