Changeset 164255 in webkit


Ignore:
Timestamp:
Feb 17, 2014 4:08:02 PM (10 years ago)
Author:
andersca@apple.com
Message:

Stop using isMainThread() in WebKit2
​https://bugs.webkit.org/show_bug.cgi?id=128940
<rdar://problem/15963666>

Reviewed by Enrica Casucci.

Since isMainThread() has a different meaning when the web thread is enabled on iOS,
just use RunLoop::isMain() to check if we're executing on the main thread.

  • DatabaseProcess/DatabaseProcess.cpp:

(WebKit::DatabaseProcess::ensurePathExists):
(WebKit::DatabaseProcess::postDatabaseTask):
(WebKit::DatabaseProcess::performNextDatabaseTask):

  • DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp:

(WebKit::UniqueIDBDatabase::shutdown):
(WebKit::UniqueIDBDatabase::shutdownBackingStore):
(WebKit::UniqueIDBDatabase::didShutdownBackingStore):
(WebKit::UniqueIDBDatabase::deleteDatabase):
(WebKit::UniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata):
(WebKit::UniqueIDBDatabase::openBackingStoreAndReadMetadata):
(WebKit::UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata):
(WebKit::UniqueIDBDatabase::postTransactionOperation):
(WebKit::UniqueIDBDatabase::didCompleteTransactionOperation):
(WebKit::UniqueIDBDatabase::changeDatabaseVersion):
(WebKit::UniqueIDBDatabase::createObjectStore):
(WebKit::UniqueIDBDatabase::deleteObjectStore):
(WebKit::UniqueIDBDatabase::clearObjectStore):
(WebKit::UniqueIDBDatabase::createIndex):
(WebKit::UniqueIDBDatabase::deleteIndex):
(WebKit::UniqueIDBDatabase::putRecord):
(WebKit::UniqueIDBDatabase::getRecord):
(WebKit::UniqueIDBDatabase::openCursor):
(WebKit::UniqueIDBDatabase::cursorAdvance):
(WebKit::UniqueIDBDatabase::cursorIterate):
(WebKit::UniqueIDBDatabase::count):
(WebKit::UniqueIDBDatabase::deleteRange):
(WebKit::UniqueIDBDatabase::openBackingStoreTransaction):
(WebKit::UniqueIDBDatabase::beginBackingStoreTransaction):
(WebKit::UniqueIDBDatabase::commitBackingStoreTransaction):
(WebKit::UniqueIDBDatabase::resetBackingStoreTransaction):
(WebKit::UniqueIDBDatabase::rollbackBackingStoreTransaction):
(WebKit::UniqueIDBDatabase::changeDatabaseVersionInBackingStore):
(WebKit::UniqueIDBDatabase::createObjectStoreInBackingStore):
(WebKit::UniqueIDBDatabase::deleteObjectStoreInBackingStore):
(WebKit::UniqueIDBDatabase::clearObjectStoreInBackingStore):
(WebKit::UniqueIDBDatabase::createIndexInBackingStore):
(WebKit::UniqueIDBDatabase::deleteIndexInBackingStore):
(WebKit::UniqueIDBDatabase::putRecordInBackingStore):
(WebKit::UniqueIDBDatabase::getRecordFromBackingStore):
(WebKit::UniqueIDBDatabase::openCursorInBackingStore):
(WebKit::UniqueIDBDatabase::absoluteDatabaseDirectory):
(WebKit::UniqueIDBDatabase::postMainThreadTask):
(WebKit::UniqueIDBDatabase::performNextMainThreadTask):
(WebKit::UniqueIDBDatabase::postDatabaseTask):
(WebKit::UniqueIDBDatabase::performNextDatabaseTask):

  • DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:

(WebKit::generateDatabaseId):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::~UniqueIDBDatabaseBackingStoreSQLite):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::createAndPopulateInitialMetadata):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::extractExistingMetadata):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::openSQLiteDatabaseAtPath):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::establishTransaction):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::beginTransaction):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::commitTransaction):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::resetTransaction):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::rollbackTransaction):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::changeDatabaseVersion):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::createObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::clearObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::createIndex):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteIndex):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::generateKeyNumber):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::updateKeyGeneratorNumber):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::keyExistsInObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::putRecord):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::putIndexRecord):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getIndexRecord):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteRecord):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteRange):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRecordFromObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRangeRecordFromObjectStore):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::count):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::openCursor):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::advanceCursor):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::iterateCursor):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::notifyCursorsOfChanges):

  • NetworkProcess/FileAPI/NetworkBlobRegistry.cpp:

(WebKit::NetworkBlobRegistry::shared):

  • NetworkProcess/HostRecord.cpp:

(WebKit::HostRecord::scheduleResourceLoader):
(WebKit::HostRecord::addLoaderInProgress):
(WebKit::HostRecord::removeLoader):

  • NetworkProcess/NetworkResourceLoadScheduler.cpp:

(WebKit::NetworkResourceLoadScheduler::removeLoader):
(WebKit::NetworkResourceLoadScheduler::receivedRedirect):
(WebKit::NetworkResourceLoadScheduler::removeScheduledLoaders):

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::NetworkResourceLoader):
(WebKit::NetworkResourceLoader::~NetworkResourceLoader):
(WebKit::NetworkResourceLoader::start):
(WebKit::NetworkResourceLoader::cleanup):
(WebKit::NetworkResourceLoader::abort):
(WebKit::NetworkResourceLoader::willSendRequestAsync):
(WebKit::NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync):

  • NetworkProcess/NetworkResourceLoader.h:

(WebKit::NetworkResourceLoader::setHostRecord):
(WebKit::NetworkResourceLoader::hostRecord):

  • NetworkProcess/mac/DiskCacheMonitor.mm:

(WebKit::DiskCacheMonitor::DiskCacheMonitor):

  • Shared/AsyncRequest.cpp:

(WebKit::generateRequestID):

  • Shared/Authentication/AuthenticationManager.cpp:

(WebKit::generateAuthenticationChallengeID):
(WebKit::AuthenticationManager::establishIdentifierForChallenge):
(WebKit::AuthenticationManager::useCredentialForChallenge):
(WebKit::AuthenticationManager::continueWithoutCredentialForChallenge):
(WebKit::AuthenticationManager::cancelChallenge):

  • Shared/Downloads/mac/DownloadMac.mm:

(dispatchOnMainThread):

  • Shared/Plugins/NPObjectProxy.cpp:

(WebKit::NPObjectProxy::~NPObjectProxy):

  • Shared/Plugins/Netscape/mac/NetscapePluginModuleMac.mm:

(WebKit::getPluginInfoFromCarbonResources):

  • Shared/SessionTracker.cpp:

(WebKit::staticSessionMap):
(WebKit::storageSessionToID):
(WebKit::identifierBase):
(WebKit::SessionTracker::destroySession):
(WebKit::SessionTracker::setIdentifierBase):

  • UIProcess/APISession.cpp:

