Changeset 200483 in webkit


Ignore:
Timestamp:
May 5, 2016, 3:13:58 PM (9 years ago)
Author:
beidson@apple.com
Message:

Modern IDB: Add thread identifiers and assertions to IDB DOM objects.
​https://bugs.webkit.org/show_bug.cgi?id=157329

Reviewed by Alex Christensen.

No new tests (No current change in behavior, will be tested as bug 149953 makes progress).

  • Modules/indexeddb/IDBCursor.cpp:

(WebCore::IDBCursor::IDBCursor):
(WebCore::IDBCursor::~IDBCursor):
(WebCore::IDBCursor::sourcesDeleted):
(WebCore::IDBCursor::transaction):
(WebCore::IDBCursor::direction):
(WebCore::IDBCursor::update):
(WebCore::IDBCursor::advance):
(WebCore::IDBCursor::continueFunction):
(WebCore::IDBCursor::uncheckedIterateCursor):
(WebCore::IDBCursor::deleteFunction):
(WebCore::IDBCursor::setGetResult):

  • Modules/indexeddb/IDBDatabase.cpp:

(WebCore::IDBDatabase::~IDBDatabase):
(WebCore::IDBDatabase::hasPendingActivity):
(WebCore::IDBDatabase::name):
(WebCore::IDBDatabase::version):
(WebCore::IDBDatabase::objectStoreNames):
(WebCore::IDBDatabase::createObjectStore):
(WebCore::IDBDatabase::transaction):
(WebCore::IDBDatabase::deleteObjectStore):
(WebCore::IDBDatabase::close):
(WebCore::IDBDatabase::maybeCloseInServer):
(WebCore::IDBDatabase::activeDOMObjectName):
(WebCore::IDBDatabase::canSuspendForDocumentSuspension):
(WebCore::IDBDatabase::stop):
(WebCore::IDBDatabase::startVersionChangeTransaction):
(WebCore::IDBDatabase::didStartTransaction):
(WebCore::IDBDatabase::willCommitTransaction):
(WebCore::IDBDatabase::didCommitTransaction):
(WebCore::IDBDatabase::willAbortTransaction):
(WebCore::IDBDatabase::didAbortTransaction):
(WebCore::IDBDatabase::didCommitOrAbortTransaction):
(WebCore::IDBDatabase::fireVersionChangeEvent):
(WebCore::IDBDatabase::dispatchEvent):
(WebCore::IDBDatabase::didCreateIndexInfo):
(WebCore::IDBDatabase::didDeleteIndexInfo):

  • Modules/indexeddb/IDBDatabase.h:

(WebCore::IDBDatabase::originThreadID):

  • Modules/indexeddb/IDBIndex.cpp:

(WebCore::IDBIndex::IDBIndex):
(WebCore::IDBIndex::~IDBIndex):
(WebCore::IDBIndex::name):
(WebCore::IDBIndex::objectStore):
(WebCore::IDBIndex::keyPath):
(WebCore::IDBIndex::unique):
(WebCore::IDBIndex::multiEntry):
(WebCore::IDBIndex::openCursor):
(WebCore::IDBIndex::doCount):
(WebCore::IDBIndex::openKeyCursor):
(WebCore::IDBIndex::doGet):
(WebCore::IDBIndex::doGetKey):
(WebCore::IDBIndex::markAsDeleted):

  • Modules/indexeddb/IDBObjectStore.cpp:

(WebCore::IDBObjectStore::IDBObjectStore):
(WebCore::IDBObjectStore::~IDBObjectStore):
(WebCore::IDBObjectStore::name):
(WebCore::IDBObjectStore::keyPath):
(WebCore::IDBObjectStore::indexNames):
(WebCore::IDBObjectStore::transaction):
(WebCore::IDBObjectStore::autoIncrement):
(WebCore::IDBObjectStore::openCursor):
(WebCore::IDBObjectStore::get):
(WebCore::IDBObjectStore::putOrAdd):
(WebCore::IDBObjectStore::doDelete):
(WebCore::IDBObjectStore::clear):
(WebCore::IDBObjectStore::createIndex):
(WebCore::IDBObjectStore::index):
(WebCore::IDBObjectStore::deleteIndex):
(WebCore::IDBObjectStore::doCount):
(WebCore::IDBObjectStore::markAsDeleted):
(WebCore::IDBObjectStore::rollbackInfoForVersionChangeAbort):

  • Modules/indexeddb/IDBOpenDBRequest.cpp:

(WebCore::IDBOpenDBRequest::~IDBOpenDBRequest):
(WebCore::IDBOpenDBRequest::onError):
(WebCore::IDBOpenDBRequest::versionChangeTransactionDidFinish):
(WebCore::IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit):
(WebCore::IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion):
(WebCore::IDBOpenDBRequest::dispatchEvent):
(WebCore::IDBOpenDBRequest::onSuccess):
(WebCore::IDBOpenDBRequest::onUpgradeNeeded):
(WebCore::IDBOpenDBRequest::onDeleteDatabaseSuccess):
(WebCore::IDBOpenDBRequest::requestCompleted):
(WebCore::IDBOpenDBRequest::requestBlocked):

  • Modules/indexeddb/IDBRequest.cpp:

(WebCore::IDBRequest::~IDBRequest):
(WebCore::IDBRequest::errorCode):
(WebCore::IDBRequest::error):
(WebCore::IDBRequest::setSource):
(WebCore::IDBRequest::setVersionChangeTransaction):
(WebCore::IDBRequest::transaction):
(WebCore::IDBRequest::readyState):
(WebCore::IDBRequest::sourceObjectStoreIdentifier):
(WebCore::IDBRequest::sourceIndexIdentifier):
(WebCore::IDBRequest::requestedIndexRecordType):
(WebCore::IDBRequest::eventTargetInterface):
(WebCore::IDBRequest::activeDOMObjectName):
(WebCore::IDBRequest::canSuspendForDocumentSuspension):
(WebCore::IDBRequest::hasPendingActivity):
(WebCore::IDBRequest::stop):
(WebCore::IDBRequest::enqueueEvent):
(WebCore::IDBRequest::dispatchEvent):
(WebCore::IDBRequest::uncaughtExceptionInEventHandler):
(WebCore::IDBRequest::setResult):
(WebCore::IDBRequest::setResultToStructuredClone):
(WebCore::IDBRequest::clearResult):
(WebCore::IDBRequest::setResultToUndefined):
(WebCore::IDBRequest::resultCursor):
(WebCore::IDBRequest::willIterateCursor):
(WebCore::IDBRequest::didOpenOrIterateCursor):
(WebCore::IDBRequest::requestCompleted):
(WebCore::IDBRequest::onError):
(WebCore::IDBRequest::onSuccess):

  • Modules/indexeddb/IDBRequest.h:

(WebCore::IDBRequest::originThreadID):

  • Modules/indexeddb/IDBTransaction.cpp:

(WebCore::IDBTransaction::IDBTransaction):
(WebCore::IDBTransaction::~IDBTransaction):
(WebCore::IDBTransaction::mode):
(WebCore::IDBTransaction::db):
(WebCore::IDBTransaction::serverConnection):
(WebCore::IDBTransaction::error):
(WebCore::IDBTransaction::objectStore):
(WebCore::IDBTransaction::abortDueToFailedRequest):
(WebCore::IDBTransaction::transitionedToFinishing):
(WebCore::IDBTransaction::abort):
(WebCore::IDBTransaction::abortOnServerAndCancelRequests):
(WebCore::IDBTransaction::activeDOMObjectName):
(WebCore::IDBTransaction::canSuspendForDocumentSuspension):
(WebCore::IDBTransaction::hasPendingActivity):
(WebCore::IDBTransaction::stop):
(WebCore::IDBTransaction::isActive):
(WebCore::IDBTransaction::isFinishedOrFinishing):
(WebCore::IDBTransaction::addRequest):
(WebCore::IDBTransaction::removeRequest):
(WebCore::IDBTransaction::scheduleOperation):
(WebCore::IDBTransaction::scheduleOperationTimer):
(WebCore::IDBTransaction::operationTimerFired):
(WebCore::IDBTransaction::commit):
(WebCore::IDBTransaction::commitOnServer):
(WebCore::IDBTransaction::finishAbortOrCommit):
(WebCore::IDBTransaction::didStart):
(WebCore::IDBTransaction::notifyDidAbort):
(WebCore::IDBTransaction::didAbort):
(WebCore::IDBTransaction::didCommit):
(WebCore::IDBTransaction::fireOnComplete):
(WebCore::IDBTransaction::fireOnAbort):
(WebCore::IDBTransaction::enqueueEvent):
(WebCore::IDBTransaction::dispatchEvent):
(WebCore::IDBTransaction::createObjectStore):
(WebCore::IDBTransaction::createObjectStoreOnServer):
(WebCore::IDBTransaction::didCreateObjectStoreOnServer):
(WebCore::IDBTransaction::createIndex):
(WebCore::IDBTransaction::createIndexOnServer):
(WebCore::IDBTransaction::didCreateIndexOnServer):
(WebCore::IDBTransaction::requestOpenCursor):
(WebCore::IDBTransaction::doRequestOpenCursor):
(WebCore::IDBTransaction::openCursorOnServer):
(WebCore::IDBTransaction::didOpenCursorOnServer):
(WebCore::IDBTransaction::iterateCursor):
(WebCore::IDBTransaction::iterateCursorOnServer):
(WebCore::IDBTransaction::didIterateCursorOnServer):
(WebCore::IDBTransaction::requestGetRecord):
(WebCore::IDBTransaction::requestGetValue):
(WebCore::IDBTransaction::requestGetKey):
(WebCore::IDBTransaction::requestIndexRecord):
(WebCore::IDBTransaction::getRecordOnServer):
(WebCore::IDBTransaction::didGetRecordOnServer):
(WebCore::IDBTransaction::requestCount):
(WebCore::IDBTransaction::getCountOnServer):
(WebCore::IDBTransaction::didGetCountOnServer):
(WebCore::IDBTransaction::requestDeleteRecord):
(WebCore::IDBTransaction::deleteRecordOnServer):
(WebCore::IDBTransaction::didDeleteRecordOnServer):
(WebCore::IDBTransaction::requestClearObjectStore):
(WebCore::IDBTransaction::clearObjectStoreOnServer):
(WebCore::IDBTransaction::didClearObjectStoreOnServer):
(WebCore::IDBTransaction::requestPutOrAdd):
(WebCore::IDBTransaction::putOrAddOnServer):
(WebCore::IDBTransaction::didPutOrAddOnServer):
(WebCore::IDBTransaction::deleteObjectStore):
(WebCore::IDBTransaction::deleteObjectStoreOnServer):
(WebCore::IDBTransaction::didDeleteObjectStoreOnServer):
(WebCore::IDBTransaction::deleteIndex):
(WebCore::IDBTransaction::deleteIndexOnServer):
(WebCore::IDBTransaction::didDeleteIndexOnServer):
(WebCore::IDBTransaction::operationDidComplete):
(WebCore::IDBTransaction::establishOnServer):
(WebCore::IDBTransaction::activate):
(WebCore::IDBTransaction::deactivate):

