bool
Thread::interrupted()
{
ThreadHandle handle = currentThread();
if(!handle.is_null()) {
return handle->consumeInterruptionSync();
} else {
return false;
}
};
void AddThr::run()
{
Functions::DemuxersInfo demuxersInfo;
for (Module *module : QMPlay2Core.getPluginsInstance())
for (const Module::Info &mod : module->getModulesInfo())
if (mod.type == Module::DEMUXER)
demuxersInfo += {mod.name, mod.icon.isNull() ? module->icon() : mod.icon, mod.extensions};
add(urls, par, demuxersInfo, existingEntries.isEmpty() ? nullptr : &existingEntries, loadList);
if (currentThread() == pLW.thread()) //jeżeli funkcja działa w głównym wątku
finished();
}
void SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown()
{
ASSERT(currentThread() == database()->databaseContext()->databaseThread()->getThreadID());
// If the transaction is in progress, we should roll it back here, since this
// is our last opportunity to do something related to this transaction on the
// DB thread. Amongst other work, doCleanup() will clear m_sqliteTransaction
// which invokes SQLiteTransaction's destructor, which will do the roll back
// if necessary.
doCleanup();
}
void initializeThreading()
{
if (!atomicallyInitializedStaticMutex) {
atomicallyInitializedStaticMutex = new Mutex;
threadMapMutex();
wtf_random_init();
initializeMainThread();
mainThreadIdentifier = currentThread();
setThreadName(mainThreadIdentifier, "Main Thread");
}
}
RefPtr<DOMStringList> IDBObjectStore::indexNames() const
{
ASSERT(currentThread() == m_transaction->database().originThreadID());
RefPtr<DOMStringList> indexNames = DOMStringList::create();
for (auto& name : m_info.indexNames())
indexNames->append(name);
indexNames->sort();
return indexNames;
}
void TimerBase::start(double nextFireInterval,
double repeatInterval,
const WebTraceLocation& caller) {
#if DCHECK_IS_ON()
DCHECK_EQ(m_thread, currentThread());
#endif
m_location = caller;
m_repeatInterval = repeatInterval;
setNextFireTime(timerMonotonicallyIncreasingTime(), nextFireInterval);
}
bool OfflineAudioDestinationHandler::renderIfNotSuspended(AudioBus* sourceBus, AudioBus* destinationBus, size_t numberOfFrames)
{
// We don't want denormals slowing down any of the audio processing
// since they can very seriously hurt performance.
// This will take care of all AudioNodes because they all process within this scope.
DenormalDisabler denormalDisabler;
context()->deferredTaskHandler().setAudioThread(currentThread());
if (!context()->isDestinationInitialized()) {
destinationBus->zero();
return false;
}
// Take care pre-render tasks at the beginning of each render quantum. Then
// it will stop the rendering loop if the context needs to be suspended
// at the beginning of the next render quantum.
if (context()->handlePreOfflineRenderTasks()) {
suspendOfflineRendering();
return true;
}
// Prepare the local audio input provider for this render quantum.
if (sourceBus)
m_localAudioInputProvider.set(sourceBus);
ASSERT(numberOfInputs() >= 1);
if (numberOfInputs() < 1) {
destinationBus->zero();
return false;
}
// This will cause the node(s) connected to us to process, which in turn will pull on their input(s),
// all the way backwards through the rendering graph.
AudioBus* renderedBus = input(0).pull(destinationBus, numberOfFrames);
if (!renderedBus) {
destinationBus->zero();
} else if (renderedBus != destinationBus) {
// in-place processing was not possible - so copy
destinationBus->copyFrom(*renderedBus);
}
// Process nodes which need a little extra help because they are not connected to anything, but still need to process.
context()->deferredTaskHandler().processAutomaticPullNodes(numberOfFrames);
// Let the context take care of any business at the end of each render quantum.
context()->handlePostOfflineRenderTasks();
// Advance current sample-frame.
size_t newSampleFrame = m_currentSampleFrame + numberOfFrames;
releaseStore(&m_currentSampleFrame, newSampleFrame);
return false;
}
TimerBase::TimerBase()
: m_nextFireTime(0)
, m_unalignedNextFireTime(0)
, m_repeatInterval(0)
, m_heapIndex(-1)
, m_cachedThreadGlobalTimerHeap(0)
#if ENABLE(ASSERT)
, m_thread(currentThread())
#endif
{
}
void IDBOpenDBRequest::onSuccess(const IDBResultData& resultData)
{
LOG(IndexedDB, "IDBOpenDBRequest::onSuccess()");
ASSERT(currentThread() == originThreadID());
setResult(IDBDatabase::create(*scriptExecutionContext(), connectionProxy(), resultData));
m_isDone = true;
enqueueEvent(IDBRequestCompletionEvent::create(eventNames().successEvent, false, false, *this));
}
bool IDBOpenDBRequest::dispatchEvent(Event& event)
{
ASSERT(currentThread() == originThreadID());
bool result = IDBRequest::dispatchEvent(event);
if (m_transaction && m_transaction->isVersionChange() && (event.type() == eventNames().errorEvent || event.type() == eventNames().successEvent))
m_transaction->database().connectionProxy().didFinishHandlingVersionChangeTransaction(m_transaction->database().databaseConnectionIdentifier(), *m_transaction);
return result;
}
void TimerBase::stop()
{
ASSERT(m_thread == currentThread());
m_repeatInterval = 0;
setNextFireTime(0);
ASSERT(m_nextFireTime == 0);
ASSERT(m_repeatInterval == 0);
ASSERT(!inHeap());
}
ThreadState::ThreadState(intptr_t* startOfStack)
: m_thread(currentThread())
, m_startOfStack(startOfStack)
{
ASSERT(!**s_threadSpecific);
**s_threadSpecific = this;
// FIXME: This is to silence clang that complains about unused private
// member. Remove once we implement stack scanning that uses it.
(void) m_startOfStack;
}
void IDBDatabase::didCommitTransaction(IDBTransaction& transaction)
{
LOG(IndexedDB, "IDBDatabase::didCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data());
ASSERT(currentThread() == originThreadID());
if (m_versionChangeTransaction == &transaction)
m_info.setVersion(transaction.info().newVersion());
didCommitOrAbortTransaction(transaction);
}
WorkerMessagingProxy::WorkerMessagingProxy(Worker* workerObject)
: m_scriptExecutionContext(workerObject->scriptExecutionContext())
, m_workerObject(workerObject)
, m_unconfirmedMessageCount(0)
, m_workerThreadHadPendingActivity(false)
, m_askedToTerminate(false)
{
ASSERT(m_workerObject);
ASSERT((m_scriptExecutionContext->isDocument() && isMainThread())
|| (m_scriptExecutionContext->isWorkerContext() && currentThread() == static_cast<WorkerContext*>(m_scriptExecutionContext.get())->thread()->threadID()));
}
void IDBDatabase::renameIndex(IDBIndex& index, const String& newName)
{
ASSERT(currentThread() == originThreadID());
ASSERT(m_versionChangeTransaction);
ASSERT(m_info.hasObjectStore(index.objectStore().info().name()));
ASSERT(m_info.infoForExistingObjectStore(index.objectStore().info().name())->hasIndex(index.info().name()));
m_info.infoForExistingObjectStore(index.objectStore().info().name())->infoForExistingIndex(index.info().identifier())->rename(newName);
m_versionChangeTransaction->renameIndex(index, newName);
}
void TimerBase::stop()
{
ASSERT(m_thread == currentThread() || (isMainThread() || pthread_main_np()) && WebCoreWebThreadIsLockedOrDisabled());
m_repeatInterval = 0;
setNextFireTime(0);
ASSERT(m_nextFireTime == 0);
ASSERT(m_repeatInterval == 0);
ASSERT(!inHeap());
}
TimerBase::TimerBase()
: m_nextFireTime(0)
, m_unalignedNextFireTime(0)
, m_repeatInterval(0)
, m_heapIndex(-1)
, m_cachedThreadGlobalTimerHeap(0)
#ifndef NDEBUG
, m_thread(currentThread())
, m_wasDeleted(false)
#endif
{
}
bool IDBDatabase::hasPendingActivity() const
{
ASSERT(currentThread() == originThreadID() || mayBeGCThread());
if (m_closedInServer)
return false;
if (!m_activeTransactions.isEmpty() || !m_committingTransactions.isEmpty() || !m_abortingTransactions.isEmpty())
return true;
return hasEventListeners(m_eventNames.abortEvent) || hasEventListeners(m_eventNames.errorEvent) || hasEventListeners(m_eventNames.versionchangeEvent);
}
bool IDBDatabase::dispatchEvent(Event& event)
{
LOG(IndexedDB, "IDBDatabase::dispatchEvent (%" PRIu64 ") (%p)", m_databaseConnectionIdentifier, this);
ASSERT(currentThread() == originThreadID());
bool result = EventTargetWithInlineData::dispatchEvent(event);
if (event.isVersionChangeEvent() && event.type() == m_eventNames.versionchangeEvent)
connectionProxy().didFireVersionChangeEvent(m_databaseConnectionIdentifier, downcast<IDBVersionChangeEvent>(event).requestIdentifier());
return result;
}
void endParallel()
{
__sync_fetch_and_add(&gActiveThreadCount, -1);
while (gActiveThreadCount > 0)
;
if (currentThread() == 0)
{
// Stop all but me
*((unsigned int*) 0xffff0064) = ~1;
}
}
void IDBDatabase::didStartTransaction(IDBTransaction& transaction)
{
LOG(IndexedDB, "IDBDatabase::didStartTransaction %s", transaction.info().identifier().loggingString().utf8().data());
ASSERT(!m_versionChangeTransaction);
ASSERT(currentThread() == originThreadID());
// It is possible for the client to have aborted a transaction before the server replies back that it has started.
if (m_abortingTransactions.contains(transaction.info().identifier()))
return;
m_activeTransactions.set(transaction.info().identifier(), &transaction);
}
void initializeMainThread(void (*function)(MainThreadFunction, void*))
{
static bool initializedMainThread;
if (initializedMainThread)
return;
initializedMainThread = true;
callOnMainThreadFunction = function;
mainThreadIdentifier = currentThread();
AtomicString::init();
}
void initializeThreading()
{
if (!atomicallyInitializedStaticMutex) {
atomicallyInitializedStaticMutex = new Mutex;
threadMapMutex();
initializeRandomNumberGenerator();
#if !PLATFORM(DARWIN) || PLATFORM(CHROMIUM)
mainThreadIdentifier = currentThread();
#endif
initializeMainThread();
}
}
void initializeMainThread()
{
static bool initializedMainThread;
if (initializedMainThread)
return;
initializedMainThread = true;
mainThreadIdentifier = currentThread();
initializeMainThreadPlatform();
initializeGCThreads();
}
NEVER_INLINE void LockBase::lockSlow()
{
unsigned spinCount = 0;
// This magic number turns out to be optimal based on past JikesRVM experiments.
const unsigned spinLimit = 40;
for (;;) {
uint8_t currentByteValue = m_byte.load();
if (verbose)
dataLog(toString(currentThread(), ": locking with ", currentByteValue, "\n"));
// We allow ourselves to barge in.
if (!(currentByteValue & isHeldBit)
&& m_byte.compareExchangeWeak(currentByteValue, currentByteValue | isHeldBit))
return;
// If there is nobody parked and we haven't spun too much, we can just try to spin around.
if (!(currentByteValue & hasParkedBit) && spinCount < spinLimit) {
spinCount++;
std::this_thread::yield();
continue;
}
// Need to park. We do this by setting the parked bit first, and then parking. We spin around
// if the parked bit wasn't set and we failed at setting it.
if (!(currentByteValue & hasParkedBit)
&& !m_byte.compareExchangeWeak(currentByteValue, currentByteValue | hasParkedBit))
continue;
// We now expect the value to be isHeld|hasParked. So long as that's the case, we can park.
ParkingLot::ParkResult parkResult =
ParkingLot::compareAndPark(&m_byte, isHeldBit | hasParkedBit);
if (parkResult.wasUnparked) {
switch (static_cast<Token>(parkResult.token)) {
case DirectHandoff:
// The lock was never released. It was handed to us directly by the thread that did
// unlock(). This means we're done!
RELEASE_ASSERT(isHeld());
return;
case BargingOpportunity:
// This is the common case. The thread that called unlock() has released the lock,
// and we have been woken up so that we may get an opportunity to grab the lock. But
// other threads may barge, so the best that we can do is loop around and try again.
break;
}
}
// We have awoken, or we never parked because the byte value changed. Either way, we loop
// around and try again.
}
}
RefPtr<WebCore::IDBTransaction> IDBDatabase::transaction(const Vector<String>& objectStores, const String& modeString, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBDatabase::transaction");
ASSERT(currentThread() == originThreadID());
if (m_closePending) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The database connection is closing.");
return nullptr;
}
if (objectStores.isEmpty()) {
ec.code = IDBDatabaseException::InvalidAccessError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The storeNames parameter was empty.");
return nullptr;
}
IndexedDB::TransactionMode mode = IDBTransaction::stringToMode(modeString, ec.code);
if (ec.code) {
ec.message = makeString(ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The mode provided ('"), modeString, ASCIILiteral("') is not one of 'readonly' or 'readwrite'."));
return nullptr;
}
if (mode != IndexedDB::TransactionMode::ReadOnly && mode != IndexedDB::TransactionMode::ReadWrite) {
ec.code = TypeError;
return nullptr;
}
if (m_versionChangeTransaction && !m_versionChangeTransaction->isFinishedOrFinishing()) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': A version change transaction is running.");
return nullptr;
}
for (auto& objectStoreName : objectStores) {
if (m_info.hasObjectStore(objectStoreName))
continue;
ec.code = IDBDatabaseException::NotFoundError;
ec.message = ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': One of the specified object stores was not found.");
return nullptr;
}
auto info = IDBTransactionInfo::clientTransaction(m_connectionProxy.get(), objectStores, mode);
auto transaction = IDBTransaction::create(*this, info);
LOG(IndexedDB, "IDBDatabase::transaction - Added active transaction %s", info.identifier().loggingString().utf8().data());
m_activeTransactions.set(info.identifier(), &transaction.get());
return adoptRef(&transaction.leakRef());
}
void AudioDestinationNode::render(AudioBus*, AudioBus* destinationBus, size_t numberOfFrames)
{
// We don't want denormals slowing down any of the audio processing
// since they can very seriously hurt performance.
// This will take care of all AudioNodes because they all process within this scope.
DenormalDisabler denormalDisabler;
context().setAudioThread(currentThread());
if (!context().isInitialized()) {
destinationBus->zero();
setIsSilent(true);
return;
}
ASSERT(numberOfFrames);
if (!numberOfFrames) {
destinationBus->zero();
setIsSilent(true);
return;
}
// Let the context take care of any business at the start of each render quantum.
context().handlePreRenderTasks();
// This will cause the node(s) connected to us to process, which in turn will pull on their input(s),
// all the way backwards through the rendering graph.
AudioBus* renderedBus = input(0)->pull(destinationBus, numberOfFrames);
if (!renderedBus)
destinationBus->zero();
else if (renderedBus != destinationBus) {
// in-place processing was not possible - so copy
destinationBus->copyFrom(*renderedBus);
}
// Process nodes which need a little extra help because they are not connected to anything, but still need to process.
context().processAutomaticPullNodes(numberOfFrames);
// Let the context take care of any business at the end of each render quantum.
context().handlePostRenderTasks();
// Advance current sample-frame.
m_currentSampleFrame += numberOfFrames;
setIsSilent(destinationBus->isSilent());
// The reason we are handling mute after the call to setIsSilent() is because the muted state does
// not affect the audio destination node's effective playing state.
if (m_muted)
destinationBus->zero();
}
ExceptionOr<Ref<IDBRequest>> IDBIndex::getAllKeys(ExecState& execState, RefPtr<IDBKeyRange> range, Optional<uint32_t> count)
{
LOG(IndexedDB, "IDBIndex::getAllKeys");
ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
if (m_deleted || m_objectStore.isDeleted())
return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The index or its object store has been deleted.") };
if (!m_objectStore.transaction().isActive())
return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The transaction is inactive or finished.") };
return m_objectStore.transaction().requestGetAllIndexRecords(execState, *this, range.get(), IndexedDB::GetAllType::Keys, count);
}
WorkerContext::~WorkerContext()
{
ASSERT(currentThread() == thread()->threadID());
#if ENABLE(NOTIFICATIONS)
m_notifications.clear();
#endif
// Make sure we have no observers.
notifyObserversOfStop();
// Notify proxy that we are going away. This can free the WorkerThread object, so do not access it after this.
thread()->workerReportingProxy().workerContextDestroyed();
}
void WorkerRunLoop::runCleanupTasks(WorkerGlobalScope* context)
{
ASSERT(context);
ASSERT(context->thread().threadID() == currentThread());
ASSERT(m_messageQueue.killed());
while (true) {
auto task = m_messageQueue.tryGetMessageIgnoringKilled();
if (!task)
return;
task->performTask(*this, context);
}
}
