SQLTransactionState SQLTransaction::deliverTransactionErrorCallback()
{
InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncOperationCompletedCallbackStarting(m_database->executionContext(), m_asyncOperationId);
// Spec 4.3.2.10: If exists, invoke error callback with the last
// error to have occurred in this transaction.
if (SQLTransactionErrorCallback* errorCallback = m_errorCallback.release()) {
// If we get here with an empty m_transactionError, then the backend
// must be waiting in the idle state waiting for this state to finish.
// Hence, it's thread safe to fetch the backend transactionError without
// a lock.
if (!m_transactionError) {
ASSERT(m_backend->transactionError());
m_transactionError = SQLErrorData::create(*m_backend->transactionError());
}
ASSERT(m_transactionError);
errorCallback->handleEvent(SQLError::create(*m_transactionError));
m_transactionError = nullptr;
}
InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
clearCallbacks();
// Spec 4.3.2.10: Rollback the transaction.
return SQLTransactionState::CleanupAfterTransactionErrorCallback;
}
void Self::assignCallbacks() {
for (auto&& item : items_) {
item->setResultCallback([this](bool result) {
setResult(result);
clearCallbacks();
});
}
}
void ReadableStream::releaseReader()
{
if (m_closedPromise)
m_closedPromise.value().resolve(nullptr);
for (auto& request : m_readRequests)
request.resolveEnd();
clearCallbacks();
if (m_reader)
m_releasedReaders.append(WTF::move(m_reader));
}
refreshCompute::~refreshCompute()
{
clearCallbacks();
// Reset any global pointer pointing to this compute
for (unsigned int i=0; i<4; i++)
{
if (currentRefreshCompute[i] &&
(currentRefreshCompute[i])->panelName() == mPanelName)
{
currentRefreshCompute[i] = 0;
}
}
}
SQLTransactionState SQLTransaction::deliverSuccessCallback()
{
InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncOperationCompletedCallbackStarting(m_database->executionContext(), m_asyncOperationId);
// Spec 4.3.2.8: Deliver success callback.
if (VoidCallback* successCallback = m_successCallback.release())
successCallback->handleEvent();
InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
clearCallbacks();
// Schedule a "post-success callback" step to return control to the database thread in case there
// are further transactions queued up for this Database
return SQLTransactionState::CleanupAndTerminate;
}
void performDelayedClear() {
QMutexLocker lock(&toClearLock);
if (!toClear.isEmpty()) {
for (RPCCallbackClears::iterator i = toClear.begin(), e = toClear.end(); i != e; ++i) {
if (cDebug()) {
QMutexLocker locker(&parserMapLock);
if (parserMap.find(i->requestId) != parserMap.end()) {
DEBUG_LOG(("RPC Info: clearing delayed callback %1, error code %2").arg(i->requestId).arg(i->errorCode));
}
}
clearCallbacks(i->requestId, i->errorCode);
_mtp_internal::unregisterRequest(i->requestId);
}
toClear.clear();
}
}
void ReadableStream::changeStateToErrored()
{
if (m_state != State::Readable)
return;
clearValues();
m_state = State::Errored;
JSC::JSValue error = this->error();
if (m_closedPromise)
m_closedPromise.value().reject(error);
for (auto& request : m_readRequests)
request.reject(error);
clearCallbacks();
if (m_reader)
releaseReader();
}
bool SQLTransaction::computeNextStateAndCleanupIfNeeded()
{
// Only honor the requested state transition if we're not supposed to be
// cleaning up and shutting down:
if (m_database->opened()) {
setStateToRequestedState();
ASSERT(m_nextState == SQLTransactionState::End
|| m_nextState == SQLTransactionState::DeliverTransactionCallback
|| m_nextState == SQLTransactionState::DeliverTransactionErrorCallback
|| m_nextState == SQLTransactionState::DeliverStatementCallback
|| m_nextState == SQLTransactionState::DeliverQuotaIncreaseCallback
|| m_nextState == SQLTransactionState::DeliverSuccessCallback);
WTF_LOG(StorageAPI, "Callback %s\n", nameForSQLTransactionState(m_nextState));
return false;
}
clearCallbacks();
m_nextState = SQLTransactionState::CleanupAndTerminate;
return true;
}
bool Self::show() {
bool displayed = false;
// Fix AdMob consumes other ads' callbacks.
assignCallbacks();
for (auto&& item : items_) {
if (not displayed) {
if (item->show()) {
displayed = true;
continue;
}
}
if (not item->isLoaded()) {
item->load();
}
}
if (not displayed) {
clearCallbacks();
}
return displayed;
}
TriggerCentral::TriggerCentral() {
memset(hwEventCounters, 0, sizeof(hwEventCounters));
clearCallbacks(&triggerListeneres);
}