Location:
trunk/Source/WebCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r200479 r200483  
     12016-05-04  Brady Eidson  <beidson@apple.com>
     2
     3        Modern IDB: Add thread identifiers and assertions to IDB DOM objects.
     4        https://bugs.webkit.org/show_bug.cgi?id=157329
     5
     6        Reviewed by Alex Christensen.
     7
     8        No new tests (No current change in behavior, will be tested as bug 149953 makes progress).
     9
     10        * Modules/indexeddb/IDBCursor.cpp:
     11        (WebCore::IDBCursor::IDBCursor):
     12        (WebCore::IDBCursor::~IDBCursor):
     13        (WebCore::IDBCursor::sourcesDeleted):
     14        (WebCore::IDBCursor::transaction):
     15        (WebCore::IDBCursor::direction):
     16        (WebCore::IDBCursor::update):
     17        (WebCore::IDBCursor::advance):
     18        (WebCore::IDBCursor::continueFunction):
     19        (WebCore::IDBCursor::uncheckedIterateCursor):
     20        (WebCore::IDBCursor::deleteFunction):
     21        (WebCore::IDBCursor::setGetResult):
     22       
     23        * Modules/indexeddb/IDBDatabase.cpp:
     24        (WebCore::IDBDatabase::~IDBDatabase):
     25        (WebCore::IDBDatabase::hasPendingActivity):
     26        (WebCore::IDBDatabase::name):
     27        (WebCore::IDBDatabase::version):
     28        (WebCore::IDBDatabase::objectStoreNames):
     29        (WebCore::IDBDatabase::createObjectStore):
     30        (WebCore::IDBDatabase::transaction):
     31        (WebCore::IDBDatabase::deleteObjectStore):
     32        (WebCore::IDBDatabase::close):
     33        (WebCore::IDBDatabase::maybeCloseInServer):
     34        (WebCore::IDBDatabase::activeDOMObjectName):
     35        (WebCore::IDBDatabase::canSuspendForDocumentSuspension):
     36        (WebCore::IDBDatabase::stop):
     37        (WebCore::IDBDatabase::startVersionChangeTransaction):
     38        (WebCore::IDBDatabase::didStartTransaction):
     39        (WebCore::IDBDatabase::willCommitTransaction):
     40        (WebCore::IDBDatabase::didCommitTransaction):
     41        (WebCore::IDBDatabase::willAbortTransaction):
     42        (WebCore::IDBDatabase::didAbortTransaction):
     43        (WebCore::IDBDatabase::didCommitOrAbortTransaction):
     44        (WebCore::IDBDatabase::fireVersionChangeEvent):
     45        (WebCore::IDBDatabase::dispatchEvent):
     46        (WebCore::IDBDatabase::didCreateIndexInfo):
     47        (WebCore::IDBDatabase::didDeleteIndexInfo):
     48        * Modules/indexeddb/IDBDatabase.h:
     49        (WebCore::IDBDatabase::originThreadID):
     50       
     51        * Modules/indexeddb/IDBIndex.cpp:
     52        (WebCore::IDBIndex::IDBIndex):
     53        (WebCore::IDBIndex::~IDBIndex):
     54        (WebCore::IDBIndex::name):
     55        (WebCore::IDBIndex::objectStore):
     56        (WebCore::IDBIndex::keyPath):
     57        (WebCore::IDBIndex::unique):
     58        (WebCore::IDBIndex::multiEntry):
     59        (WebCore::IDBIndex::openCursor):
     60        (WebCore::IDBIndex::doCount):
     61        (WebCore::IDBIndex::openKeyCursor):
     62        (WebCore::IDBIndex::doGet):
     63        (WebCore::IDBIndex::doGetKey):
     64        (WebCore::IDBIndex::markAsDeleted):
     65       
     66        * Modules/indexeddb/IDBObjectStore.cpp:
     67        (WebCore::IDBObjectStore::IDBObjectStore):
     68        (WebCore::IDBObjectStore::~IDBObjectStore):
     69        (WebCore::IDBObjectStore::name):
     70        (WebCore::IDBObjectStore::keyPath):
     71        (WebCore::IDBObjectStore::indexNames):
     72        (WebCore::IDBObjectStore::transaction):
     73        (WebCore::IDBObjectStore::autoIncrement):
     74        (WebCore::IDBObjectStore::openCursor):
     75        (WebCore::IDBObjectStore::get):
     76        (WebCore::IDBObjectStore::putOrAdd):
     77        (WebCore::IDBObjectStore::doDelete):
     78        (WebCore::IDBObjectStore::clear):
     79        (WebCore::IDBObjectStore::createIndex):
     80        (WebCore::IDBObjectStore::index):
     81        (WebCore::IDBObjectStore::deleteIndex):
     82        (WebCore::IDBObjectStore::doCount):
     83        (WebCore::IDBObjectStore::markAsDeleted):
     84        (WebCore::IDBObjectStore::rollbackInfoForVersionChangeAbort):
     85       
     86        * Modules/indexeddb/IDBOpenDBRequest.cpp:
     87        (WebCore::IDBOpenDBRequest::~IDBOpenDBRequest):
     88        (WebCore::IDBOpenDBRequest::onError):
     89        (WebCore::IDBOpenDBRequest::versionChangeTransactionDidFinish):
     90        (WebCore::IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit):
     91        (WebCore::IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion):
     92        (WebCore::IDBOpenDBRequest::dispatchEvent):
     93        (WebCore::IDBOpenDBRequest::onSuccess):
     94        (WebCore::IDBOpenDBRequest::onUpgradeNeeded):
     95        (WebCore::IDBOpenDBRequest::onDeleteDatabaseSuccess):
     96        (WebCore::IDBOpenDBRequest::requestCompleted):
     97        (WebCore::IDBOpenDBRequest::requestBlocked):
     98       
     99        * Modules/indexeddb/IDBRequest.cpp:
     100        (WebCore::IDBRequest::~IDBRequest):
     101        (WebCore::IDBRequest::errorCode):
     102        (WebCore::IDBRequest::error):
     103        (WebCore::IDBRequest::setSource):
     104        (WebCore::IDBRequest::setVersionChangeTransaction):
     105        (WebCore::IDBRequest::transaction):
     106        (WebCore::IDBRequest::readyState):
     107        (WebCore::IDBRequest::sourceObjectStoreIdentifier):
     108        (WebCore::IDBRequest::sourceIndexIdentifier):
     109        (WebCore::IDBRequest::requestedIndexRecordType):
     110        (WebCore::IDBRequest::eventTargetInterface):
     111        (WebCore::IDBRequest::activeDOMObjectName):
     112        (WebCore::IDBRequest::canSuspendForDocumentSuspension):
     113        (WebCore::IDBRequest::hasPendingActivity):
     114        (WebCore::IDBRequest::stop):
     115        (WebCore::IDBRequest::enqueueEvent):
     116        (WebCore::IDBRequest::dispatchEvent):
     117        (WebCore::IDBRequest::uncaughtExceptionInEventHandler):
     118        (WebCore::IDBRequest::setResult):
     119        (WebCore::IDBRequest::setResultToStructuredClone):
     120        (WebCore::IDBRequest::clearResult):
     121        (WebCore::IDBRequest::setResultToUndefined):
     122        (WebCore::IDBRequest::resultCursor):
     123        (WebCore::IDBRequest::willIterateCursor):
     124        (WebCore::IDBRequest::didOpenOrIterateCursor):
     125        (WebCore::IDBRequest::requestCompleted):
     126        (WebCore::IDBRequest::onError):
     127        (WebCore::IDBRequest::onSuccess):
     128        * Modules/indexeddb/IDBRequest.h:
     129        (WebCore::IDBRequest::originThreadID):
     130       
     131        * Modules/indexeddb/IDBTransaction.cpp:
     132        (WebCore::IDBTransaction::IDBTransaction):
     133        (WebCore::IDBTransaction::~IDBTransaction):
     134        (WebCore::IDBTransaction::mode):
     135        (WebCore::IDBTransaction::db):
     136        (WebCore::IDBTransaction::serverConnection):
     137        (WebCore::IDBTransaction::error):
     138        (WebCore::IDBTransaction::objectStore):
     139        (WebCore::IDBTransaction::abortDueToFailedRequest):
     140        (WebCore::IDBTransaction::transitionedToFinishing):
     141        (WebCore::IDBTransaction::abort):
     142        (WebCore::IDBTransaction::abortOnServerAndCancelRequests):
     143        (WebCore::IDBTransaction::activeDOMObjectName):
     144        (WebCore::IDBTransaction::canSuspendForDocumentSuspension):
     145        (WebCore::IDBTransaction::hasPendingActivity):
     146        (WebCore::IDBTransaction::stop):
     147        (WebCore::IDBTransaction::isActive):
     148        (WebCore::IDBTransaction::isFinishedOrFinishing):
     149        (WebCore::IDBTransaction::addRequest):
     150        (WebCore::IDBTransaction::removeRequest):
     151        (WebCore::IDBTransaction::scheduleOperation):
     152        (WebCore::IDBTransaction::scheduleOperationTimer):
     153        (WebCore::IDBTransaction::operationTimerFired):
     154        (WebCore::IDBTransaction::commit):
     155        (WebCore::IDBTransaction::commitOnServer):
     156        (WebCore::IDBTransaction::finishAbortOrCommit):
     157        (WebCore::IDBTransaction::didStart):
     158        (WebCore::IDBTransaction::notifyDidAbort):
     159        (WebCore::IDBTransaction::didAbort):
     160        (WebCore::IDBTransaction::didCommit):
     161        (WebCore::IDBTransaction::fireOnComplete):
     162        (WebCore::IDBTransaction::fireOnAbort):
     163        (WebCore::IDBTransaction::enqueueEvent):
     164        (WebCore::IDBTransaction::dispatchEvent):
     165        (WebCore::IDBTransaction::createObjectStore):
     166        (WebCore::IDBTransaction::createObjectStoreOnServer):
     167        (WebCore::IDBTransaction::didCreateObjectStoreOnServer):
     168        (WebCore::IDBTransaction::createIndex):
     169        (WebCore::IDBTransaction::createIndexOnServer):
     170        (WebCore::IDBTransaction::didCreateIndexOnServer):
     171        (WebCore::IDBTransaction::requestOpenCursor):
     172        (WebCore::IDBTransaction::doRequestOpenCursor):
     173        (WebCore::IDBTransaction::openCursorOnServer):
     174        (WebCore::IDBTransaction::didOpenCursorOnServer):
     175        (WebCore::IDBTransaction::iterateCursor):
     176        (WebCore::IDBTransaction::iterateCursorOnServer):
     177        (WebCore::IDBTransaction::didIterateCursorOnServer):
     178        (WebCore::IDBTransaction::requestGetRecord):
     179        (WebCore::IDBTransaction::requestGetValue):
     180        (WebCore::IDBTransaction::requestGetKey):
     181        (WebCore::IDBTransaction::requestIndexRecord):
     182        (WebCore::IDBTransaction::getRecordOnServer):
     183        (WebCore::IDBTransaction::didGetRecordOnServer):
     184        (WebCore::IDBTransaction::requestCount):
     185        (WebCore::IDBTransaction::getCountOnServer):
     186        (WebCore::IDBTransaction::didGetCountOnServer):
     187        (WebCore::IDBTransaction::requestDeleteRecord):
     188        (WebCore::IDBTransaction::deleteRecordOnServer):
     189        (WebCore::IDBTransaction::didDeleteRecordOnServer):
     190        (WebCore::IDBTransaction::requestClearObjectStore):
     191        (WebCore::IDBTransaction::clearObjectStoreOnServer):
     192        (WebCore::IDBTransaction::didClearObjectStoreOnServer):
     193        (WebCore::IDBTransaction::requestPutOrAdd):
     194        (WebCore::IDBTransaction::putOrAddOnServer):
     195        (WebCore::IDBTransaction::didPutOrAddOnServer):
     196        (WebCore::IDBTransaction::deleteObjectStore):
     197        (WebCore::IDBTransaction::deleteObjectStoreOnServer):
     198        (WebCore::IDBTransaction::didDeleteObjectStoreOnServer):
     199        (WebCore::IDBTransaction::deleteIndex):
     200        (WebCore::IDBTransaction::deleteIndexOnServer):
     201        (WebCore::IDBTransaction::didDeleteIndexOnServer):
     202        (WebCore::IDBTransaction::operationDidComplete):
     203        (WebCore::IDBTransaction::establishOnServer):
     204        (WebCore::IDBTransaction::activate):
     205        (WebCore::IDBTransaction::deactivate):
     206
    12072016-05-05  Nan Wang  <n_wang@apple.com>
    2208

  • trunk/Source/WebCore/Modules/indexeddb/IDBCursor.cpp

    r200287 r200483  
    3131#include "ExceptionCode.h"
    3232#include "IDBBindingUtilities.h"
     33#include "IDBDatabase.h"
    3334#include "IDBDatabaseException.h"
    3435#include "IDBGetResult.h"
    … …  
    117118    , m_objectStore(&objectStore)
    118119{
     120    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
     121
    119122    suspendIfNeeded();
    120123}
    … …  
    125128    , m_index(&index)
    126129{
     130    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
     131
    127132    suspendIfNeeded();
    128133}
    … …  
    130135IDBCursor::~IDBCursor()
    131136{
     137    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    132138}
    133139
    134140bool IDBCursor::sourcesDeleted() const
    135141{
     142    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
     143
    136144    if (m_objectStore)
    137145        return m_objectStore->isDeleted();
    … …  
    152160IDBTransaction& IDBCursor::transaction() const
    153161{
     162    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    154163    return effectiveObjectStore().modernTransaction();
    155164}
    … …  
    157166const String& IDBCursor::direction() const
    158167{
     168    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    159169    return directionToString(m_info.cursorDirection());
    160170}
    … …  
    163173{
    164174    LOG(IndexedDB, "IDBCursor::update");
     175    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    165176
    166177    if (sourcesDeleted()) {
    … …  
    221232{
    222233    LOG(IndexedDB, "IDBCursor::advance");
     234    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    223235
    224236    if (!m_request) {
    … …  
    268280{
    269281    LOG(IndexedDB, "IDBCursor::continueFunction (to key %s)", key.loggingString().utf8().data());
     282    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    270283
    271284    if (!m_request) {
    … …  
    317330void IDBCursor::uncheckedIterateCursor(const IDBKeyData& key, unsigned count)
    318331{
     332    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
     333
    319334    ++m_outstandingRequestCount;
    320335
    … …  
    326341{
    327342    LOG(IndexedDB, "IDBCursor::deleteFunction");
     343    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    328344
    329345    if (sourcesDeleted()) {
    … …  
    371387{
    372388    LOG(IndexedDB, "IDBCursor::setGetResult - current key %s", getResult.keyData().loggingString().substring(0, 100).utf8().data());
     389    ASSERT(currentThread() == effectiveObjectStore().modernTransaction().database().originThreadID());
    373390
    374391    auto* context = request.scriptExecutionContext();

  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.cpp

    r200163 r200483  
    6363IDBDatabase::~IDBDatabase()
    6464{
     65    ASSERT(currentThread() == m_originThreadID);
    6566    m_connectionProxy->connectionToServer().unregisterDatabaseConnection(*this);
    6667}
    … …  
    6869bool IDBDatabase::hasPendingActivity() const
    6970{
     71    ASSERT(currentThread() == m_originThreadID);
    7072    return !m_closedInServer;
    7173}
    … …  
    7375const String IDBDatabase::name() const
    7476{
     77    ASSERT(currentThread() == m_originThreadID);
    7578    return m_info.name();
    7679}
    … …  
    7881uint64_t IDBDatabase::version() const
    7982{
     83    ASSERT(currentThread() == m_originThreadID);
    8084    return m_info.version();
    8185}
    … …  
    8387RefPtr<DOMStringList> IDBDatabase::objectStoreNames() const
    8488{
     89    ASSERT(currentThread() == m_originThreadID);
     90
    8591    RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
    8692    for (auto& name : m_info.objectStoreNames())
    … …  
    100106    LOG(IndexedDB, "IDBDatabase::createObjectStore - (%s %s)", m_info.name().utf8().data(), name.utf8().data());
    101107
     108    ASSERT(currentThread() == m_originThreadID);
    102109    ASSERT(!m_versionChangeTransaction || m_versionChangeTransaction->isVersionChange());
    103110
    … …  
    145152    LOG(IndexedDB, "IDBDatabase::transaction");
    146153
     154    ASSERT(currentThread() == m_originThreadID);
     155
    147156    if (m_closePending) {
    148157        ec.code = IDBDatabaseException::InvalidStateError;
    … …  
    194203RefPtr<WebCore::IDBTransaction> IDBDatabase::transaction(ScriptExecutionContext* context, const String& objectStore, const String& mode, ExceptionCodeWithMessage& ec)
    195204{
     205    ASSERT(currentThread() == m_originThreadID);
     206
    196207    Vector<String> objectStores(1);
    197208    objectStores[0] = objectStore;
    … …  
    203214    LOG(IndexedDB, "IDBDatabase::deleteObjectStore");
    204215
     216    ASSERT(currentThread() == m_originThreadID);
     217
    205218    if (!m_versionChangeTransaction) {
    206219        ec.code = IDBDatabaseException::InvalidStateError;
    … …  
    228241    LOG(IndexedDB, "IDBDatabase::close - %" PRIu64, m_databaseConnectionIdentifier);
    229242
     243    ASSERT(currentThread() == m_originThreadID);
     244
    230245    m_closePending = true;
    231246    maybeCloseInServer();
    … …  
    235250{
    236251    LOG(IndexedDB, "IDBDatabase::maybeCloseInServer - %" PRIu64, m_databaseConnectionIdentifier);
     252
     253    ASSERT(currentThread() == m_originThreadID);
    237254
    238255    if (m_closedInServer)
    … …  
    251268const char* IDBDatabase::activeDOMObjectName() const
    252269{
     270    ASSERT(currentThread() == m_originThreadID);
    253271    return "IDBDatabase";
    254272}
    … …  
    256274bool IDBDatabase::canSuspendForDocumentSuspension() const
    257275{
     276    ASSERT(currentThread() == m_originThreadID);
     277
    258278    // FIXME: This value will sometimes be false when database operations are actually in progress.
    259279    // Such database operations do not yet exist.
    … …  
    264284{
    265285    LOG(IndexedDB, "IDBDatabase::stop - %" PRIu64, m_databaseConnectionIdentifier);
     286
     287    ASSERT(currentThread() == m_originThreadID);
    266288
    267289    Vector<IDBResourceIdentifier> transactionIdentifiers;
    … …  
    284306    LOG(IndexedDB, "IDBDatabase::startVersionChangeTransaction %s", info.identifier().loggingString().utf8().data());
    285307
     308    ASSERT(currentThread() == m_originThreadID);
    286309    ASSERT(!m_versionChangeTransaction);
    287310    ASSERT(info.mode() == IndexedDB::TransactionMode::VersionChange);
    … …  
    301324    LOG(IndexedDB, "IDBDatabase::didStartTransaction %s", transaction.info().identifier().loggingString().utf8().data());
    302325    ASSERT(!m_versionChangeTransaction);
     326    ASSERT(currentThread() == m_originThreadID);
    303327
    304328    // It is possible for the client to have aborted a transaction before the server replies back that it has started.
    … …  
    312336{
    313337    LOG(IndexedDB, "IDBDatabase::willCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data());
     338
     339    ASSERT(currentThread() == m_originThreadID);
    314340
    315341    auto refTransaction = m_activeTransactions.take(transaction.info().identifier());
    … …  
    322348    LOG(IndexedDB, "IDBDatabase::didCommitTransaction %s", transaction.info().identifier().loggingString().utf8().data());
    323349
     350    ASSERT(currentThread() == m_originThreadID);
     351
    324352    if (m_versionChangeTransaction == &transaction)
    325353        m_info.setVersion(transaction.info().newVersion());
    … …  
    331359{
    332360    LOG(IndexedDB, "IDBDatabase::willAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
     361
     362    ASSERT(currentThread() == m_originThreadID);
    333363
    334364    auto refTransaction = m_activeTransactions.take(transaction.info().identifier());
    … …  
    349379{
    350380    LOG(IndexedDB, "IDBDatabase::didAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
     381
     382    ASSERT(currentThread() == m_originThreadID);
    351383
    352384    if (transaction.isVersionChange()) {
    … …  
    363395{
    364396    LOG(IndexedDB, "IDBDatabase::didCommitOrAbortTransaction %s", transaction.info().identifier().loggingString().utf8().data());
     397
     398    ASSERT(currentThread() == m_originThreadID);
    365399
    366400    if (m_versionChangeTransaction == &transaction)
    … …  
    392426    LOG(IndexedDB, "IDBDatabase::fireVersionChangeEvent - current version %" PRIu64 ", requested version %" PRIu64 ", connection %" PRIu64, currentVersion, requestedVersion, m_databaseConnectionIdentifier);
    393427
     428    ASSERT(currentThread() == m_originThreadID);
     429
    394430    if (!scriptExecutionContext() || m_closePending) {
    395431        serverConnection().didFireVersionChangeEvent(m_databaseConnectionIdentifier, requestIdentifier);
    … …  
    405441{
    406442    LOG(IndexedDB, "IDBDatabase::dispatchEvent (%" PRIu64 ")", m_databaseConnectionIdentifier);
     443    ASSERT(currentThread() == m_originThreadID);
    407444
    408445    bool result = EventTargetWithInlineData::dispatchEvent(event);
    … …  
    416453void IDBDatabase::didCreateIndexInfo(const IDBIndexInfo& info)
    417454{
     455    ASSERT(currentThread() == m_originThreadID);
     456
    418457    auto* objectStore = m_info.infoForExistingObjectStore(info.objectStoreIdentifier());
    419458    ASSERT(objectStore);
    … …  
    423462void IDBDatabase::didDeleteIndexInfo(const IDBIndexInfo& info)
    424463{
     464    ASSERT(currentThread() == m_originThreadID);
     465
    425466    auto* objectStore = m_info.infoForExistingObjectStore(info.objectStoreIdentifier());
    426467    ASSERT(objectStore);

  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.h

    r199843 r200483  
    102102    bool hasPendingActivity() const final;
    103103
     104    ThreadIdentifier originThreadID() const { return m_originThreadID; }
     105
    104106private:
    105107    IDBDatabase(ScriptExecutionContext&, IDBClient::IDBConnectionProxy&, const IDBResultData&);
    … …  
    120122    HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_committingTransactions;
    121123    HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_abortingTransactions;
     124
     125    ThreadIdentifier m_originThreadID { currentThread() };
    122126};
    123127

  • trunk/Source/WebCore/Modules/indexeddb/IDBIndex.cpp

    r200246 r200483  
    3131#include "IDBBindingUtilities.h"
    3232#include "IDBCursor.h"
     33#include "IDBDatabase.h"
    3334#include "IDBDatabaseException.h"
    3435#include "IDBKeyRangeData.h"
    … …  
    4748    , m_objectStore(objectStore)
    4849{
     50    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
     51
    4952    suspendIfNeeded();
    5053}
    … …  
    5255IDBIndex::~IDBIndex()
    5356{
     57    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    5458}
    5559
    … …  
    7175const String& IDBIndex::name() const
    7276{
     77    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    7378    return m_info.name();
    7479}
    … …  
    7681RefPtr<IDBObjectStore> IDBIndex::objectStore()
    7782{
     83    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    7884    return &m_objectStore;
    7985}
    … …  
    8187const IDBKeyPath& IDBIndex::keyPath() const
    8288{
     89    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    8390    return m_info.keyPath();
    8491}
    … …  
    8693bool IDBIndex::unique() const
    8794{
     95    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    8896    return m_info.unique();
    8997}
    … …  
    9199bool IDBIndex::multiEntry() const
    92100{
     101    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    93102    return m_info.multiEntry();
    94103}
    … …  
    97106{
    98107    LOG(IndexedDB, "IDBIndex::openCursor");
     108    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    99109
    100110    if (m_deleted || m_objectStore.isDeleted()) {
    … …  
    129139{
    130140    LOG(IndexedDB, "IDBIndex::openCursor");
     141    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
     142
    131143    RefPtr<IDBKeyRange> keyRange = IDBKeyRange::only(context, key, ec.code);
    132144    if (ec.code) {
    … …  
    161173RefPtr<IDBRequest> IDBIndex::doCount(ScriptExecutionContext& context, const IDBKeyRangeData& range, ExceptionCodeWithMessage& ec)
    162174{
     175    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
     176
    163177    if (m_deleted || m_objectStore.isDeleted()) {
    164178        ec.code = IDBDatabaseException::InvalidStateError;
    … …  
    185199{
    186200    LOG(IndexedDB, "IDBIndex::openKeyCursor");
     201    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
    187202
    188203    if (m_deleted || m_objectStore.isDeleted()) {
    … …  
    242257RefPtr<IDBRequest> IDBIndex::doGet(ScriptExecutionContext& context, const IDBKeyRangeData& range, ExceptionCodeWithMessage& ec)
    243258{
     259    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
     260
    244261    if (m_deleted || m_objectStore.isDeleted()) {
    245262        ec.code = IDBDatabaseException::InvalidStateError;
    … …  
    286303RefPtr<IDBRequest> IDBIndex::doGetKey(ScriptExecutionContext& context, const IDBKeyRangeData& range, ExceptionCodeWithMessage& ec)
    287304{
     305    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
     306
    288307    if (m_deleted || m_objectStore.isDeleted()) {
    289308        ec.code = IDBDatabaseException::InvalidStateError;
    … …  
    309328void IDBIndex::markAsDeleted()
    310329{
     330    ASSERT(currentThread() == m_objectStore.modernTransaction().database().originThreadID());
     331
    311332    ASSERT(!m_deleted);
    312333    m_deleted = true;

  • trunk/Source/WebCore/Modules/indexeddb/IDBObjectStore.cpp

    r200246 r200483  
    6464    , m_transaction(transaction)
    6565{
     66    ASSERT(currentThread() == m_transaction->database().originThreadID());
     67
    6668    suspendIfNeeded();
    6769}
    … …  
    6971IDBObjectStore::~IDBObjectStore()
    7072{
     73    ASSERT(currentThread() == m_transaction->database().originThreadID());
    7174}
    7275
    … …  
    8891const String& IDBObjectStore::name() const
    8992{
     93    ASSERT(currentThread() == m_transaction->database().originThreadID());
    9094    return m_info.name();
    9195}
    … …  
    9397const IDBKeyPath& IDBObjectStore::keyPath() const
    9498{
     99    ASSERT(currentThread() == m_transaction->database().originThreadID());
    95100    return m_info.keyPath();
    96101}
    … …  
    98103RefPtr<DOMStringList> IDBObjectStore::indexNames() const
    99104{
     105    ASSERT(currentThread() == m_transaction->database().originThreadID());
     106
    100107    RefPtr<DOMStringList> indexNames = DOMStringList::create();
    101108    for (auto& name : m_info.indexNames())
    … …  
    108115RefPtr<IDBTransaction> IDBObjectStore::transaction()
    109116{
     117    ASSERT(currentThread() == m_transaction->database().originThreadID());\
    110118    return &m_transaction.get();
    111119}
    … …  
    113121bool IDBObjectStore::autoIncrement() const
    114122{
     123    ASSERT(currentThread() == m_transaction->database().originThreadID());
    115124    return m_info.autoIncrement();
    116125}
    … …  
    119128{
    120129    LOG(IndexedDB, "IDBObjectStore::openCursor");
     130    ASSERT(currentThread() == m_transaction->database().originThreadID());
    121131
    122132    if (m_deleted) {
    … …  
    155165{
    156166    LOG(IndexedDB, "IDBObjectStore::get");
     167    ASSERT(currentThread() == m_transaction->database().originThreadID());
    157168
    158169    if (!m_transaction->isActive()) {
    … …  
    182193{
    183194    LOG(IndexedDB, "IDBObjectStore::get");
     195    ASSERT(currentThread() == m_transaction->database().originThreadID());
    184196
    185197    if (!m_transaction->isActive()) {
    … …  
    228240{
    229241    LOG(IndexedDB, "IDBObjectStore::putOrAdd");
     242    ASSERT(currentThread() == m_transaction->database().originThreadID());
    230243
    231244    auto context = scriptExecutionContextFromExecState(&state);
    … …  
    338351{
    339352    LOG(IndexedDB, "IDBObjectStore::deleteFunction");
     353    ASSERT(currentThread() == m_transaction->database().originThreadID());
    340354
    341355    // The IDB spec for several IDBObjectStore methods states that transaction related exceptions should fire before
    … …  
    393407{
    394408    LOG(IndexedDB, "IDBObjectStore::clear");
     409    ASSERT(currentThread() == m_transaction->database().originThreadID());
    395410
    396411    // The IDB spec for several IDBObjectStore methods states that transaction related exceptions should fire before
    … …  
    424439{
    425440    LOG(IndexedDB, "IDBObjectStore::createIndex %s", name.utf8().data());
     441    ASSERT(currentThread() == m_transaction->database().originThreadID());
    426442
    427443    if (m_deleted) {
    … …  
    482498{
    483499    LOG(IndexedDB, "IDBObjectStore::index");
     500    ASSERT(currentThread() == m_transaction->database().originThreadID());
    484501
    485502    if (!scriptExecutionContext())
    … …  
    520537{
    521538    LOG(IndexedDB, "IDBObjectStore::deleteIndex %s", name.utf8().data());
     539    ASSERT(currentThread() == m_transaction->database().originThreadID());
    522540
    523541    if (m_deleted) {
    … …  
    586604RefPtr<IDBRequest> IDBObjectStore::doCount(ScriptExecutionContext& context, const IDBKeyRangeData& range, ExceptionCodeWithMessage& ec)
    587605{
     606    ASSERT(currentThread() == m_transaction->database().originThreadID());
     607
    588608    // The IDB spec for several IDBObjectStore methods states that transaction related exceptions should fire before
    589609    // the exception for an object store being deleted.
    … …  
    613633void IDBObjectStore::markAsDeleted()
    614634{
     635    ASSERT(currentThread() == m_transaction->database().originThreadID());
    615636    m_deleted = true;
    616637}
    … …  
    618639void IDBObjectStore::rollbackInfoForVersionChangeAbort()
    619640{
     641    ASSERT(currentThread() == m_transaction->database().originThreadID());
    620642    m_info = m_originalInfo;
    621643}

  • trunk/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp

    r199843 r200483  
    6363IDBOpenDBRequest::~IDBOpenDBRequest()
    6464{
     65    ASSERT(currentThread() == originThreadID());
    6566}
    6667
    6768void IDBOpenDBRequest::onError(const IDBResultData& data)
    6869{
     70    ASSERT(currentThread() == originThreadID());
     71
    6972    m_domError = DOMError::create(data.error().name(), data.error().message());
    7073    enqueueEvent(IDBRequestCompletionEvent::create(eventNames().errorEvent, true, true, *this));
    … …  
    7376void IDBOpenDBRequest::versionChangeTransactionDidFinish()
    7477{
     78    ASSERT(currentThread() == originThreadID());
     79
    7580    // 3.3.7 "versionchange" transaction steps
    7681    // When the transaction is finished, after firing complete/abort on the transaction, immediately set request's transaction property to null.
    … …  
    8287    LOG(IndexedDB, "IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit()");
    8388
     89    ASSERT(currentThread() == originThreadID());
    8490    ASSERT(hasPendingActivity());
    8591    m_transaction->addRequest(*this);
    … …  
    95101    LOG(IndexedDB, "IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion()");
    96102
     103    ASSERT(currentThread() == originThreadID());
    97104    ASSERT(hasPendingActivity());
    98105
    … …  
    107114bool IDBOpenDBRequest::dispatchEvent(Event& event)
    108115{
     116    ASSERT(currentThread() == originThreadID());
     117
    109118    bool result = IDBRequest::dispatchEvent(event);
    110119
    … …  
    119128    LOG(IndexedDB, "IDBOpenDBRequest::onSuccess()");
    120129
     130    ASSERT(currentThread() == originThreadID());
     131
    121132    setResult(IDBDatabase::create(*scriptExecutionContext(), connectionProxy(), resultData));
    122133    m_isDone = true;
    … …  
    127138void IDBOpenDBRequest::onUpgradeNeeded(const IDBResultData& resultData)
    128139{
     140    ASSERT(currentThread() == originThreadID());
     141
    129142    Ref<IDBDatabase> database = IDBDatabase::create(*scriptExecutionContext(), connectionProxy(), resultData);
    130143    Ref<IDBTransaction> transaction = database->startVersionChangeTransaction(resultData.transactionInfo(), *this);
    … …  
    148161void IDBOpenDBRequest::onDeleteDatabaseSuccess(const IDBResultData& resultData)
    149162{
     163    ASSERT(currentThread() == originThreadID());
     164
    150165    uint64_t oldVersion = resultData.databaseInfo().version();
    151166
    … …  
    161176{
    162177    LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted");
     178
     179    ASSERT(currentThread() == originThreadID());
    163180
    164181    // If an Open request was completed after the page has navigated, leaving this request
    … …  
    200217void IDBOpenDBRequest::requestBlocked(uint64_t oldVersion, uint64_t newVersion)
    201218{
     219    ASSERT(currentThread() == originThreadID());
     220
    202221    LOG(IndexedDB, "IDBOpenDBRequest::requestBlocked");
    203222    enqueueEvent(IDBVersionChangeEvent::create(oldVersion, newVersion, eventNames().blockedEvent));

  • trunk/Source/WebCore/Modules/indexeddb/IDBRequest.cpp

    r199843 r200483  
    120120IDBRequest::~IDBRequest()
    121121{
     122    ASSERT(currentThread() == m_originThreadID);
     123
    122124    if (m_cursorResult)
    123125        m_cursorResult->clearRequest();
    … …  
    126128unsigned short IDBRequest::errorCode(ExceptionCode&) const
    127129{
     130    ASSERT(currentThread() == m_originThreadID);
     131
    128132    return 0;
    129133}
    … …  
    131135RefPtr<DOMError> IDBRequest::error(ExceptionCodeWithMessage& ec) const
    132136{
     137    ASSERT(currentThread() == m_originThreadID);
     138
    133139    if (m_isDone)
    134140        return m_domError;
    … …  
    141147void IDBRequest::setSource(IDBCursor& cursor)
    142148{
     149    ASSERT(currentThread() == m_originThreadID);
    143150    ASSERT(!m_cursorRequestNotifier);
    144151
    … …  
    154161void IDBRequest::setVersionChangeTransaction(IDBTransaction& transaction)
    155162{
     163    ASSERT(currentThread() == m_originThreadID);
    156164    ASSERT(!m_transaction);
    157165    ASSERT(transaction.isVersionChange());
    … …  
    163171RefPtr<WebCore::IDBTransaction> IDBRequest::transaction() const
    164172{
     173    ASSERT(currentThread() == m_originThreadID);
    165174    return m_shouldExposeTransactionToDOM ? m_transaction : nullptr;
    166175}
    … …  
    168177const String& IDBRequest::readyState() const
    169178{
     179    ASSERT(currentThread() == m_originThreadID);
     180
    170181    static NeverDestroyed<String> pendingString(ASCIILiteral("pending"));
    171182    static NeverDestroyed<String> doneString(ASCIILiteral("done"));
    … …  
    175186uint64_t IDBRequest::sourceObjectStoreIdentifier() const
    176187{
     188    ASSERT(currentThread() == m_originThreadID);
     189
    177190    if (m_objectStoreSource)
    178191        return m_objectStoreSource->info().identifier();
    … …  
    184197uint64_t IDBRequest::sourceIndexIdentifier() const
    185198{
     199    ASSERT(currentThread() == m_originThreadID);
     200
    186201    if (!m_indexSource)
    187202        return 0;
    … …  
    191206IndexedDB::IndexRecordType IDBRequest::requestedIndexRecordType() const
    192207{
     208    ASSERT(currentThread() == m_originThreadID);
    193209    ASSERT(m_indexSource);
    194210
    … …  
    198214EventTargetInterface IDBRequest::eventTargetInterface() const
    199215{
     216    ASSERT(currentThread() == m_originThreadID);
     217
    200218    return IDBRequestEventTargetInterfaceType;
    201219}
    … …  
    203221const char* IDBRequest::activeDOMObjectName() const
    204222{
     223    ASSERT(currentThread() == m_originThreadID);
     224
    205225    return "IDBRequest";
    206226}
    … …  
    208228bool IDBRequest::canSuspendForDocumentSuspension() const
    209229{
     230    ASSERT(currentThread() == m_originThreadID);
    210231    return false;
    211232}
    … …  
    213234bool IDBRequest::hasPendingActivity() const
    214235{
     236    ASSERT(currentThread() == m_originThreadID);
    215237    return m_hasPendingActivity;
    216238}
    … …  
    218240void IDBRequest::stop()
    219241{
     242    ASSERT(currentThread() == m_originThreadID);
    220243    ASSERT(!m_contextStopped);
    221244    m_contextStopped = true;
    … …  
    224247void IDBRequest::enqueueEvent(Ref<Event>&& event)
    225248{
     249    ASSERT(currentThread() == m_originThreadID);
    226250    if (!scriptExecutionContext() || m_contextStopped)
    227251        return;
    … …  
    235259    LOG(IndexedDB, "IDBRequest::dispatchEvent - %s (%p)", event.type().string().utf8().data(), this);
    236260
     261    ASSERT(currentThread() == m_originThreadID);
    237262    ASSERT(m_hasPendingActivity);
    238263    ASSERT(!m_contextStopped);
    … …  
    282307    LOG(IndexedDB, "IDBRequest::uncaughtExceptionInEventHandler");
    283308
     309    ASSERT(currentThread() == m_originThreadID);
     310
    284311    if (m_transaction && m_idbError.code() != IDBDatabaseException::AbortError)
    285312        m_transaction->abortDueToFailedRequest(DOMError::create(IDBDatabaseException::getErrorName(IDBDatabaseException::AbortError), ASCIILiteral("IDBTransaction will abort due to uncaught exception in an event handler")));
    … …  
    288315void IDBRequest::setResult(const IDBKeyData& keyData)
    289316{
     317    ASSERT(currentThread() == m_originThreadID);
     318
    290319    auto* context = scriptExecutionContext();
    291320    if (!context)
    … …  
    298327void IDBRequest::setResult(uint64_t number)
    299328{
     329    ASSERT(currentThread() == m_originThreadID);
     330
    300331    auto* context = scriptExecutionContext();
    301332    if (!context)
    … …  
    308339void IDBRequest::setResultToStructuredClone(const IDBValue& value)
    309340{
     341    ASSERT(currentThread() == m_originThreadID);
     342
    310343    LOG(IndexedDB, "IDBRequest::setResultToStructuredClone");
    311344
    … …  
    320353void IDBRequest::clearResult()
    321354{
     355    ASSERT(currentThread() == m_originThreadID);
     356
    322357    m_scriptResult = { };
    323358    m_cursorResult = nullptr;
    … …  
    327362void IDBRequest::setResultToUndefined()
    328363{
     364    ASSERT(currentThread() == m_originThreadID);
     365
    329366    auto* context = scriptExecutionContext();
    330367    if (!context)
    … …  
    337374IDBCursor* IDBRequest::resultCursor()
    338375{
     376    ASSERT(currentThread() == m_originThreadID);
     377
    339378    return m_cursorResult.get();
    340379}
    … …  
    342381void IDBRequest::willIterateCursor(IDBCursor& cursor)
    343382{
     383    ASSERT(currentThread() == m_originThreadID);
    344384    ASSERT(m_isDone);
    345385    ASSERT(scriptExecutionContext());
    … …  
    363403void IDBRequest::didOpenOrIterateCursor(const IDBResultData& resultData)
    364404{
     405    ASSERT(currentThread() == m_originThreadID);
    365406    ASSERT(m_pendingCursor);
    366407
    … …  
    381422void IDBRequest::requestCompleted(const IDBResultData& resultData)
    382423{
     424    ASSERT(currentThread() == m_originThreadID);
     425
    383426    m_isDone = true;
    384427
    … …  
    394437    LOG(IndexedDB, "IDBRequest::onError");
    395438
     439    ASSERT(currentThread() == m_originThreadID);
    396440    ASSERT(!m_idbError.isNull());
     441
    397442    m_domError = DOMError::create(m_idbError.name(), m_idbError.message());
    398443    enqueueEvent(Event::create(eventNames().errorEvent, true, true));
    … …  
    402447{
    403448    LOG(IndexedDB, "IDBRequest::onSuccess");
     449    ASSERT(currentThread() == m_originThreadID);
    404450
    405451    enqueueEvent(Event::create(eventNames().successEvent, false, false));
    … …  
    408454void IDBRequest::setResult(Ref<IDBDatabase>&& database)
    409455{
     456    ASSERT(currentThread() == m_originThreadID);
     457
    410458    clearResult();
    411459    m_databaseResult = WTFMove(database);

  • trunk/Source/WebCore/Modules/indexeddb/IDBRequest.h

    r199843 r200483  
    105105    bool hasPendingActivity() const final;
    106106
     107    ThreadIdentifier originThreadID() const { return m_originThreadID; }
     108
    107109protected:
    108110    IDBRequest(ScriptExecutionContext&, IDBClient::IDBConnectionProxy&);
    … …  
    171173
    172174    Ref<IDBClient::IDBConnectionProxy> m_connectionProxy;
     175
     176    ThreadIdentifier m_originThreadID { currentThread() };
    173177};
    174178

  • trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp

    r200036 r200483  
    132132{
    133133    LOG(IndexedDB, "IDBTransaction::IDBTransaction - %s", m_info.loggingString().utf8().data());
     134    ASSERT(currentThread() == m_database->originThreadID());
    134135
    135136    relaxAdoptionRequirement();
    … …  
    156157IDBTransaction::~IDBTransaction()
    157158{
     159    ASSERT(currentThread() == m_database->originThreadID());
    158160}
    159161
    160162const String& IDBTransaction::mode() const
    161163{
     164    ASSERT(currentThread() == m_database->originThreadID());
     165
    162166    switch (m_info.mode()) {
    163167    case IndexedDB::TransactionMode::ReadOnly:
    … …  
    174178WebCore::IDBDatabase* IDBTransaction::db()
    175179{
     180    ASSERT(currentThread() == m_database->originThreadID());
    176181    return &m_database.get();
    177182}
    … …  
    179184IDBClient::IDBConnectionToServer& IDBTransaction::serverConnection()
    180185{
     186    ASSERT(currentThread() == m_database->originThreadID());
    181187    return m_database->serverConnection();
    182188}
    … …  
    184190RefPtr<DOMError> IDBTransaction::error() const
    185191{
     192    ASSERT(currentThread() == m_database->originThreadID());
    186193    return m_domError;
    187194}
    … …  
    190197{
    191198    LOG(IndexedDB, "IDBTransaction::objectStore");
     199    ASSERT(currentThread() == m_database->originThreadID());
    192200
    193201    if (!scriptExecutionContext())
    … …  
    236244{
    237245    LOG(IndexedDB, "IDBTransaction::abortDueToFailedRequest");
     246    ASSERT(currentThread() == m_database->originThreadID());
     247
    238248    if (isFinishedOrFinishing())
    239249        return;
    … …  
    246256void IDBTransaction::transitionedToFinishing(IndexedDB::TransactionState state)
    247257{
     258    ASSERT(currentThread() == m_database->originThreadID());
     259
    248260    ASSERT(!isFinishedOrFinishing());
    249261    m_state = state;
    … …  
    255267{
    256268    LOG(IndexedDB, "IDBTransaction::abort");
     269    ASSERT(currentThread() == m_database->originThreadID());
    257270
    258271    if (isFinishedOrFinishing()) {
    … …  
    280293{
    281294    LOG(IndexedDB, "IDBTransaction::abortOnServerAndCancelRequests");
    282 
     295    ASSERT(currentThread() == m_database->originThreadID());
    283296    ASSERT(m_transactionOperationQueue.isEmpty());
    284297
    … …  
    298311const char* IDBTransaction::activeDOMObjectName() const
    299312{
     313    ASSERT(currentThread() == m_database->originThreadID());
    300314    return "IDBTransaction";
    301315}
    … …  
    303317bool IDBTransaction::canSuspendForDocumentSuspension() const
    304318{
     319    ASSERT(currentThread() == m_database->originThreadID());
    305320    return false;
    306321}
    … …  
    308323bool IDBTransaction::hasPendingActivity() const
    309324{
     325    ASSERT(currentThread() == m_database->originThreadID());
    310326    return !m_contextStopped && m_state != IndexedDB::TransactionState::Finished;
    311327}
    … …  
    314330{
    315331    LOG(IndexedDB, "IDBTransaction::stop");
     332    ASSERT(currentThread() == m_database->originThreadID());
    316333
    317334    // IDBDatabase::stop() calls IDBTransaction::stop() for each of its active transactions.
    … …  
    331348bool IDBTransaction::isActive() const
    332349{
     350    ASSERT(currentThread() == m_database->originThreadID());
    333351    return m_state == IndexedDB::TransactionState::Active;
    334352}
    … …  
    336354bool IDBTransaction::isFinishedOrFinishing() const
    337355{
     356    ASSERT(currentThread() == m_database->originThreadID());
     357
    338358    return m_state == IndexedDB::TransactionState::Committing
    339359        || m_state == IndexedDB::TransactionState::Aborting
    … …  
    343363void IDBTransaction::addRequest(IDBRequest& request)
    344364{
     365    ASSERT(currentThread() == m_database->originThreadID());
    345366    m_openRequests.add(&request);
    346367}
    … …  
    348369void IDBTransaction::removeRequest(IDBRequest& request)
    349370{
     371    ASSERT(currentThread() == m_database->originThreadID());
    350372    ASSERT(m_openRequests.contains(&request));
    351373    m_openRequests.remove(&request);
    … …  
    355377{
    356378    ASSERT(!m_transactionOperationMap.contains(operation->identifier()));
     379    ASSERT(currentThread() == m_database->originThreadID());
    357380
    358381    m_transactionOperationQueue.append(operation);
    … …  
    364387void IDBTransaction::scheduleOperationTimer()
    365388{
     389    ASSERT(currentThread() == m_database->originThreadID());
     390
    366391    if (!m_operationTimer.isActive())
    367392        m_operationTimer.startOneShot(0);
    … …  
    371396{
    372397    LOG(IndexedDB, "IDBTransaction::operationTimerFired (%p)", this);
     398    ASSERT(currentThread() == m_database->originThreadID());
    373399
    374400    if (!m_startedOnServer)
    … …  
    392418{
    393419    LOG(IndexedDB, "IDBTransaction::commit");
    394 
     420    ASSERT(currentThread() == m_database->originThreadID());
    395421    ASSERT(!isFinishedOrFinishing());
    396422
    … …  
    405431{
    406432    LOG(IndexedDB, "IDBTransaction::commitOnServer");
     433    ASSERT(currentThread() == m_database->originThreadID());
     434
    407435    serverConnection().commitTransaction(*this);
    408436
    … …  
    414442{
    415443    ASSERT(m_state != IndexedDB::TransactionState::Finished);
     444    ASSERT(currentThread() == m_database->originThreadID());
     445
    416446    m_state = IndexedDB::TransactionState::Finished;
    417447}
    … …  
    420450{
    421451    LOG(IndexedDB, "IDBTransaction::didStart");
     452    ASSERT(currentThread() == m_database->originThreadID());
    422453
    423454    m_database->didStartTransaction(*this);
    … …  
    437468void IDBTransaction::notifyDidAbort(const IDBError& error)
    438469{
     470    ASSERT(currentThread() == m_database->originThreadID());
     471
    439472    m_database->didAbortTransaction(*this);
    440473    m_idbError = error;
    … …  
    450483{
    451484    LOG(IndexedDB, "IDBTransaction::didAbort");
     485    ASSERT(currentThread() == m_database->originThreadID());
    452486
    453487    if (m_state == IndexedDB::TransactionState::Finished)
    … …  
    462496{
    463497    LOG(IndexedDB, "IDBTransaction::didCommit");
    464 
     498    ASSERT(currentThread() == m_database->originThreadID());
    465499    ASSERT(m_state == IndexedDB::TransactionState::Committing);
    466500
    … …  
    479513{
    480514    LOG(IndexedDB, "IDBTransaction::fireOnComplete");
     515    ASSERT(currentThread() == m_database->originThreadID());
    481516    enqueueEvent(Event::create(eventNames().completeEvent, false, false));
    482517}
    … …  
    485520{
    486521    LOG(IndexedDB, "IDBTransaction::fireOnAbort");
     522    ASSERT(currentThread() == m_database->originThreadID());
    487523    enqueueEvent(Event::create(eventNames().abortEvent, true, false));
    488524}
    … …  
    491527{
    492528    ASSERT(m_state != IndexedDB::TransactionState::Finished);
     529    ASSERT(currentThread() == m_database->originThreadID());
    493530
    494531    if (!scriptExecutionContext() || m_contextStopped)
    … …  
    503540    LOG(IndexedDB, "IDBTransaction::dispatchEvent");
    504541
     542    ASSERT(currentThread() == m_database->originThreadID());
    505543    ASSERT(scriptExecutionContext());
    506544    ASSERT(!m_contextStopped);
    … …  
    536574    ASSERT(isVersionChange());
    537575    ASSERT(scriptExecutionContext());
     576    ASSERT(currentThread() == m_database->originThreadID());
    538577
    539578    Ref<IDBObjectStore> objectStore = IDBObjectStore::create(*scriptExecutionContext(), info, *this);
    … …  
    549588{
    550589    LOG(IndexedDB, "IDBTransaction::createObjectStoreOnServer");
    551 
     590    ASSERT(currentThread() == m_database->originThreadID());
    552591    ASSERT(isVersionChange());
    553592
    … …  
    558597{
    559598    LOG(IndexedDB, "IDBTransaction::didCreateObjectStoreOnServer");
    560 
     599    ASSERT(currentThread() == m_database->originThreadID());
    561600    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::CreateObjectStoreSuccess || resultData.type() == IDBResultType::Error);
    562601}
    … …  
    566605    LOG(IndexedDB, "IDBTransaction::createIndex");
    567606    ASSERT(isVersionChange());
     607    ASSERT(currentThread() == m_database->originThreadID());
    568608
    569609    if (!scriptExecutionContext())
    … …  
    579619{
    580620    LOG(IndexedDB, "IDBTransaction::createIndexOnServer");
    581 
     621    ASSERT(currentThread() == m_database->originThreadID());
    582622    ASSERT(isVersionChange());
    583623
    … …  
    588628{
    589629    LOG(IndexedDB, "IDBTransaction::didCreateIndexOnServer");
     630    ASSERT(currentThread() == m_database->originThreadID());
    590631
    591632    if (resultData.type() == IDBResultType::CreateIndexSuccess)
    … …  
    605646{
    606647    LOG(IndexedDB, "IDBTransaction::requestOpenCursor");
     648    ASSERT(currentThread() == m_database->originThreadID());
    607649
    608650    return doRequestOpenCursor(context, IDBCursorWithValue::create(*this, objectStore, info));
    … …  
    612654{
    613655    LOG(IndexedDB, "IDBTransaction::requestOpenCursor");
     656    ASSERT(currentThread() == m_database->originThreadID());
    614657
    615658    if (info.cursorType() == IndexedDB::CursorType::KeyOnly)
    … …  
    622665{
    623666    ASSERT(isActive());
     667    ASSERT(currentThread() == m_database->originThreadID());
    624668
    625669    Ref<IDBRequest> request = IDBRequest::create(context, cursor.get(), *this);
    … …  
    635679{
    636680    LOG(IndexedDB, "IDBTransaction::openCursorOnServer");
     681    ASSERT(currentThread() == m_database->originThreadID());
    637682
    638683    m_database->serverConnection().openCursor(operation, info);
    … …  
    642687{
    643688    LOG(IndexedDB, "IDBTransaction::didOpenCursorOnServer");
     689    ASSERT(currentThread() == m_database->originThreadID());
    644690
    645691    request.didOpenOrIterateCursor(resultData);
    … …  
    651697    ASSERT(isActive());
    652698    ASSERT(cursor.request());
     699    ASSERT(currentThread() == m_database->originThreadID());
    653700
    654701    addRequest(*cursor.request());
    … …  
    661708{
    662709    LOG(IndexedDB, "IDBTransaction::iterateCursorOnServer");
     710    ASSERT(currentThread() == m_database->originThreadID());
    663711
    664712    serverConnection().iterateCursor(operation, key, count);
    … …  
    668716{
    669717    LOG(IndexedDB, "IDBTransaction::didIterateCursorOnServer");
     718    ASSERT(currentThread() == m_database->originThreadID());
    670719
    671720    request.didOpenOrIterateCursor(resultData);
    … …  
    677726    ASSERT(isActive());
    678727    ASSERT(!keyRangeData.isNull);
     728    ASSERT(currentThread() == m_database->originThreadID());
    679729
    680730    Ref<IDBRequest> request = IDBRequest::create(context, objectStore, *this);
    … …  
    690740{
    691741    LOG(IndexedDB, "IDBTransaction::requestGetValue");
     742    ASSERT(currentThread() == m_database->originThreadID());
     743
    692744    return requestIndexRecord(context, index, IndexedDB::IndexRecordType::Value, range);
    693745}
    … …  
    696748{
    697749    LOG(IndexedDB, "IDBTransaction::requestGetValue");
     750    ASSERT(currentThread() == m_database->originThreadID());
     751
    698752    return requestIndexRecord(context, index, IndexedDB::IndexRecordType::Key, range);
    699753}
    … …  
    704758    ASSERT(isActive());
    705759    ASSERT(!range.isNull);
     760    ASSERT(currentThread() == m_database->originThreadID());
    706761
    707762    Ref<IDBRequest> request = IDBRequest::createGet(context, index, type, *this);
    … …  
    717772{
    718773    LOG(IndexedDB, "IDBTransaction::getRecordOnServer");
     774    ASSERT(currentThread() == m_database->originThreadID());
    719775
    720776    serverConnection().getRecord(operation, keyRange);
    … …  
    724780{
    725781    LOG(IndexedDB, "IDBTransaction::didGetRecordOnServer");
     782    ASSERT(currentThread() == m_database->originThreadID());
    726783
    727784    if (resultData.type() == IDBResultType::Error) {
    … …  
    754811    ASSERT(isActive());
    755812    ASSERT(!range.isNull);
     813    ASSERT(currentThread() == m_database->originThreadID());
    756814
    757815    Ref<IDBRequest> request = IDBRequest::create(context, objectStore, *this);
    … …  
    768826    ASSERT(isActive());
    769827    ASSERT(!range.isNull);
     828    ASSERT(currentThread() == m_database->originThreadID());
    770829
    771830    Ref<IDBRequest> request = IDBRequest::createCount(context, index, *this);
    … …  
    780839{
    781840    LOG(IndexedDB, "IDBTransaction::getCountOnServer");
     841    ASSERT(currentThread() == m_database->originThreadID());
    782842
    783843    serverConnection().getCount(operation, keyRange);
    … …  
    787847{
    788848    LOG(IndexedDB, "IDBTransaction::didGetCountOnServer");
     849    ASSERT(currentThread() == m_database->originThreadID());
    789850
    790851    request.setResult(resultData.resultInteger());
    … …  
    797858    ASSERT(isActive());
    798859    ASSERT(!range.isNull);
     860    ASSERT(currentThread() == m_database->originThreadID());
    799861
    800862    Ref<IDBRequest> request = IDBRequest::create(context, objectStore, *this);
    … …  
    808870{
    809871    LOG(IndexedDB, "IDBTransaction::deleteRecordOnServer");
     872    ASSERT(currentThread() == m_database->originThreadID());
    810873
    811874    serverConnection().deleteRecord(operation, keyRange);
    … …  
    815878{
    816879    LOG(IndexedDB, "IDBTransaction::didDeleteRecordOnServer");
     880    ASSERT(currentThread() == m_database->originThreadID());
    817881
    818882    request.setResultToUndefined();
    … …  
    824888    LOG(IndexedDB, "IDBTransaction::requestClearObjectStore");
    825889    ASSERT(isActive());
     890    ASSERT(currentThread() == m_database->originThreadID());
    826891
    827892    Ref<IDBRequest> request = IDBRequest::create(context, objectStore, *this);
    … …  
    838903{
    839904    LOG(IndexedDB, "IDBTransaction::clearObjectStoreOnServer");
     905    ASSERT(currentThread() == m_database->originThreadID());
    840906
    841907    serverConnection().clearObjectStore(operation, objectStoreIdentifier);
    … …  
    845911{
    846912    LOG(IndexedDB, "IDBTransaction::didClearObjectStoreOnServer");
     913    ASSERT(currentThread() == m_database->originThreadID());
    847914
    848915    request.setResultToUndefined();
    … …  
    856923    ASSERT(!isReadOnly());
    857924    ASSERT(objectStore.info().autoIncrement() || key);
     925    ASSERT(currentThread() == m_database->originThreadID());
    858926
    859927    Ref<IDBRequest> request = IDBRequest::create(context, objectStore, *this);
    … …  
    869937{
    870938    LOG(IndexedDB, "IDBTransaction::putOrAddOnServer");
    871 
     939    ASSERT(currentThread() == m_database->originThreadID());
    872940    ASSERT(!isReadOnly());
    873941    ASSERT(value);
    … …  
    898966{
    899967    LOG(IndexedDB, "IDBTransaction::didPutOrAddOnServer");
     968    ASSERT(currentThread() == m_database->originThreadID());
    900969
    901970    if (auto* result = resultData.resultKey())
    … …  
    909978{
    910979    LOG(IndexedDB, "IDBTransaction::deleteObjectStore");
    911 
     980    ASSERT(currentThread() == m_database->originThreadID());
    912981    ASSERT(isVersionChange());
    913982
    … …  
    923992    LOG(IndexedDB, "IDBTransaction::deleteObjectStoreOnServer");
    924993    ASSERT(isVersionChange());
     994    ASSERT(currentThread() == m_database->originThreadID());
    925995
    926996    serverConnection().deleteObjectStore(operation, objectStoreName);
    … …  
    9301000{
    9311001    LOG(IndexedDB, "IDBTransaction::didDeleteObjectStoreOnServer");
     1002    ASSERT(currentThread() == m_database->originThreadID());
    9321003    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::DeleteObjectStoreSuccess || resultData.type() == IDBResultType::Error);
    9331004}
    … …  
    9361007{
    9371008    LOG(IndexedDB, "IDBTransaction::deleteIndex");
    938 
     1009    ASSERT(currentThread() == m_database->originThreadID());
    9391010    ASSERT(isVersionChange());
    9401011
    … …  
    9471018    LOG(IndexedDB, "IDBTransaction::deleteIndexOnServer");
    9481019    ASSERT(isVersionChange());
     1020    ASSERT(currentThread() == m_database->originThreadID());
    9491021
    9501022    serverConnection().deleteIndex(operation, objectStoreIdentifier, indexName);
    … …  
    9541026{
    9551027    LOG(IndexedDB, "IDBTransaction::didDeleteIndexOnServer");
     1028    ASSERT(currentThread() == m_database->originThreadID());
    9561029    ASSERT_UNUSED(resultData, resultData.type() == IDBResultType::DeleteIndexSuccess || resultData.type() == IDBResultType::Error);
    9571030}
    … …  
    9601033{
    9611034    ASSERT(m_transactionOperationMap.get(operation.identifier()) == &operation);
     1035    ASSERT(currentThread() == m_database->originThreadID());
     1036
    9621037    m_transactionOperationMap.remove(operation.identifier());
    9631038
    … …  
    9681043{
    9691044    LOG(IndexedDB, "IDBTransaction::establishOnServer");
     1045    ASSERT(currentThread() == m_database->originThreadID());
    9701046
    9711047    serverConnection().establishTransaction(*this);
    … …  
    9741050void IDBTransaction::activate()
    9751051{
     1052    ASSERT(currentThread() == m_database->originThreadID());
     1053
    9761054    if (isFinishedOrFinishing())
    9771055        return;
    … …  
    9821060void IDBTransaction::deactivate()
    9831061{
     1062    ASSERT(currentThread() == m_database->originThreadID());
     1063
    9841064    if (m_state == IndexedDB::TransactionState::Active)
    9851065        m_state = IndexedDB::TransactionState::Inactive;
Note: See TracChangeset for help on using the changeset viewer.