(API::generateID):
(API::Session::defaultSession):
(API::Session::legacyPrivateSession):

  • WebProcess/Cookies/WebCookieManager.cpp:

(WebKit::WebCookieManager::dispatchCookiesDidChange):

  • WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.cpp:

(WebKit::WebIDBFactoryBackend::open):
(WebKit::WebIDBFactoryBackend::deleteDatabase):

  • WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp:

(WebKit::generateServerConnectionIdentifier):

  • WebProcess/WebCoreSupport/mac/WebFrameNetworkingContext.mm:

(WebKit::WebFrameNetworkingContext::storageSession):

  • WebProcess/WebPage/EventDispatcher.cpp:

(WebKit::EventDispatcher::dispatchWheelEvent):

Location:
trunk/Source/WebKit2
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r164254 r164255  
     12014-02-17  Anders Carlsson  <andersca@apple.com>
     2
     3        Stop using isMainThread() in WebKit2
     4        https://bugs.webkit.org/show_bug.cgi?id=128940
     5        <rdar://problem/15963666>
     6
     7        Reviewed by Enrica Casucci.
     8
     9        Since isMainThread() has a different meaning when the web thread is enabled on iOS,
     10        just use RunLoop::isMain() to check if we're executing on the main thread.
     11
     12        * DatabaseProcess/DatabaseProcess.cpp:
     13        (WebKit::DatabaseProcess::ensurePathExists):
     14        (WebKit::DatabaseProcess::postDatabaseTask):
     15        (WebKit::DatabaseProcess::performNextDatabaseTask):
     16        * DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp:
     17        (WebKit::UniqueIDBDatabase::shutdown):
     18        (WebKit::UniqueIDBDatabase::shutdownBackingStore):
     19        (WebKit::UniqueIDBDatabase::didShutdownBackingStore):
     20        (WebKit::UniqueIDBDatabase::deleteDatabase):
     21        (WebKit::UniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata):
     22        (WebKit::UniqueIDBDatabase::openBackingStoreAndReadMetadata):
     23        (WebKit::UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata):
     24        (WebKit::UniqueIDBDatabase::postTransactionOperation):
     25        (WebKit::UniqueIDBDatabase::didCompleteTransactionOperation):
     26        (WebKit::UniqueIDBDatabase::changeDatabaseVersion):
     27        (WebKit::UniqueIDBDatabase::createObjectStore):
     28        (WebKit::UniqueIDBDatabase::deleteObjectStore):
     29        (WebKit::UniqueIDBDatabase::clearObjectStore):
     30        (WebKit::UniqueIDBDatabase::createIndex):
     31        (WebKit::UniqueIDBDatabase::deleteIndex):
     32        (WebKit::UniqueIDBDatabase::putRecord):
     33        (WebKit::UniqueIDBDatabase::getRecord):
     34        (WebKit::UniqueIDBDatabase::openCursor):
     35        (WebKit::UniqueIDBDatabase::cursorAdvance):
     36        (WebKit::UniqueIDBDatabase::cursorIterate):
     37        (WebKit::UniqueIDBDatabase::count):
     38        (WebKit::UniqueIDBDatabase::deleteRange):
     39        (WebKit::UniqueIDBDatabase::openBackingStoreTransaction):
     40        (WebKit::UniqueIDBDatabase::beginBackingStoreTransaction):
     41        (WebKit::UniqueIDBDatabase::commitBackingStoreTransaction):
     42        (WebKit::UniqueIDBDatabase::resetBackingStoreTransaction):
     43        (WebKit::UniqueIDBDatabase::rollbackBackingStoreTransaction):
     44        (WebKit::UniqueIDBDatabase::changeDatabaseVersionInBackingStore):
     45        (WebKit::UniqueIDBDatabase::createObjectStoreInBackingStore):
     46        (WebKit::UniqueIDBDatabase::deleteObjectStoreInBackingStore):
     47        (WebKit::UniqueIDBDatabase::clearObjectStoreInBackingStore):
     48        (WebKit::UniqueIDBDatabase::createIndexInBackingStore):
     49        (WebKit::UniqueIDBDatabase::deleteIndexInBackingStore):
     50        (WebKit::UniqueIDBDatabase::putRecordInBackingStore):
     51        (WebKit::UniqueIDBDatabase::getRecordFromBackingStore):
     52        (WebKit::UniqueIDBDatabase::openCursorInBackingStore):
     53        (WebKit::UniqueIDBDatabase::absoluteDatabaseDirectory):
     54        (WebKit::UniqueIDBDatabase::postMainThreadTask):
     55        (WebKit::UniqueIDBDatabase::performNextMainThreadTask):
     56        (WebKit::UniqueIDBDatabase::postDatabaseTask):
     57        (WebKit::UniqueIDBDatabase::performNextDatabaseTask):
     58        * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
     59        (WebKit::generateDatabaseId):
     60        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite):
     61        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::~UniqueIDBDatabaseBackingStoreSQLite):
     62        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::createAndPopulateInitialMetadata):
     63        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::extractExistingMetadata):
     64        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::openSQLiteDatabaseAtPath):
     65        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata):
     66        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::establishTransaction):
     67        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::beginTransaction):
     68        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::commitTransaction):
     69        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::resetTransaction):
     70        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::rollbackTransaction):
     71        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::changeDatabaseVersion):
     72        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::createObjectStore):
     73        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore):
     74        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::clearObjectStore):
     75        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::createIndex):
     76        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteIndex):
     77        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::generateKeyNumber):
     78        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::updateKeyGeneratorNumber):
     79        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::keyExistsInObjectStore):
     80        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::putRecord):
     81        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::putIndexRecord):
     82        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getIndexRecord):
     83        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteRecord):
     84        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::deleteRange):
     85        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRecordFromObjectStore):
     86        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getKeyRangeRecordFromObjectStore):
     87        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::count):
     88        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::openCursor):
     89        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::advanceCursor):
     90        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::iterateCursor):
     91        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::notifyCursorsOfChanges):
     92        * NetworkProcess/FileAPI/NetworkBlobRegistry.cpp:
     93        (WebKit::NetworkBlobRegistry::shared):
     94        * NetworkProcess/HostRecord.cpp:
     95        (WebKit::HostRecord::scheduleResourceLoader):
     96        (WebKit::HostRecord::addLoaderInProgress):
     97        (WebKit::HostRecord::removeLoader):
     98        * NetworkProcess/NetworkResourceLoadScheduler.cpp:
     99        (WebKit::NetworkResourceLoadScheduler::removeLoader):
     100        (WebKit::NetworkResourceLoadScheduler::receivedRedirect):
     101        (WebKit::NetworkResourceLoadScheduler::removeScheduledLoaders):
     102        * NetworkProcess/NetworkResourceLoader.cpp:
     103        (WebKit::NetworkResourceLoader::NetworkResourceLoader):
     104        (WebKit::NetworkResourceLoader::~NetworkResourceLoader):
     105        (WebKit::NetworkResourceLoader::start):
     106        (WebKit::NetworkResourceLoader::cleanup):
     107        (WebKit::NetworkResourceLoader::abort):
     108        (WebKit::NetworkResourceLoader::willSendRequestAsync):
     109        (WebKit::NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync):
     110        * NetworkProcess/NetworkResourceLoader.h:
     111        (WebKit::NetworkResourceLoader::setHostRecord):
     112        (WebKit::NetworkResourceLoader::hostRecord):
     113        * NetworkProcess/mac/DiskCacheMonitor.mm:
     114        (WebKit::DiskCacheMonitor::DiskCacheMonitor):
     115        * Shared/AsyncRequest.cpp:
     116        (WebKit::generateRequestID):
     117        * Shared/Authentication/AuthenticationManager.cpp:
     118        (WebKit::generateAuthenticationChallengeID):
     119        (WebKit::AuthenticationManager::establishIdentifierForChallenge):
     120        (WebKit::AuthenticationManager::useCredentialForChallenge):
     121        (WebKit::AuthenticationManager::continueWithoutCredentialForChallenge):
     122        (WebKit::AuthenticationManager::cancelChallenge):
     123        * Shared/Downloads/mac/DownloadMac.mm:
     124        (dispatchOnMainThread):
     125        * Shared/Plugins/NPObjectProxy.cpp:
     126        (WebKit::NPObjectProxy::~NPObjectProxy):
     127        * Shared/Plugins/Netscape/mac/NetscapePluginModuleMac.mm:
     128        (WebKit::getPluginInfoFromCarbonResources):
     129        * Shared/SessionTracker.cpp:
     130        (WebKit::staticSessionMap):
     131        (WebKit::storageSessionToID):
     132        (WebKit::identifierBase):
     133        (WebKit::SessionTracker::destroySession):
     134        (WebKit::SessionTracker::setIdentifierBase):
     135        * UIProcess/APISession.cpp:
     136        (API::generateID):
     137        (API::Session::defaultSession):
     138        (API::Session::legacyPrivateSession):
     139        * WebProcess/Cookies/WebCookieManager.cpp:
     140        (WebKit::WebCookieManager::dispatchCookiesDidChange):
     141        * WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.cpp:
     142        (WebKit::WebIDBFactoryBackend::open):
     143        (WebKit::WebIDBFactoryBackend::deleteDatabase):
     144        * WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp:
     145        (WebKit::generateServerConnectionIdentifier):
     146        * WebProcess/WebCoreSupport/mac/WebFrameNetworkingContext.mm:
     147        (WebKit::WebFrameNetworkingContext::storageSession):
     148        * WebProcess/WebPage/EventDispatcher.cpp:
     149        (WebKit::EventDispatcher::dispatchWheelEvent):
     150
    11512014-02-17  Anders Carlsson  <andersca@apple.com>
    2152

  • trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp

    r163961 r164255  
    110110void DatabaseProcess::ensurePathExists(const String& path)
    111111{
    112     ASSERT(!isMainThread());
     112    ASSERT(!RunLoop::isMain());
    113113
    114114    if (!makeAllDirectories(path))
    … …  
    125125void DatabaseProcess::postDatabaseTask(std::unique_ptr<AsyncTask> task)
    126126{
    127     ASSERT(isMainThread());
     127    ASSERT(RunLoop::isMain());
    128128
    129129    MutexLocker locker(m_databaseTaskMutex);
    … …  
    136136void DatabaseProcess::performNextDatabaseTask()
    137137{
    138     ASSERT(!isMainThread());
     138    ASSERT(!RunLoop::isMain());
    139139
    140140    std::unique_ptr<AsyncTask> task;

  • trunk/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp

    r163877 r164255  
    120120void UniqueIDBDatabase::shutdown(UniqueIDBDatabaseShutdownType type)
    121121{
    122     ASSERT(isMainThread());
     122    ASSERT(RunLoop::isMain());
    123123
    124124    if (!m_acceptingNewRequests)
    … …  
    140140void UniqueIDBDatabase::shutdownBackingStore(UniqueIDBDatabaseShutdownType type, const String& databaseDirectory)
    141141{
    142     ASSERT(!isMainThread());
     142    ASSERT(!RunLoop::isMain());
    143143
    144144    m_backingStore.clear();
    … …  
    156156void UniqueIDBDatabase::didShutdownBackingStore(UniqueIDBDatabaseShutdownType type)
    157157{
    158     ASSERT(isMainThread());
     158    ASSERT(RunLoop::isMain());
    159159
    160160    // Balanced by a ref in ::shutdown()
    … …  
    185185void UniqueIDBDatabase::deleteDatabase(std::function<void(bool)> successCallback)
    186186{
    187     ASSERT(isMainThread());
     187    ASSERT(RunLoop::isMain());
    188188
    189189    if (!m_acceptingNewRequests) {
    … …  
    209209void UniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata(std::function<void(bool, const IDBDatabaseMetadata&)> completionCallback)
    210210{
    211     ASSERT(isMainThread());
     211    ASSERT(RunLoop::isMain());
    212212
    213213    if (!m_acceptingNewRequests) {
    … …  
    248248void UniqueIDBDatabase::openBackingStoreAndReadMetadata(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
    249249{
    250     ASSERT(!isMainThread());
     250    ASSERT(!RunLoop::isMain());
    251251    ASSERT(!m_backingStore);
    252252
    … …  
    264264void UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata(const IDBDatabaseMetadata& metadata, bool success)
    265265{
    266     ASSERT(isMainThread());
     266    ASSERT(RunLoop::isMain());
    267267    ASSERT(!m_metadata);
    268268
    … …  
    305305void UniqueIDBDatabase::postTransactionOperation(const IDBIdentifier& transactionIdentifier, std::unique_ptr<AsyncTask> task, std::function<void(bool)> successCallback)
    306306{
    307     ASSERT(isMainThread());
     307    ASSERT(RunLoop::isMain());
    308308
    309309    if (!m_acceptingNewRequests) {
    … …  
    331331void UniqueIDBDatabase::didCompleteTransactionOperation(const IDBIdentifier& transactionIdentifier, bool success)
    332332{
    333     ASSERT(isMainThread());
     333    ASSERT(RunLoop::isMain());
    334334
    335335    RefPtr<AsyncRequest> request = m_pendingTransactionRequests.take(transactionIdentifier);
    … …  
    342342void UniqueIDBDatabase::changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion, std::function<void(bool)> successCallback)
    343343{
    344     ASSERT(isMainThread());
     344    ASSERT(RunLoop::isMain());
    345345
    346346    if (!m_acceptingNewRequests) {
    … …  
    407407void UniqueIDBDatabase::createObjectStore(const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata, std::function<void(bool)> successCallback)
    408408{
    409     ASSERT(isMainThread());
     409    ASSERT(RunLoop::isMain());
    410410
    411411    if (!m_acceptingNewRequests) {
    … …  
    435435void UniqueIDBDatabase::deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void(bool)> successCallback)
    436436{
    437     ASSERT(isMainThread());
     437    ASSERT(RunLoop::isMain());
    438438
    439439    if (!m_acceptingNewRequests) {
    … …  
    462462void UniqueIDBDatabase::clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void(bool)> successCallback)
    463463{
    464     ASSERT(isMainThread());
     464    ASSERT(RunLoop::isMain());
    465465
    466466    if (!m_acceptingNewRequests) {
    … …  
    485485void UniqueIDBDatabase::createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata, std::function<void(bool)> successCallback)
    486486{
    487     ASSERT(isMainThread());
     487    ASSERT(RunLoop::isMain());
    488488
    489489    if (!m_acceptingNewRequests) {
    … …  
    519519void UniqueIDBDatabase::deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, std::function<void(bool)> successCallback)
    520520{
    521     ASSERT(isMainThread());
     521    ASSERT(RunLoop::isMain());
    522522
    523523    if (!m_acceptingNewRequests) {
    … …  
    553553void UniqueIDBDatabase::putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyData& keyData, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys, std::function<void(const IDBKeyData&, uint32_t, const String&)> callback)
    554554{
    555     ASSERT(isMainThread());
     555    ASSERT(RunLoop::isMain());
    556556
    557557    if (!m_acceptingNewRequests) {
    … …  
    576576void UniqueIDBDatabase::getRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType, std::function<void(const IDBGetResult&, uint32_t, const String&)> callback)
    577577{
    578     ASSERT(isMainThread());
     578    ASSERT(RunLoop::isMain());
    579579
    580580    if (!m_acceptingNewRequests) {
    … …  
    599599void UniqueIDBDatabase::openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRangeData, std::function<void(int64_t, const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
    600600{
    601     ASSERT(isMainThread());
     601    ASSERT(RunLoop::isMain());
    602602
    603603    if (!m_acceptingNewRequests) {
    … …  
    622622void UniqueIDBDatabase::cursorAdvance(const IDBIdentifier& cursorIdentifier, uint64_t count, std::function<void(const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
    623623{
    624     ASSERT(isMainThread());
     624    ASSERT(RunLoop::isMain());
    625625
    626626    if (!m_acceptingNewRequests) {
    … …  
    643643void UniqueIDBDatabase::cursorIterate(const IDBIdentifier& cursorIdentifier, const IDBKeyData& key, std::function<void(const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
    644644{
    645     ASSERT(isMainThread());
     645    ASSERT(RunLoop::isMain());
    646646
    647647    if (!m_acceptingNewRequests) {
    … …  
    664664void UniqueIDBDatabase::count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, std::function<void(int64_t, uint32_t, const String&)> callback)
    665665{
    666     ASSERT(isMainThread());
     666    ASSERT(RunLoop::isMain());
    667667
    668668    if (!m_acceptingNewRequests) {
    … …  
    685685void UniqueIDBDatabase::deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData, std::function<void(uint32_t, const String&)> callback)
    686686{
    687     ASSERT(isMainThread());
     687    ASSERT(RunLoop::isMain());
    688688
    689689    if (!m_acceptingNewRequests) {
    … …  
    706706void UniqueIDBDatabase::openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode)
    707707{
    708     ASSERT(!isMainThread());
     708    ASSERT(!RunLoop::isMain());
    709709    ASSERT(m_backingStore);
    710710
    … …  
    716716void UniqueIDBDatabase::beginBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
    717717{
    718     ASSERT(!isMainThread());
     718    ASSERT(!RunLoop::isMain());
    719719    ASSERT(m_backingStore);
    720720
    … …  
    726726void UniqueIDBDatabase::commitBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
    727727{
    728     ASSERT(!isMainThread());
     728    ASSERT(!RunLoop::isMain());
    729729    ASSERT(m_backingStore);
    730730
    … …  
    736736void UniqueIDBDatabase::resetBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
    737737{
    738     ASSERT(!isMainThread());
     738    ASSERT(!RunLoop::isMain());
    739739    ASSERT(m_backingStore);
    740740
    … …  
    746746void UniqueIDBDatabase::rollbackBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
    747747{
    748     ASSERT(!isMainThread());
     748    ASSERT(!RunLoop::isMain());
    749749    ASSERT(m_backingStore);
    750750
    … …  
    756756void UniqueIDBDatabase::changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, uint64_t newVersion)
    757757{
    758     ASSERT(!isMainThread());
     758    ASSERT(!RunLoop::isMain());
    759759    ASSERT(m_backingStore);
    760760
    … …  
    766766void UniqueIDBDatabase::createObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata)
    767767{
    768     ASSERT(!isMainThread());
     768    ASSERT(!RunLoop::isMain());
    769769    ASSERT(m_backingStore);
    770770
    … …  
    776776void UniqueIDBDatabase::deleteObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
    777777{
    778     ASSERT(!isMainThread());
     778    ASSERT(!RunLoop::isMain());
    779779    ASSERT(m_backingStore);
    780780
    … …  
    786786void UniqueIDBDatabase::clearObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
    787787{
    788     ASSERT(!isMainThread());
     788    ASSERT(!RunLoop::isMain());
    789789    ASSERT(m_backingStore);
    790790
    … …  
    796796void UniqueIDBDatabase::createIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata)
    797797{
    798     ASSERT(!isMainThread());
     798    ASSERT(!RunLoop::isMain());
    799799    ASSERT(m_backingStore);
    800800
    … …  
    806806void UniqueIDBDatabase::deleteIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID)
    807807{
    808     ASSERT(!isMainThread());
     808    ASSERT(!RunLoop::isMain());
    809809    ASSERT(m_backingStore);
    810810
    … …  
    816816void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, const IDBKeyData& inputKeyData, const Vector<uint8_t>& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys)
    817817{
    818     ASSERT(!isMainThread());
     818    ASSERT(!RunLoop::isMain());
    819819    ASSERT(m_backingStore);
    820820
    … …  
    889889void UniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType)
    890890{
    891     ASSERT(!isMainThread());
     891    ASSERT(!RunLoop::isMain());
    892892    ASSERT(m_backingStore);
    893893
    … …  
    950950void UniqueIDBDatabase::openCursorInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRange)
    951951{
    952     ASSERT(!isMainThread());
     952    ASSERT(!RunLoop::isMain());
    953953    ASSERT(m_backingStore);
    954954
    … …  
    10691069String UniqueIDBDatabase::absoluteDatabaseDirectory() const
    10701070{
    1071     ASSERT(isMainThread());
     1071    ASSERT(RunLoop::isMain());
    10721072    return DatabaseProcess::shared().absoluteIndexedDatabasePathFromDatabaseRelativePath(m_databaseRelativeDirectory);
    10731073}
    … …  
    10751075void UniqueIDBDatabase::postMainThreadTask(std::unique_ptr<AsyncTask> task, DatabaseTaskType taskType)
    10761076{
    1077     ASSERT(!isMainThread());
     1077    ASSERT(!RunLoop::isMain());
    10781078
    10791079    if (!m_acceptingNewRequests && taskType == DatabaseTaskType::Normal)
    … …  
    10911091void UniqueIDBDatabase::performNextMainThreadTask()
    10921092{
    1093     ASSERT(isMainThread());
     1093    ASSERT(RunLoop::isMain());
    10941094
    10951095    // Balanced by a ref() in ::postMainThreadTask
    … …  
    11221122void UniqueIDBDatabase::postDatabaseTask(std::unique_ptr<AsyncTask> task, DatabaseTaskType taskType)
    11231123{
    1124     ASSERT(isMainThread());
     1124    ASSERT(RunLoop::isMain());
    11251125
    11261126    if (!m_acceptingNewRequests && taskType == DatabaseTaskType::Normal)
    … …  
    11361136void UniqueIDBDatabase::performNextDatabaseTask()
    11371137{
    1138     ASSERT(!isMainThread());
     1138    ASSERT(!RunLoop::isMain());
    11391139
    11401140    // It is possible that this database might be shutting down on the main thread.

  • trunk/Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp

    r163892 r164255  
    4444#include <WebCore/SQLiteStatement.h>
    4545#include <WebCore/SharedBuffer.h>
    46 #include <wtf/MainThread.h>
     46#include <wtf/RunLoop.h>
    4747
    4848using namespace JSC;
    … …  
    5858    static int64_t databaseID = 0;
    5959
    60     ASSERT(!isMainThread());
     60    ASSERT(!RunLoop::isMain());
    6161    return ++databaseID;
    6262}
    … …  
    6767{
    6868    // The backing store is meant to be created and used entirely on a background thread.
    69     ASSERT(!isMainThread());
     69    ASSERT(!RunLoop::isMain());
    7070}
    7171
    7272UniqueIDBDatabaseBackingStoreSQLite::~UniqueIDBDatabaseBackingStoreSQLite()
    7373{
    74     ASSERT(!isMainThread());
     74    ASSERT(!RunLoop::isMain());
    7575
    7676    m_transactions.clear();
    … …  
    8686std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::createAndPopulateInitialMetadata()
    8787{
    88     ASSERT(!isMainThread());
     88    ASSERT(!RunLoop::isMain());
    8989    ASSERT(m_sqliteDB);
    9090    ASSERT(m_sqliteDB->isOpen());
    … …  
    176176std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::extractExistingMetadata()
    177177{
    178     ASSERT(!isMainThread());
     178    ASSERT(!RunLoop::isMain());
    179179    ASSERT(m_sqliteDB);
    180180
    … …  
    290290std::unique_ptr<SQLiteDatabase> UniqueIDBDatabaseBackingStoreSQLite::openSQLiteDatabaseAtPath(const String& path)
    291291{
    292     ASSERT(!isMainThread());
     292    ASSERT(!RunLoop::isMain());
    293293
    294294    auto sqliteDatabase = std::make_unique<SQLiteDatabase>();
    … …  
    307307std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata()
    308308{
    309     ASSERT(!isMainThread());
     309    ASSERT(!RunLoop::isMain());
    310310
    311311    String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(m_absoluteDatabaseDirectory);
    … …  
    334334bool UniqueIDBDatabaseBackingStoreSQLite::establishTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>&, IndexedDB::TransactionMode mode)
    335335{
    336     ASSERT(!isMainThread());
     336    ASSERT(!RunLoop::isMain());
    337337
    338338    if (!m_transactions.add(transactionIdentifier, SQLiteIDBTransaction::create(*this, transactionIdentifier, mode)).isNewEntry) {
    … …  
    346346bool UniqueIDBDatabaseBackingStoreSQLite::beginTransaction(const IDBIdentifier& transactionIdentifier)
    347347{
    348     ASSERT(!isMainThread());
     348    ASSERT(!RunLoop::isMain());
    349349
    350350    SQLiteIDBTransaction* transaction = m_transactions.get(transactionIdentifier);
    … …  
    359359bool UniqueIDBDatabaseBackingStoreSQLite::commitTransaction(const IDBIdentifier& transactionIdentifier)
    360360{
    361     ASSERT(!isMainThread());
     361    ASSERT(!RunLoop::isMain());
    362362
    363363    SQLiteIDBTransaction* transaction = m_transactions.get(transactionIdentifier);
    … …  
    372372bool UniqueIDBDatabaseBackingStoreSQLite::resetTransaction(const IDBIdentifier& transactionIdentifier)
    373373{
    374     ASSERT(!isMainThread());
     374    ASSERT(!RunLoop::isMain());
    375375
    376376    std::unique_ptr<SQLiteIDBTransaction> transaction = m_transactions.take(transactionIdentifier);
    … …  
    385385bool UniqueIDBDatabaseBackingStoreSQLite::rollbackTransaction(const IDBIdentifier& transactionIdentifier)
    386386{
    387     ASSERT(!isMainThread());
     387    ASSERT(!RunLoop::isMain());
    388388
    389389    SQLiteIDBTransaction* transaction = m_transactions.get(transactionIdentifier);
    … …  
    398398bool UniqueIDBDatabaseBackingStoreSQLite::changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion)
    399399{
    400     ASSERT(!isMainThread());
     400    ASSERT(!RunLoop::isMain());
    401401    ASSERT(m_sqliteDB);
    402402    ASSERT(m_sqliteDB->isOpen());
    … …  
    427427bool UniqueIDBDatabaseBackingStoreSQLite::createObjectStore(const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata)
    428428{
    429     ASSERT(!isMainThread());
     429    ASSERT(!RunLoop::isMain());
    430430    ASSERT(m_sqliteDB);
    431431    ASSERT(m_sqliteDB->isOpen());
    … …  
    476476bool UniqueIDBDatabaseBackingStoreSQLite::deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
    477477{
    478     ASSERT(!isMainThread());
     478    ASSERT(!RunLoop::isMain());
    479479    ASSERT(m_sqliteDB);
    480480    ASSERT(m_sqliteDB->isOpen());
    … …  
    550550bool UniqueIDBDatabaseBackingStoreSQLite::clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
    551551{
    552     ASSERT(!isMainThread());
     552    ASSERT(!RunLoop::isMain());
    553553    ASSERT(m_sqliteDB);
    554554    ASSERT(m_sqliteDB->isOpen());
    … …  
    589589bool UniqueIDBDatabaseBackingStoreSQLite::createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata)
    590590{
    591     ASSERT(!isMainThread());
     591    ASSERT(!RunLoop::isMain());
    592592    ASSERT(m_sqliteDB);
    593593    ASSERT(m_sqliteDB->isOpen());
    … …  
    671671bool UniqueIDBDatabaseBackingStoreSQLite::deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID)
    672672{
    673     ASSERT(!isMainThread());
     673    ASSERT(!RunLoop::isMain());
    674674    ASSERT(m_sqliteDB);
    675675    ASSERT(m_sqliteDB->isOpen());
    … …  
    712712bool UniqueIDBDatabaseBackingStoreSQLite::generateKeyNumber(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t& generatedKey)
    713713{
    714     ASSERT(!isMainThread());
     714    ASSERT(!RunLoop::isMain());
    715715    ASSERT(m_sqliteDB);
    716716    ASSERT(m_sqliteDB->isOpen());
    … …  
    755755bool UniqueIDBDatabaseBackingStoreSQLite::updateKeyGeneratorNumber(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t keyNumber, bool)
    756756{
    757     ASSERT(!isMainThread());
     757    ASSERT(!RunLoop::isMain());
    758758    ASSERT(m_sqliteDB);
    759759    ASSERT(m_sqliteDB->isOpen());
    … …  
    785785bool UniqueIDBDatabaseBackingStoreSQLite::keyExistsInObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyData& keyData, bool& keyExists)
    786786{
    787     ASSERT(!isMainThread());
     787    ASSERT(!RunLoop::isMain());
    788788    ASSERT(m_sqliteDB);
    789789    ASSERT(m_sqliteDB->isOpen());
    … …  
    829829bool UniqueIDBDatabaseBackingStoreSQLite::putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyData& keyData, const uint8_t* valueBuffer, size_t valueSize)
    830830{
    831     ASSERT(!isMainThread());
     831    ASSERT(!RunLoop::isMain());
    832832    ASSERT(m_sqliteDB);
    833833    ASSERT(m_sqliteDB->isOpen());
    … …  
    865865bool UniqueIDBDatabaseBackingStoreSQLite::putIndexRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyData& keyValue, const IDBKeyData& indexKey)
    866866{
    867     ASSERT(!isMainThread());
     867    ASSERT(!RunLoop::isMain());
    868868    ASSERT(m_sqliteDB);
    869869    ASSERT(m_sqliteDB->isOpen());
    … …  
    913913bool UniqueIDBDatabaseBackingStoreSQLite::getIndexRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType, IDBGetResult& result)
    914914{
    915     ASSERT(!isMainThread());
     915    ASSERT(!RunLoop::isMain());
    916916    ASSERT(m_sqliteDB);
    917917    ASSERT(m_sqliteDB->isOpen());
    … …  
    948948bool UniqueIDBDatabaseBackingStoreSQLite::deleteRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyData& keyData)
    949949{
    950     ASSERT(!isMainThread());
     950    ASSERT(!RunLoop::isMain());
    951951    ASSERT(m_sqliteDB);
    952952    ASSERT(m_sqliteDB->isOpen());
    … …  
    968968bool UniqueIDBDatabaseBackingStoreSQLite::deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData)
    969969{
    970     ASSERT(!isMainThread());
     970    ASSERT(!RunLoop::isMain());
    971971    ASSERT(m_sqliteDB);
    972972    ASSERT(m_sqliteDB->isOpen());
    … …  
    10291029bool UniqueIDBDatabaseBackingStoreSQLite::deleteRecord(SQLiteIDBTransaction& transaction, int64_t objectStoreID, const WebCore::IDBKeyData& key)
    10301030{
    1031     ASSERT(!isMainThread());
     1031    ASSERT(!RunLoop::isMain());
    10321032    ASSERT(m_sqliteDB);
    10331033    ASSERT(m_sqliteDB->isOpen());
    … …  
    10701070bool UniqueIDBDatabaseBackingStoreSQLite::getKeyRecordFromObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKey& key, RefPtr<SharedBuffer>& result)
    10711071{
    1072     ASSERT(!isMainThread());
     1072    ASSERT(!RunLoop::isMain());
    10731073    ASSERT(m_sqliteDB);
    10741074    ASSERT(m_sqliteDB->isOpen());
    … …  
    11161116bool UniqueIDBDatabaseBackingStoreSQLite::getKeyRangeRecordFromObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRange& keyRange, RefPtr<SharedBuffer>& result, RefPtr<IDBKey>& resultKey)
    11171117{
    1118     ASSERT(!isMainThread());
     1118    ASSERT(!RunLoop::isMain());
    11191119    ASSERT(m_sqliteDB);
    11201120    ASSERT(m_sqliteDB->isOpen());
    … …  
    11701170bool UniqueIDBDatabaseBackingStoreSQLite::count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, int64_t& count)
    11711171{
    1172     ASSERT(!isMainThread());
     1172    ASSERT(!RunLoop::isMain());
    11731173    ASSERT(m_sqliteDB);
    11741174    ASSERT(m_sqliteDB->isOpen());
    … …  
    12001200bool UniqueIDBDatabaseBackingStoreSQLite::openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRange, int64_t& cursorID, IDBKeyData& key, IDBKeyData& primaryKey, Vector<uint8_t>& valueBuffer)
    12011201{
    1202     ASSERT(!isMainThread());
     1202    ASSERT(!RunLoop::isMain());
    12031203    ASSERT(m_sqliteDB);
    12041204    ASSERT(m_sqliteDB->isOpen());
    … …  
    12251225bool UniqueIDBDatabaseBackingStoreSQLite::advanceCursor(const IDBIdentifier& cursorIdentifier, uint64_t count, IDBKeyData& key, IDBKeyData& primaryKey, Vector<uint8_t>& valueBuffer)
    12261226{
    1227     ASSERT(!isMainThread());
     1227    ASSERT(!RunLoop::isMain());
    12281228    ASSERT(m_sqliteDB);
    12291229    ASSERT(m_sqliteDB->isOpen());
    … …  
    12531253bool UniqueIDBDatabaseBackingStoreSQLite::iterateCursor(const IDBIdentifier& cursorIdentifier, const IDBKeyData& targetKey, IDBKeyData& key, IDBKeyData& primaryKey, Vector<uint8_t>& valueBuffer)
    12541254{
    1255     ASSERT(!isMainThread());
     1255    ASSERT(!RunLoop::isMain());
    12561256    ASSERT(m_sqliteDB);
    12571257    ASSERT(m_sqliteDB->isOpen());
    … …  
    12811281void UniqueIDBDatabaseBackingStoreSQLite::notifyCursorsOfChanges(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
    12821282{
    1283     ASSERT(!isMainThread());
     1283    ASSERT(!RunLoop::isMain());
    12841284    ASSERT(m_sqliteDB);
    12851285    ASSERT(m_sqliteDB->isOpen());

  • trunk/Source/WebKit2/NetworkProcess/FileAPI/NetworkBlobRegistry.cpp

    r161045 r164255  
    3131#include "SandboxExtension.h"
    3232#include <WebCore/BlobRegistryImpl.h>
    33 #include <wtf/MainThread.h>
    3433#include <wtf/NeverDestroyed.h>
     34#include <wtf/RunLoop.h>
    3535
    3636using namespace WebCore;
    … …  
    4040NetworkBlobRegistry& NetworkBlobRegistry::shared()
    4141{
    42     ASSERT(isMainThread());
     42    ASSERT(RunLoop::isMain());
    4343    static NeverDestroyed<NetworkBlobRegistry> registry;
    4444    return registry;

  • trunk/Source/WebKit2/NetworkProcess/HostRecord.cpp

    r154183 r164255  
    5858void HostRecord::scheduleResourceLoader(PassRefPtr<NetworkResourceLoader> loader)
    5959{
    60     ASSERT(isMainThread());
     60    ASSERT(RunLoop::isMain());
    6161
    6262    loader->setHostRecord(this);
    … …  
    7070void HostRecord::addLoaderInProgress(NetworkResourceLoader* loader)
    7171{
    72     ASSERT(isMainThread());
     72    ASSERT(RunLoop::isMain());
    7373
    7474    m_loadersInProgress.add(loader);
    … …  
    9191void HostRecord::removeLoader(NetworkResourceLoader* loader)
    9292{
    93     ASSERT(isMainThread());
     93    ASSERT(RunLoop::isMain());
    9494
    9595    // FIXME (NetworkProcess): Due to IPC race conditions, it's possible this HostRecord will be asked to remove the same loader twice.

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoadScheduler.cpp

    r156550 r164255  
    7777void NetworkResourceLoadScheduler::removeLoader(NetworkResourceLoader* loader)
    7878{
    79     ASSERT(isMainThread());
     79    ASSERT(RunLoop::isMain());
    8080    ASSERT(loader);
    8181
    … …  
    9595void NetworkResourceLoadScheduler::receivedRedirect(NetworkResourceLoader* loader, const WebCore::URL& redirectURL)
    9696{
    97     ASSERT(isMainThread());
     97    ASSERT(RunLoop::isMain());
    9898    LOG(NetworkScheduling, "(NetworkProcess) NetworkResourceLoadScheduler::receivedRedirect loader originally for '%s' redirected to '%s'", loader->request().url().string().utf8().data(), redirectURL.string().utf8().data());
    9999
    … …  
    139139void NetworkResourceLoadScheduler::removeScheduledLoaders(void* context)
    140140{
    141     ASSERT(isMainThread());
     141    ASSERT(RunLoop::isMain());
    142142    ASSERT(removeScheduledLoadersCalled);
    143143

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r163961 r164255  
    100100        m_resourceSandboxExtensions.append(resourceSandboxExtension);
    101101
    102     ASSERT(isMainThread());
     102    ASSERT(RunLoop::isMain());
    103103   
    104104    if (reply)
    … …  
    110110NetworkResourceLoader::~NetworkResourceLoader()
    111111{
    112     ASSERT(isMainThread());
     112    ASSERT(RunLoop::isMain());
    113113    ASSERT(!m_handle);
    114114    ASSERT(!m_hostRecord);
    … …  
    122122void NetworkResourceLoader::start()
    123123{
    124     ASSERT(isMainThread());
     124    ASSERT(RunLoop::isMain());
    125125
    126126    // Explicit ref() balanced by a deref() in NetworkResourceLoader::resourceHandleStopped()
    … …  
    138138void NetworkResourceLoader::cleanup()
    139139{
    140     ASSERT(isMainThread());
     140    ASSERT(RunLoop::isMain());
    141141
    142142    invalidateSandboxExtensions();
    … …  
    164164void NetworkResourceLoader::abort()
    165165{
    166     ASSERT(isMainThread());
     166    ASSERT(RunLoop::isMain());
    167167
    168168    if (m_handle && !m_handleConvertedToDownload)
    … …  
    234234    // We only expect to get the willSendRequest callback from ResourceHandle as the result of a redirect.
    235235    ASSERT(!redirectResponse.isNull());
    236     ASSERT(isMainThread());
     236    ASSERT(RunLoop::isMain());
    237237
    238238    ResourceRequest proposedRequest = request;
    … …  
    379379void NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace& protectionSpace)
    380380{
    381     ASSERT(isMainThread());
     381    ASSERT(RunLoop::isMain());
    382382    ASSERT_UNUSED(handle, handle == m_handle);
    383383

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

    r163961 r164255  
    122122    bool isLoadingMainResource() const { return m_isLoadingMainResource; }
    123123   
    124     void setHostRecord(HostRecord* hostRecord) { ASSERT(isMainThread()); m_hostRecord = hostRecord; }
    125     HostRecord* hostRecord() const { ASSERT(isMainThread()); return m_hostRecord.get(); }
     124    void setHostRecord(HostRecord* hostRecord) { ASSERT(RunLoop::isMain()); m_hostRecord = hostRecord; }
     125    HostRecord* hostRecord() const { ASSERT(RunLoop::isMain()); return m_hostRecord.get(); }
    126126
    127127    template<typename T>

  • trunk/Source/WebKit2/NetworkProcess/mac/DiskCacheMonitor.mm

    r161148 r164255  
    6464    , m_resourceRequest(loader->request())
    6565{
    66     ASSERT(isMainThread());
     66    ASSERT(RunLoop::isMain());
    6767
    6868    // Set up a delayed callback to cancel this monitor if the resource hasn't been cached yet.

  • trunk/Source/WebKit2/Shared/AsyncRequest.cpp

    r160033 r164255  
    2828#include "AsyncRequest.h"
    2929
    30 #include <wtf/MainThread.h>
     30#include <wtf/RunLoop.h>
    3131
    3232namespace WebKit {
    … …  
    3434static uint64_t generateRequestID()
    3535{
    36     ASSERT(isMainThread());
     36    ASSERT(RunLoop::isMain());
    3737    static uint64_t requestID = 0;
    3838    return ++requestID;

  • trunk/Source/WebKit2/Shared/Authentication/AuthenticationManager.cpp

    r160464 r164255  
    4848static uint64_t generateAuthenticationChallengeID()
    4949{
    50     ASSERT(isMainThread());
     50    ASSERT(RunLoop::isMain());
    5151
    5252    static int64_t uniqueAuthenticationChallengeID;
    … …  
    6767uint64_t AuthenticationManager::establishIdentifierForChallenge(const WebCore::AuthenticationChallenge& authenticationChallenge)
    6868{
    69     ASSERT(isMainThread());
     69    ASSERT(RunLoop::isMain());
    7070
    7171    uint64_t challengeID = generateAuthenticationChallengeID();
    … …  
    107107void AuthenticationManager::useCredentialForChallenge(uint64_t challengeID, const Credential& credential, const CertificateInfo& certificateInfo)
    108108{
    109     ASSERT(isMainThread());
     109    ASSERT(RunLoop::isMain());
    110110
    111111    AuthenticationChallenge challenge = m_challenges.take(challengeID);
    … …  
    127127void AuthenticationManager::continueWithoutCredentialForChallenge(uint64_t challengeID)
    128128{
    129     ASSERT(isMainThread());
     129    ASSERT(RunLoop::isMain());
    130130
    131131    AuthenticationChallenge challenge = m_challenges.take(challengeID);
    … …  
    143143void AuthenticationManager::cancelChallenge(uint64_t challengeID)
    144144{
    145     ASSERT(isMainThread());
     145    ASSERT(RunLoop::isMain());
    146146
    147147    AuthenticationChallenge challenge = m_challenges.take(challengeID);

  • trunk/Source/WebKit2/Shared/Downloads/mac/DownloadMac.mm

    r162505 r164255  
    131131static void dispatchOnMainThread(void (^block)())
    132132{
    133     if (isMainThread()) {
     133    if (RunLoop::isMain()) {
    134134        block();
    135135        return;

  • trunk/Source/WebKit2/Shared/Plugins/NPObjectProxy.cpp

    r159001 r164255  
    5858NPObjectProxy::~NPObjectProxy()
    5959{
    60     ASSERT(isMainThread());
     60    ASSERT(RunLoop::isMain());
    6161
    6262    if (!m_npRemoteObjectMap)

  • trunk/Source/WebKit2/Shared/Plugins/Netscape/mac/NetscapePluginModuleMac.mm

    r159437 r164255  
    293293static bool getPluginInfoFromCarbonResources(CFBundleRef bundle, PluginModuleInfo& plugin)
    294294{
    295     ASSERT(isMainThread());
     295    ASSERT(RunLoop::isMain());
    296296
    297297    ResourceMap resourceMap(bundle);

  • trunk/Source/WebKit2/Shared/SessionTracker.cpp

    r163217 r164255  
    2727#include "SessionTracker.h"
    2828
    29 #include <wtf/MainThread.h>
    3029#include <wtf/NeverDestroyed.h>
     30#include <wtf/RunLoop.h>
    3131
    3232using namespace WebCore;
    … …  
    3939static HashMap<uint64_t, std::unique_ptr<NetworkStorageSession>>& staticSessionMap()
    4040{
    41     ASSERT(isMainThread());
     41    ASSERT(RunLoop::isMain());
    4242
    4343    static NeverDestroyed<HashMap<uint64_t, std::unique_ptr<NetworkStorageSession>>> map;
    … …  
    4747static HashMap<const NetworkStorageSession*, uint64_t>& storageSessionToID()
    4848{
    49     ASSERT(isMainThread());
     49    ASSERT(RunLoop::isMain());
    5050
    5151    static NeverDestroyed<HashMap<const NetworkStorageSession*, uint64_t>> map;
    … …  
    5555static String& identifierBase()
    5656{
    57     ASSERT(isMainThread());
     57    ASSERT(RunLoop::isMain());
    5858
    5959    static NeverDestroyed<String> base;
    … …  
    9494void SessionTracker::destroySession(uint64_t sessionID)
    9595{
    96     ASSERT(isMainThread());
     96    ASSERT(RunLoop::isMain());
    9797    if (staticSessionMap().contains(sessionID)) {
    9898        storageSessionToID().remove(session(sessionID));
    … …  
    103103void SessionTracker::setIdentifierBase(const String& identifier)
    104104{
    105     ASSERT(isMainThread());
     105    ASSERT(RunLoop::isMain());
    106106
    107107    identifierBase() = identifier;

  • trunk/Source/WebKit2/UIProcess/APISession.cpp

    r162271 r164255  
    2727#include "APISession.h"
    2828
    29 #include <wtf/MainThread.h>
     29#include <wtf/RunLoop.h>
    3030
    3131namespace API {
    … …  
    3333static uint64_t generateID(bool isEphemeral)
    3434{
    35     ASSERT(isMainThread());
     35    ASSERT(RunLoop::isMain());
    3636
    3737    static uint64_t uniqueSessionID = WebKit::SessionTracker::legacyPrivateSessionID;
    … …  
    4242Session& Session::defaultSession()
    4343{
    44     ASSERT(isMainThread());
     44    ASSERT(RunLoop::isMain());
    4545
    4646    static Session* defaultSession = new Session(false, WebKit::SessionTracker::defaultSessionID);
    … …  
    5050Session& Session::legacyPrivateSession()
    5151{
    52     ASSERT(isMainThread());
     52    ASSERT(RunLoop::isMain());
    5353
    5454    static Session* legacyPrivateSession = new Session(true, WebKit::SessionTracker::legacyPrivateSessionID);

  • trunk/Source/WebKit2/WebProcess/Cookies/WebCookieManager.cpp

    r160464 r164255  
    9696void WebCookieManager::dispatchCookiesDidChange()
    9797{
    98     ASSERT(isMainThread());
     98    ASSERT(RunLoop::isMain());
    9999    m_process->send(Messages::WebCookieManagerProxy::CookiesDidChange(), 0);
    100100}

  • trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBFactoryBackend.cpp

    r164051 r164255  
    115115void WebIDBFactoryBackend::open(const String& databaseName, uint64_t version, int64_t transactionId, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, const SecurityOrigin& openingOrigin, const SecurityOrigin& mainFrameOrigin)
    116116{
    117     ASSERT(isMainThread());
     117    ASSERT(RunLoop::isMain());
    118118    LOG(IDB, "WebIDBFactoryBackend::open");
    119119
    … …  
    150150void WebIDBFactoryBackend::deleteDatabase(const String& databaseName, const SecurityOrigin& openingOrigin, const SecurityOrigin& mainFrameOrigin, PassRefPtr<IDBCallbacks> callbacks, ScriptExecutionContext*, const String&)
    151151{
    152     ASSERT(isMainThread());
     152    ASSERT(RunLoop::isMain());
    153153    LOG(IDB, "WebIDBFactoryBackend::deleteDatabase");
    154154

  • trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBServerConnection.cpp

    r163959 r164255  
    4848static uint64_t generateServerConnectionIdentifier()
    4949{
    50     ASSERT(isMainThread());
     50    ASSERT(RunLoop::isMain());
    5151    static uint64_t identifier = 0;
    5252    return ++identifier;

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/mac/WebFrameNetworkingContext.mm

    r163217 r164255  
    101101NetworkStorageSession& WebFrameNetworkingContext::storageSession() const
    102102{
    103     ASSERT(isMainThread());
     103    ASSERT(RunLoop::isMain());
    104104
    105105    if (frame())

  • trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp

    r164192 r164255  
    146146void EventDispatcher::dispatchWheelEvent(uint64_t pageID, const WebWheelEvent& wheelEvent)
    147147{
    148     ASSERT(isMainThread());
     148    ASSERT(RunLoop::isMain());
    149149
    150150    WebPage* webPage = WebProcess::shared().webPage(pageID);
Note: See TracChangeset for help on using the changeset viewer.