void CurlDownload::didReceiveData(void* data, int size) { MutexLocker locker(m_mutex); callOnMainThread(MainThreadTask(receivedDataCallback, this, size)); writeDataToFile(static_cast<const char*>(data), size); }
void CALLBACK NetworkStateNotifier::addrChangeCallback(void* context, BOOLEAN timedOut) { // NotifyAddrChange only notifies us of a single address change. Now that we've been notified, // we need to call it again so we'll get notified the *next* time. static_cast<NetworkStateNotifier*>(context)->registerForAddressChange(); callOnMainThread(callAddressChanged, context); }
void SetIndexesReadyOperation::perform(std::function<void()> completionCallback) { LOG(StorageAPI, "SetIndexesReadyOperation"); for (size_t i = 0; i < m_indexCount; ++i) m_transaction->didCompletePreemptiveEvent(); callOnMainThread(completionCallback); }
void UserMediaRequest::constraintsValidated() { RefPtr<UserMediaRequest> protectedThis(this); callOnMainThread([protectedThis] { // 2 - The constraints are valid, ask the user for access to media. if (UserMediaController* controller = protectedThis->m_controller) controller->requestPermission(*protectedThis.get()); }); }
void WebCLEvent::callbackProxy(cl_event event, cl_int type, void* userData) { if (!isMainThread()) { callOnMainThread(WTF::bind(callbackProxyOnMainThread, event, type, userData)); return; } callbackProxyOnMainThread(event, type, userData); }
void StorageTracker::syncImportOriginIdentifiers() { ASSERT(m_isActive); ASSERT(!isMainThread()); { MutexLocker locker(m_databaseMutex); // Don't force creation of StorageTracker's db just because a tracker // was initialized. It will be created if local storage dbs are found // by syncFileSystemAndTrackerDatabse() or the next time a local storage // db is created by StorageAreaSync. openTrackerDatabase(false); if (m_database.isOpen()) { SQLiteTransactionInProgressAutoCounter transactionCounter; SQLiteStatement statement(m_database, "SELECT origin FROM Origins"); if (statement.prepare() != SQLResultOk) { LOG_ERROR("Failed to prepare statement."); return; } int result; { MutexLocker lockOrigins(m_originSetMutex); while ((result = statement.step()) == SQLResultRow) m_originSet.add(statement.getColumnText(0).isolatedCopy()); } if (result != SQLResultDone) { LOG_ERROR("Failed to read in all origins from the database."); return; } } } syncFileSystemAndTrackerDatabase(); { MutexLocker locker(m_clientMutex); if (m_client) { MutexLocker locker(m_originSetMutex); OriginSet::const_iterator end = m_originSet.end(); for (OriginSet::const_iterator it = m_originSet.begin(); it != end; ++it) m_client->dispatchDidModifyOrigin(*it); } } callOnMainThread([this] { finishedImportingOriginIdentifiers(); }); }
void AudioContext::stop() { m_document = 0; // document is going away // Don't call uninitialize() immediately here because the ScriptExecutionContext is in the middle // of dealing with all of its ActiveDOMObjects at this point. uninitialize() can de-reference other // ActiveDOMObjects so let's schedule uninitialize() to be called later. // FIXME: see if there's a more direct way to handle this issue. callOnMainThread(uninitializeDispatch, this); }
void IDBServerConnectionLevelDB::commitTransaction(int64_t transactionID, BoolCallbackFunction successCallback) { RefPtr<IDBBackingStoreTransactionLevelDB> transaction = m_backingStoreTransactions.get(transactionID); ASSERT(transaction); bool result = transaction->commit(); callOnMainThread([successCallback, result]() { successCallback(result); }); }
void ThreadedCompositor::didChangeVisibleRect() { FloatRect visibleRect = viewportController()->visibleContentsRect(); float scale = viewportController()->pageScaleFactor(); callOnMainThread([=] { m_client->setVisibleContentsRect(visibleRect, FloatPoint::zero(), scale); }); scheduleDisplayImmediately(); }
void ScrollingTreeIOS::currentSnapPointIndicesDidChange(WebCore::ScrollingNodeID nodeID, unsigned horizontal, unsigned vertical) { if (!m_scrollingCoordinator) return; RefPtr<AsyncScrollingCoordinator> scrollingCoordinator = m_scrollingCoordinator; callOnMainThread([scrollingCoordinator, nodeID, horizontal, vertical] { scrollingCoordinator->setActiveScrollSnapIndices(nodeID, horizontal, vertical); }); }
void ScrollingTreeIOS::scrollingTreeNodeDidScroll(ScrollingNodeID nodeID, const FloatPoint& scrollPosition, SetOrSyncScrollingLayerPosition scrollingLayerPositionAction) { if (!m_scrollingCoordinator) return; if (nodeID == rootNode()->scrollingNodeID()) setMainFrameScrollPosition(scrollPosition); callOnMainThread(bind(&AsyncScrollingCoordinator::scheduleUpdateScrollPositionAfterAsyncScroll, m_scrollingCoordinator.get(), nodeID, scrollPosition, isHandlingProgrammaticScroll(), scrollingLayerPositionAction)); }
static void formFinalize(CFReadStreamRef stream, void* context) { FormStreamFields* form = static_cast<FormStreamFields*>(context); ASSERT_UNUSED(stream, form->formStream == stream); callOnMainThread([form] { closeCurrentStream(form); delete form; }); }
void ResourceHandle::internetStatusCallback(HINTERNET internetHandle, DWORD_PTR context, DWORD internetStatus, LPVOID statusInformation, DWORD statusInformationLength) { ResourceHandle* handle = reinterpret_cast<ResourceHandle*>(context); switch (internetStatus) { case INTERNET_STATUS_REDIRECT: handle->d->m_redirectUrl = String(static_cast<UChar*>(statusInformation), statusInformationLength); callOnMainThread(callOnRedirect, handle); break; case INTERNET_STATUS_REQUEST_COMPLETE: callOnMainThread(callOnRequestComplete, handle); break; default: break; } }
void ThreadableBlobRegistry::registerFileBlobURL(const URL& url, const String& path, const String& contentType) { if (isMainThread()) blobRegistry().registerFileBlobURL(url, BlobDataFileReference::create(path), contentType); else { callOnMainThread([url = url.isolatedCopy(), path = path.isolatedCopy(), contentType = contentType.isolatedCopy()] { blobRegistry().registerFileBlobURL(url, BlobDataFileReference::create(path), contentType); }); } }
void CurlDownload::didReceiveData(void* data, int size) { MutexLocker locker(m_mutex); callOnMainThread([this, size] { didReceiveDataOfLength(size); }); writeDataToFile(static_cast<const char*>(data), size); }
void AudioContext::isPlayingAudioDidChange() { // Make sure to call Document::updateIsPlayingMedia() on the main thread, since // we could be on the audio I/O thread here and the call into WebCore could block. RefPtr<AudioContext> strongThis(this); callOnMainThread([strongThis] { if (strongThis->document()) strongThis->document()->updateIsPlayingMedia(); }); }
void ThreadableBlobRegistry::registerBlobURLForSlice(const URL& newURL, const URL& srcURL, long long start, long long end) { if (isMainThread()) blobRegistry().registerBlobURLForSlice(newURL, srcURL, start, end); else { callOnMainThread([newURL = newURL.isolatedCopy(), srcURL = srcURL.isolatedCopy(), start, end] { blobRegistry().registerBlobURLForSlice(newURL, srcURL, start, end); }); } }
void UserMediaRequest::userMediaAccessGranted(const String& videoDeviceUID, const String& audioDeviceUID) { m_chosenVideoDeviceUID = videoDeviceUID; m_chosenAudioDeviceUID = audioDeviceUID; RefPtr<UserMediaRequest> protectedThis(this); callOnMainThread([protectedThis] { // 3 - the user granted access, ask platform to create the media stream descriptors. RealtimeMediaSourceCenter::singleton().createMediaStream(protectedThis.get(), protectedThis->m_audioConstraints, protectedThis->m_videoConstraints); }); }
void NetworkResourceLoadScheduler::scheduleRemoveLoader(NetworkResourceLoader* loader) { MutexLocker locker(m_loadersToRemoveMutex); m_loadersToRemove.append(loader); if (!removeScheduledLoadersCalled) { removeScheduledLoadersCalled = true; callOnMainThread(NetworkResourceLoadScheduler::removeScheduledLoaders, this); } }
void MediaStreamPrivate::scheduleDeferredTask(std::function<void()> function) { ASSERT(function); auto weakThis = createWeakPtr(); callOnMainThread([weakThis, function] { if (!weakThis) return; function(); }); }
void UserMediaRequest::failedToCreateStreamWithPermissionError() { if (!m_scriptExecutionContext) return; if (!m_errorCallback) return; RefPtr<NavigatorUserMediaError> error = NavigatorUserMediaError::create(NavigatorUserMediaError::permissionDeniedErrorName(), emptyString()); callOnMainThread(bind(&UserMediaRequest::callErrorHandler, this, error.release())); }
void DatabaseTracker::scheduleForNotification() { ASSERT(!notificationMutex().tryLock()); if (!notificationScheduled) { callOnMainThread([] { notifyDatabasesChanged(); }); notificationScheduled = true; } }
void IDBConnectionProxy::scheduleMainThreadTasks() { Locker<Lock> locker(m_mainThreadTaskLock); if (m_mainThreadProtector) return; m_mainThreadProtector = &m_connectionToServer; callOnMainThread([this] { handleMainThreadTasks(); }); }
void BlobResourceHandle::notifyFinish() { if (m_async) { // Schedule to notify the client from a standalone function because the client might dispose the handle immediately from the callback function // while we still have BlobResourceHandle calls in the stack. callOnMainThread(doNotifyFinish, this); return; } doNotifyFinish(this); }
void ScrollingTree::updateMainFrameScrollPositionAndScrollLayerPosition(const IntPoint& scrollPosition) { if (!m_scrollingCoordinator) return; { MutexLocker lock(m_mutex); m_mainFrameScrollPosition = scrollPosition; } callOnMainThread(bind(&ScrollingCoordinator::updateMainFrameScrollPositionAndScrollLayerPosition, m_scrollingCoordinator.get())); }
void ScrollingTree::invalidate() { // Invalidate is dispatched by the ScrollingCoordinator class on the ScrollingThread // to break the reference cycle between ScrollingTree and ScrollingCoordinator when the // ScrollingCoordinator's page is destroyed. ASSERT(ScrollingThread::isCurrentThread()); // Since this can potentially be the last reference to the scrolling coordinator, // we need to release it on the main thread since it has member variables (such as timers) // that expect to be destroyed from the main thread. callOnMainThread(bind(derefScrollingCoordinator, m_scrollingCoordinator.release().leakRef())); }
void TraceEventDispatcher::enqueueEvent(const TraceEvent& event) { const float eventProcessingThresholdInSeconds = 0.1; { MutexLocker locker(m_mutex); m_backgroundEvents.append(event); if (m_processEventsTaskInFlight || event.timestamp() - m_lastEventProcessingTime <= eventProcessingThresholdInSeconds) return; } m_processEventsTaskInFlight = true; callOnMainThread(bind(&TraceEventDispatcher::processBackgroundEventsTask, this)); }
void AsyncAudioDecoder::DecodingTask::decode() { ASSERT(m_audioData.get()); if (!m_audioData.get()) return; // Do the actual decoding and invoke the callback. m_audioBuffer = AudioBuffer::createFromAudioFileData(m_audioData->data(), m_audioData->byteLength(), false, sampleRate()); // Decoding is finished, but we need to do the callbacks on the main thread. callOnMainThread(notifyCompleteDispatch, this); }
void CurlDownload::didReceiveData(void* data, int size) { LockHolder locker(m_mutex); RefPtr<CurlDownload> protectedThis(this); callOnMainThread([this, size, protectedThis] { didReceiveDataOfLength(size); }); writeDataToFile(static_cast<const char*>(data), size); }
void UserMediaRequest::failedToCreateStreamWithConstraintsError(const String& constraintName) { ASSERT(!constraintName.isEmpty()); if (!m_scriptExecutionContext) return; if (!m_errorCallback) return; RefPtr<NavigatorUserMediaError> error = NavigatorUserMediaError::create(NavigatorUserMediaError::constraintNotSatisfiedErrorName(), constraintName); callOnMainThread(bind(&UserMediaRequest::callErrorHandler, this, error.release())); }