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()));
}
