Changeset 201575 in webkit


Ignore:
Timestamp:
Jun 1, 2016 4:38:37 PM (8 years ago)
Author:
beidson@apple.com
Message:

Modernize lambda usage for all callers of RunLoop::dispatch().
https://bugs.webkit.org/show_bug.cgi?id=158265

Reviewed by Chris Dumez.

Source/WebCore:

No new tests (Refactor, no behavior change).

  • Modules/indexeddb/shared/InProcessIDBServer.cpp:

(WebCore::InProcessIDBServer::deleteDatabase):
(WebCore::InProcessIDBServer::didDeleteDatabase):
(WebCore::InProcessIDBServer::openDatabase):
(WebCore::InProcessIDBServer::didOpenDatabase):
(WebCore::InProcessIDBServer::didAbortTransaction):
(WebCore::InProcessIDBServer::didCommitTransaction):
(WebCore::InProcessIDBServer::didCreateObjectStore):
(WebCore::InProcessIDBServer::didDeleteObjectStore):
(WebCore::InProcessIDBServer::didClearObjectStore):
(WebCore::InProcessIDBServer::didCreateIndex):
(WebCore::InProcessIDBServer::didDeleteIndex):
(WebCore::InProcessIDBServer::didPutOrAdd):
(WebCore::InProcessIDBServer::didGetRecord):
(WebCore::InProcessIDBServer::didGetCount):
(WebCore::InProcessIDBServer::didDeleteRecord):
(WebCore::InProcessIDBServer::didOpenCursor):
(WebCore::InProcessIDBServer::didIterateCursor):
(WebCore::InProcessIDBServer::abortTransaction):
(WebCore::InProcessIDBServer::commitTransaction):
(WebCore::InProcessIDBServer::didFinishHandlingVersionChangeTransaction):
(WebCore::InProcessIDBServer::createObjectStore):
(WebCore::InProcessIDBServer::deleteObjectStore):
(WebCore::InProcessIDBServer::clearObjectStore):
(WebCore::InProcessIDBServer::createIndex):
(WebCore::InProcessIDBServer::deleteIndex):
(WebCore::InProcessIDBServer::putOrAdd):
(WebCore::InProcessIDBServer::getRecord):
(WebCore::InProcessIDBServer::getCount):
(WebCore::InProcessIDBServer::deleteRecord):
(WebCore::InProcessIDBServer::openCursor):
(WebCore::InProcessIDBServer::iterateCursor):
(WebCore::InProcessIDBServer::establishTransaction):
(WebCore::InProcessIDBServer::fireVersionChangeEvent):
(WebCore::InProcessIDBServer::didStartTransaction):
(WebCore::InProcessIDBServer::didCloseFromServer):
(WebCore::InProcessIDBServer::notifyOpenDBRequestBlocked):
(WebCore::InProcessIDBServer::databaseConnectionClosed):
(WebCore::InProcessIDBServer::abortOpenAndUpgradeNeeded):
(WebCore::InProcessIDBServer::didFireVersionChangeEvent):
(WebCore::InProcessIDBServer::openDBRequestCancelled):
(WebCore::InProcessIDBServer::confirmDidCloseFromServer):
(WebCore::InProcessIDBServer::getAllDatabaseNames):
(WebCore::InProcessIDBServer::didGetAllDatabaseNames):

  • Modules/websockets/WebSocket.cpp:

(WebCore::WebSocket::connect):

  • bindings/js/SerializedScriptValue.cpp:

(WebCore::SerializedScriptValue::writeBlobsToDiskForIndexedDBSynchronously):

  • page/scrolling/ThreadedScrollingTree.cpp:

(WebCore::ThreadedScrollingTree::invalidate):
(WebCore::ThreadedScrollingTree::scrollingTreeNodeDidScroll):
(WebCore::ThreadedScrollingTree::currentSnapPointIndicesDidChange):
(WebCore::ThreadedScrollingTree::handleWheelEventPhase):
(WebCore::ThreadedScrollingTree::setActiveScrollSnapIndices):
(WebCore::ThreadedScrollingTree::deferTestsForReason):
(WebCore::ThreadedScrollingTree::removeTestDeferralForReason):

  • platform/graphics/cocoa/FontCacheCoreText.cpp:

(WebCore::FontCache::platformPrecache):

  • platform/graphics/mac/DisplayRefreshMonitorMac.cpp:

(WebCore::DisplayRefreshMonitorMac::displayLinkFired):

  • platform/network/DataURLDecoder.cpp:

(WebCore::DataURLDecoder::createDecodeTask):
(WebCore::DataURLDecoder::decode):

Source/WebKit2:

  • DatabaseProcess/DatabaseProcess.cpp:

(WebKit::DatabaseProcess::fetchWebsiteData):
(WebKit::DatabaseProcess::deleteWebsiteData):
(WebKit::DatabaseProcess::deleteWebsiteDataForOrigins):

  • NetworkProcess/NetworkProcess.cpp:

(WebKit::fetchDiskCacheEntries):
(WebKit::NetworkProcess::fetchWebsiteData):

  • NetworkProcess/cache/NetworkCacheStorage.cpp:

(WebKit::NetworkCache::Storage::remove):
(WebKit::NetworkCache::retrieveFromMemory):

  • Platform/IPC/Connection.cpp:

(IPC::Connection::SyncMessageState::processIncomingMessage):
(IPC::Connection::processIncomingMessage):
(IPC::Connection::connectionDidClose):
(IPC::Connection::enqueueIncomingMessage):

  • Platform/IPC/mac/ConnectionMac.mm:

(IPC::Connection::receiveSourceEventHandler):

  • Shared/mac/CookieStorageShim.mm:

(-[WKNSURLSessionLocal _getCookieHeadersForTask:completionHandler:]):

  • UIProcess/API/APIUserContentExtensionStore.cpp:

(API::UserContentExtensionStore::lookupContentExtension):
(API::UserContentExtensionStore::compileContentExtension):
(API::UserContentExtensionStore::removeContentExtension):

  • UIProcess/Launcher/ProcessLauncher.cpp:

(WebKit::ProcessLauncher::ProcessLauncher):

  • UIProcess/Launcher/mac/ProcessLauncherMac.mm:

(WebKit::connectToService):

  • UIProcess/Storage/StorageManager.cpp:

(WebKit::StorageManager::getSessionStorageOrigins):
(WebKit::StorageManager::deleteSessionStorageOrigins):
(WebKit::StorageManager::deleteSessionStorageEntriesForOrigins):
(WebKit::StorageManager::getLocalStorageOrigins):
(WebKit::StorageManager::getLocalStorageOriginDetails):
(WebKit::StorageManager::deleteLocalStorageEntriesForOrigin):
(WebKit::StorageManager::deleteLocalStorageOriginsModifiedSince):
(WebKit::StorageManager::deleteLocalStorageEntriesForOrigins):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::isWebProcessResponsive):

  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::isResponsive):

  • UIProcess/WebsiteData/WebsiteDataStore.cpp:

(WebKit::WebsiteDataStore::fetchData):

  • WebProcess/Plugins/Netscape/NetscapePlugin.cpp:

(WebKit::NetscapePlugin::pluginThreadAsyncCall):

  • WebProcess/Plugins/PluginView.cpp:

(WebKit::PluginView::unprotectPluginFromDestruction):

  • WebProcess/WebPage/EventDispatcher.cpp:

(WebKit::EventDispatcher::wheelEvent):
(WebKit::EventDispatcher::gestureEvent):
(WebKit::EventDispatcher::touchEvent):

  • WebProcess/WebPage/ViewUpdateDispatcher.cpp:

(WebKit::ViewUpdateDispatcher::visibleContentRectUpdate):

Location:
trunk/Source
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r201574 r201575  
     12016-06-01  Brady Eidson  <beidson@apple.com>
     2
     3        Modernize lambda usage for all callers of RunLoop::dispatch().
     4        https://bugs.webkit.org/show_bug.cgi?id=158265
     5
     6        Reviewed by Chris Dumez.
     7
     8        No new tests (Refactor, no behavior change).
     9
     10        * Modules/indexeddb/shared/InProcessIDBServer.cpp:
     11        (WebCore::InProcessIDBServer::deleteDatabase):
     12        (WebCore::InProcessIDBServer::didDeleteDatabase):
     13        (WebCore::InProcessIDBServer::openDatabase):
     14        (WebCore::InProcessIDBServer::didOpenDatabase):
     15        (WebCore::InProcessIDBServer::didAbortTransaction):
     16        (WebCore::InProcessIDBServer::didCommitTransaction):
     17        (WebCore::InProcessIDBServer::didCreateObjectStore):
     18        (WebCore::InProcessIDBServer::didDeleteObjectStore):
     19        (WebCore::InProcessIDBServer::didClearObjectStore):
     20        (WebCore::InProcessIDBServer::didCreateIndex):
     21        (WebCore::InProcessIDBServer::didDeleteIndex):
     22        (WebCore::InProcessIDBServer::didPutOrAdd):
     23        (WebCore::InProcessIDBServer::didGetRecord):
     24        (WebCore::InProcessIDBServer::didGetCount):
     25        (WebCore::InProcessIDBServer::didDeleteRecord):
     26        (WebCore::InProcessIDBServer::didOpenCursor):
     27        (WebCore::InProcessIDBServer::didIterateCursor):
     28        (WebCore::InProcessIDBServer::abortTransaction):
     29        (WebCore::InProcessIDBServer::commitTransaction):
     30        (WebCore::InProcessIDBServer::didFinishHandlingVersionChangeTransaction):
     31        (WebCore::InProcessIDBServer::createObjectStore):
     32        (WebCore::InProcessIDBServer::deleteObjectStore):
     33        (WebCore::InProcessIDBServer::clearObjectStore):
     34        (WebCore::InProcessIDBServer::createIndex):
     35        (WebCore::InProcessIDBServer::deleteIndex):
     36        (WebCore::InProcessIDBServer::putOrAdd):
     37        (WebCore::InProcessIDBServer::getRecord):
     38        (WebCore::InProcessIDBServer::getCount):
     39        (WebCore::InProcessIDBServer::deleteRecord):
     40        (WebCore::InProcessIDBServer::openCursor):
     41        (WebCore::InProcessIDBServer::iterateCursor):
     42        (WebCore::InProcessIDBServer::establishTransaction):
     43        (WebCore::InProcessIDBServer::fireVersionChangeEvent):
     44        (WebCore::InProcessIDBServer::didStartTransaction):
     45        (WebCore::InProcessIDBServer::didCloseFromServer):
     46        (WebCore::InProcessIDBServer::notifyOpenDBRequestBlocked):
     47        (WebCore::InProcessIDBServer::databaseConnectionClosed):
     48        (WebCore::InProcessIDBServer::abortOpenAndUpgradeNeeded):
     49        (WebCore::InProcessIDBServer::didFireVersionChangeEvent):
     50        (WebCore::InProcessIDBServer::openDBRequestCancelled):
     51        (WebCore::InProcessIDBServer::confirmDidCloseFromServer):
     52        (WebCore::InProcessIDBServer::getAllDatabaseNames):
     53        (WebCore::InProcessIDBServer::didGetAllDatabaseNames):
     54       
     55        * Modules/websockets/WebSocket.cpp:
     56        (WebCore::WebSocket::connect):
     57       
     58        * bindings/js/SerializedScriptValue.cpp:
     59        (WebCore::SerializedScriptValue::writeBlobsToDiskForIndexedDBSynchronously):
     60       
     61        * page/scrolling/ThreadedScrollingTree.cpp:
     62        (WebCore::ThreadedScrollingTree::invalidate):
     63        (WebCore::ThreadedScrollingTree::scrollingTreeNodeDidScroll):
     64        (WebCore::ThreadedScrollingTree::currentSnapPointIndicesDidChange):
     65        (WebCore::ThreadedScrollingTree::handleWheelEventPhase):
     66        (WebCore::ThreadedScrollingTree::setActiveScrollSnapIndices):
     67        (WebCore::ThreadedScrollingTree::deferTestsForReason):
     68        (WebCore::ThreadedScrollingTree::removeTestDeferralForReason):
     69       
     70        * platform/graphics/cocoa/FontCacheCoreText.cpp:
     71        (WebCore::FontCache::platformPrecache):
     72       
     73        * platform/graphics/mac/DisplayRefreshMonitorMac.cpp:
     74        (WebCore::DisplayRefreshMonitorMac::displayLinkFired):
     75       
     76        * platform/network/DataURLDecoder.cpp:
     77        (WebCore::DataURLDecoder::createDecodeTask):
     78        (WebCore::DataURLDecoder::decode):
     79
    1802016-06-01  Eric Carlson  <eric.carlson@apple.com>
    281
  • trunk/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp

    r201098 r201575  
    9292void InProcessIDBServer::deleteDatabase(const IDBRequestData& requestData)
    9393{
    94     RefPtr<InProcessIDBServer> protectedThis(this);
    95     RunLoop::current().dispatch([this, protectedThis, requestData] {
     94    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData] {
    9695        m_server->deleteDatabase(requestData);
    9796    });
     
    10099void InProcessIDBServer::didDeleteDatabase(const IDBResultData& resultData)
    101100{
    102     RefPtr<InProcessIDBServer> protectedThis(this);
    103     RunLoop::current().dispatch([this, protectedThis, resultData] {
     101    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    104102        m_connectionToServer->didDeleteDatabase(resultData);
    105103    });
     
    108106void InProcessIDBServer::openDatabase(const IDBRequestData& requestData)
    109107{
    110     RefPtr<InProcessIDBServer> protectedThis(this);
    111     RunLoop::current().dispatch([this, protectedThis, requestData] {
     108    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData] {
    112109        m_server->openDatabase(requestData);
    113110    });
     
    116113void InProcessIDBServer::didOpenDatabase(const IDBResultData& resultData)
    117114{
    118     RefPtr<InProcessIDBServer> protectedThis(this);
    119     RunLoop::current().dispatch([this, protectedThis, resultData] {
     115    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    120116        m_connectionToServer->didOpenDatabase(resultData);
    121117    });
     
    124120void InProcessIDBServer::didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
    125121{
    126     RefPtr<InProcessIDBServer> protectedThis(this);
    127     RunLoop::current().dispatch([this, protectedThis, transactionIdentifier, error] {
     122    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), transactionIdentifier, error] {
    128123        m_connectionToServer->didAbortTransaction(transactionIdentifier, error);
    129124    });
     
    132127void InProcessIDBServer::didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
    133128{
    134     RefPtr<InProcessIDBServer> protectedThis(this);
    135     RunLoop::current().dispatch([this, protectedThis, transactionIdentifier, error] {
     129    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), transactionIdentifier, error] {
    136130        m_connectionToServer->didCommitTransaction(transactionIdentifier, error);
    137131    });
     
    140134void InProcessIDBServer::didCreateObjectStore(const IDBResultData& resultData)
    141135{
    142     RefPtr<InProcessIDBServer> protectedThis(this);
    143     RunLoop::current().dispatch([this, protectedThis, resultData] {
     136    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    144137        m_connectionToServer->didCreateObjectStore(resultData);
    145138    });
     
    148141void InProcessIDBServer::didDeleteObjectStore(const IDBResultData& resultData)
    149142{
    150     RefPtr<InProcessIDBServer> protectedThis(this);
    151     RunLoop::current().dispatch([this, protectedThis, resultData] {
     143    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    152144        m_connectionToServer->didDeleteObjectStore(resultData);
    153145    });
     
    156148void InProcessIDBServer::didClearObjectStore(const IDBResultData& resultData)
    157149{
    158     RefPtr<InProcessIDBServer> protectedThis(this);
    159     RunLoop::current().dispatch([this, protectedThis, resultData] {
     150    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    160151        m_connectionToServer->didClearObjectStore(resultData);
    161152    });
     
    164155void InProcessIDBServer::didCreateIndex(const IDBResultData& resultData)
    165156{
    166     RefPtr<InProcessIDBServer> protectedThis(this);
    167     RunLoop::current().dispatch([this, protectedThis, resultData] {
     157    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    168158        m_connectionToServer->didCreateIndex(resultData);
    169159    });
     
    172162void InProcessIDBServer::didDeleteIndex(const IDBResultData& resultData)
    173163{
    174     RefPtr<InProcessIDBServer> protectedThis(this);
    175     RunLoop::current().dispatch([this, protectedThis, resultData] {
     164    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    176165        m_connectionToServer->didDeleteIndex(resultData);
    177166    });
     
    180169void InProcessIDBServer::didPutOrAdd(const IDBResultData& resultData)
    181170{
    182     RefPtr<InProcessIDBServer> protectedThis(this);
    183     RunLoop::current().dispatch([this, protectedThis, resultData] {
     171    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    184172        m_connectionToServer->didPutOrAdd(resultData);
    185173    });
     
    188176void InProcessIDBServer::didGetRecord(const IDBResultData& resultData)
    189177{
    190     RefPtr<InProcessIDBServer> protectedThis(this);
    191     RunLoop::current().dispatch([this, protectedThis, resultData] {
     178    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    192179        m_connectionToServer->didGetRecord(resultData);
    193180    });
     
    196183void InProcessIDBServer::didGetCount(const IDBResultData& resultData)
    197184{
    198     RefPtr<InProcessIDBServer> protectedThis(this);
    199     RunLoop::current().dispatch([this, protectedThis, resultData] {
     185    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    200186        m_connectionToServer->didGetCount(resultData);
    201187    });
     
    204190void InProcessIDBServer::didDeleteRecord(const IDBResultData& resultData)
    205191{
    206     RefPtr<InProcessIDBServer> protectedThis(this);
    207     RunLoop::current().dispatch([this, protectedThis, resultData] {
     192    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    208193        m_connectionToServer->didDeleteRecord(resultData);
    209194    });
     
    212197void InProcessIDBServer::didOpenCursor(const IDBResultData& resultData)
    213198{
    214     RefPtr<InProcessIDBServer> protectedThis(this);
    215     RunLoop::current().dispatch([this, protectedThis, resultData] {
     199    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    216200        m_connectionToServer->didOpenCursor(resultData);
    217201    });
     
    220204void InProcessIDBServer::didIterateCursor(const IDBResultData& resultData)
    221205{
    222     RefPtr<InProcessIDBServer> protectedThis(this);
    223     RunLoop::current().dispatch([this, protectedThis, resultData] {
     206    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData] {
    224207        m_connectionToServer->didIterateCursor(resultData);
    225208    });
     
    228211void InProcessIDBServer::abortTransaction(const IDBResourceIdentifier& resourceIdentifier)
    229212{
    230     RefPtr<InProcessIDBServer> protectedThis(this);
    231     RunLoop::current().dispatch([this, protectedThis, resourceIdentifier] {
     213    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resourceIdentifier] {
    232214        m_server->abortTransaction(resourceIdentifier);
    233215    });
     
    236218void InProcessIDBServer::commitTransaction(const IDBResourceIdentifier& resourceIdentifier)
    237219{
    238     RefPtr<InProcessIDBServer> protectedThis(this);
    239     RunLoop::current().dispatch([this, protectedThis, resourceIdentifier] {
     220    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resourceIdentifier] {
    240221        m_server->commitTransaction(resourceIdentifier);
    241222    });
     
    244225void InProcessIDBServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    245226{
    246     RefPtr<InProcessIDBServer> protectedThis(this);
    247     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier, transactionIdentifier] {
     227    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier, transactionIdentifier] {
    248228        m_server->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
    249229    });
     
    252232void InProcessIDBServer::createObjectStore(const IDBRequestData& resultData, const IDBObjectStoreInfo& info)
    253233{
    254     RefPtr<InProcessIDBServer> protectedThis(this);
    255     RunLoop::current().dispatch([this, protectedThis, resultData, info] {
     234    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), resultData, info] {
    256235        m_server->createObjectStore(resultData, info);
    257236    });
     
    260239void InProcessIDBServer::deleteObjectStore(const IDBRequestData& requestData, const String& objectStoreName)
    261240{
    262     RefPtr<InProcessIDBServer> protectedThis(this);
    263     RunLoop::current().dispatch([this, protectedThis, requestData, objectStoreName] {
     241    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, objectStoreName] {
    264242        m_server->deleteObjectStore(requestData, objectStoreName);
    265243    });
     
    268246void InProcessIDBServer::clearObjectStore(const IDBRequestData& requestData, uint64_t objectStoreIdentifier)
    269247{
    270     RefPtr<InProcessIDBServer> protectedThis(this);
    271     RunLoop::current().dispatch([this, protectedThis, requestData, objectStoreIdentifier] {
     248    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, objectStoreIdentifier] {
    272249        m_server->clearObjectStore(requestData, objectStoreIdentifier);
    273250    });
     
    276253void InProcessIDBServer::createIndex(const IDBRequestData& requestData, const IDBIndexInfo& info)
    277254{
    278     RefPtr<InProcessIDBServer> protectedThis(this);
    279     RunLoop::current().dispatch([this, protectedThis, requestData, info] {
     255    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, info] {
    280256        m_server->createIndex(requestData, info);
    281257    });
     
    284260void InProcessIDBServer::deleteIndex(const IDBRequestData& requestData, uint64_t objectStoreIdentifier, const String& indexName)
    285261{
    286     RefPtr<InProcessIDBServer> protectedThis(this);
    287     RunLoop::current().dispatch([this, protectedThis, requestData, objectStoreIdentifier, indexName] {
     262    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, objectStoreIdentifier, indexName] {
    288263        m_server->deleteIndex(requestData, objectStoreIdentifier, indexName);
    289264    });
     
    292267void InProcessIDBServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
    293268{
    294     RefPtr<InProcessIDBServer> protectedThis(this);
    295     RunLoop::current().dispatch([this, protectedThis, requestData, keyData, value, overwriteMode] {
     269    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, keyData, value, overwriteMode] {
    296270        m_server->putOrAdd(requestData, keyData, value, overwriteMode);
    297271    });
     
    300274void InProcessIDBServer::getRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
    301275{
    302     RefPtr<InProcessIDBServer> protectedThis(this);
    303 
    304     RunLoop::current().dispatch([this, protectedThis, requestData, keyRangeData] {
     276    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, keyRangeData] {
    305277        m_server->getRecord(requestData, keyRangeData);
    306278    });
     
    309281void InProcessIDBServer::getCount(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
    310282{
    311     RefPtr<InProcessIDBServer> protectedThis(this);
    312     RunLoop::current().dispatch([this, protectedThis, requestData, keyRangeData] {
     283    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, keyRangeData] {
    313284        m_server->getCount(requestData, keyRangeData);
    314285    });
     
    317288void InProcessIDBServer::deleteRecord(const IDBRequestData& requestData, const IDBKeyRangeData& keyRangeData)
    318289{
    319     RefPtr<InProcessIDBServer> protectedThis(this);
    320 
    321     RunLoop::current().dispatch([this, protectedThis, requestData, keyRangeData] {
     290    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, keyRangeData] {
    322291        m_server->deleteRecord(requestData, keyRangeData);
    323292    });
     
    326295void InProcessIDBServer::openCursor(const IDBRequestData& requestData, const IDBCursorInfo& info)
    327296{
    328     RefPtr<InProcessIDBServer> protectedThis(this);
    329 
    330     RunLoop::current().dispatch([this, protectedThis, requestData, info] {
     297    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, info] {
    331298        m_server->openCursor(requestData, info);
    332299    });
     
    335302void InProcessIDBServer::iterateCursor(const IDBRequestData& requestData, const IDBKeyData& key, unsigned long count)
    336303{
    337     RefPtr<InProcessIDBServer> protectedThis(this);
    338 
    339     RunLoop::current().dispatch([this, protectedThis, requestData, key, count] {
     304    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData, key, count] {
    340305        m_server->iterateCursor(requestData, key, count);
    341306    });
     
    344309void InProcessIDBServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
    345310{
    346     RefPtr<InProcessIDBServer> protectedThis(this);
    347 
    348     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier, info] {
     311    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier, info] {
    349312        m_server->establishTransaction(databaseConnectionIdentifier, info);
    350313    });
     
    353316void InProcessIDBServer::fireVersionChangeEvent(IDBServer::UniqueIDBDatabaseConnection& connection, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
    354317{
    355     RefPtr<InProcessIDBServer> protectedThis(this);
    356     uint64_t databaseConnectionIdentifier = connection.identifier();
    357     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier, requestIdentifier, requestedVersion] {
     318    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier = connection.identifier(), requestIdentifier, requestedVersion] {
    358319        m_connectionToServer->fireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, requestedVersion);
    359320    });
     
    362323void InProcessIDBServer::didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
    363324{
    364     RefPtr<InProcessIDBServer> protectedThis(this);
    365     RunLoop::current().dispatch([this, protectedThis, transactionIdentifier, error] {
     325    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), transactionIdentifier, error] {
    366326        m_connectionToServer->didStartTransaction(transactionIdentifier, error);
    367327    });
     
    370330void InProcessIDBServer::didCloseFromServer(IDBServer::UniqueIDBDatabaseConnection& connection, const IDBError& error)
    371331{
    372     RefPtr<InProcessIDBServer> protectedThis(this);
    373     uint64_t databaseConnectionIdentifier = connection.identifier();
    374     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier, error] {
     332    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier = connection.identifier(), error] {
    375333        m_connectionToServer->didCloseFromServer(databaseConnectionIdentifier, error);
    376334    });
     
    379337void InProcessIDBServer::notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
    380338{
    381     RefPtr<InProcessIDBServer> protectedThis(this);
    382     RunLoop::current().dispatch([this, protectedThis, requestIdentifier, oldVersion, newVersion] {
     339    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestIdentifier, oldVersion, newVersion] {
    383340        m_connectionToServer->notifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion);
    384341    });
     
    387344void InProcessIDBServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
    388345{
    389     RefPtr<InProcessIDBServer> protectedThis(this);
    390     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier] {
     346    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier] {
    391347        m_server->databaseConnectionClosed(databaseConnectionIdentifier);
    392348    });
     
    395351void InProcessIDBServer::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    396352{
    397     RefPtr<InProcessIDBServer> protectedThis(this);
    398     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier, transactionIdentifier] {
     353    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier, transactionIdentifier] {
    399354        m_server->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
    400355    });
     
    403358void InProcessIDBServer::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier)
    404359{
    405     RefPtr<InProcessIDBServer> protectedThis(this);
    406     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier, requestIdentifier] {
     360    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier, requestIdentifier] {
    407361        m_server->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
    408362    });
     
    411365void InProcessIDBServer::openDBRequestCancelled(const IDBRequestData& requestData)
    412366{
    413     RefPtr<InProcessIDBServer> protectedThis(this);
    414     RunLoop::current().dispatch([this, protectedThis, requestData] {
     367    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), requestData] {
    415368        m_server->openDBRequestCancelled(requestData);
    416369    });
     
    419372void InProcessIDBServer::confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier)
    420373{
    421     RefPtr<InProcessIDBServer> protectedThis(this);
    422     RunLoop::current().dispatch([this, protectedThis, databaseConnectionIdentifier] {
     374    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), databaseConnectionIdentifier] {
    423375        m_server->confirmDidCloseFromServer(databaseConnectionIdentifier);
    424376    });
     
    427379void InProcessIDBServer::getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID)
    428380{
    429     RefPtr<InProcessIDBServer> protectedThis(this);
    430     RunLoop::current().dispatch([this, protectedThis, mainFrameOrigin, openingOrigin, callbackID] {
     381    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), mainFrameOrigin, openingOrigin, callbackID] {
    431382        m_server->getAllDatabaseNames(m_connectionToServer->identifier(), mainFrameOrigin, openingOrigin, callbackID);
    432383    });
     
    435386void InProcessIDBServer::didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames)
    436387{
    437     RefPtr<InProcessIDBServer> protectedThis(this);
    438     RunLoop::current().dispatch([this, protectedThis, callbackID, databaseNames] {
     388    RunLoop::current().dispatch([this, protectedThis = Ref<InProcessIDBServer>(*this), callbackID, databaseNames] {
    439389        m_connectionToServer->didGetAllDatabaseNames(callbackID, databaseNames);
    440390    });
  • trunk/Source/WebCore/Modules/websockets/WebSocket.cpp

    r200895 r201575  
    284284            // constructor, we have to wait until the constructor has completed before firing the
    285285            // event; otherwise, users can't connect to the event.
    286             RunLoop::main().dispatch([this]() {
     286            RunLoop::main().dispatch([this, protectedThis = Ref<WebSocket>(*this)]() {
    287287                dispatchOrQueueErrorEvent();
    288288                stop();
  • trunk/Source/WebCore/bindings/js/SerializedScriptValue.cpp

    r201333 r201575  
    28242824
    28252825    IDBValue value;
    2826     IDBValue* valuePtr = &value;
    2827 
    28282826    Lock lock;
    28292827    Condition condition;
    2830     Condition* conditionPtr = &condition;
    28312828    lock.lock();
    28322829
    2833     RunLoop::main().dispatch([this, conditionPtr, valuePtr] {
     2830    RunLoop::main().dispatch([this, conditionPtr = &condition, valuePtr = &value] {
    28342831        writeBlobsToDiskForIndexedDB([conditionPtr, valuePtr](const IDBValue& result) {
    28352832            ASSERT(isMainThread());
  • trunk/Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp

    r200895 r201575  
    8484    // we need to release it on the main thread since it has member variables (such as timers)
    8585    // that expect to be destroyed from the main thread.
    86     ScrollingCoordinator* scrollingCoordinator = m_scrollingCoordinator.release().leakRef();
    87     RunLoop::main().dispatch([scrollingCoordinator] {
    88         scrollingCoordinator->deref();
     86    RunLoop::main().dispatch([scrollingCoordinator = WTFMove(m_scrollingCoordinator)] {
    8987    });
    9088}
     
    104102        setMainFrameScrollPosition(scrollPosition);
    105103
    106     RefPtr<AsyncScrollingCoordinator> scrollingCoordinator = m_scrollingCoordinator;
    107     bool localIsHandlingProgrammaticScroll = isHandlingProgrammaticScroll();
    108    
    109     RunLoop::main().dispatch([scrollingCoordinator, nodeID, scrollPosition, localIsHandlingProgrammaticScroll, scrollingLayerPositionAction] {
     104    RunLoop::main().dispatch([scrollingCoordinator = m_scrollingCoordinator, nodeID, scrollPosition, localIsHandlingProgrammaticScroll = isHandlingProgrammaticScroll(), scrollingLayerPositionAction] {
    110105        scrollingCoordinator->scheduleUpdateScrollPositionAfterAsyncScroll(nodeID, scrollPosition, localIsHandlingProgrammaticScroll, scrollingLayerPositionAction);
    111106    });
     
    117112        return;
    118113
    119     RefPtr<AsyncScrollingCoordinator> scrollingCoordinator = m_scrollingCoordinator;
    120     RunLoop::main().dispatch([scrollingCoordinator, nodeID, horizontal, vertical] {
     114    RunLoop::main().dispatch([scrollingCoordinator = m_scrollingCoordinator, nodeID, horizontal, vertical] {
    121115        scrollingCoordinator->setActiveScrollSnapIndices(nodeID, horizontal, vertical);
    122116    });
     
    129123        return;
    130124
    131     RefPtr<AsyncScrollingCoordinator> scrollingCoordinator = m_scrollingCoordinator;
    132     RunLoop::main().dispatch([scrollingCoordinator, phase] {
     125    RunLoop::main().dispatch([scrollingCoordinator = m_scrollingCoordinator, phase] {
    133126        scrollingCoordinator->handleWheelEventPhase(phase);
    134127    });
     
    140133        return;
    141134   
    142     RefPtr<AsyncScrollingCoordinator> scrollingCoordinator = m_scrollingCoordinator;
    143     RunLoop::main().dispatch([scrollingCoordinator, nodeID, horizontalIndex, verticalIndex] {
     135    RunLoop::main().dispatch([scrollingCoordinator = m_scrollingCoordinator, nodeID, horizontalIndex, verticalIndex] {
    144136        scrollingCoordinator->setActiveScrollSnapIndices(nodeID, horizontalIndex, verticalIndex);
    145137    });
     
    151143        return;
    152144
    153     RefPtr<AsyncScrollingCoordinator> scrollingCoordinator = m_scrollingCoordinator;
    154     RunLoop::main().dispatch([scrollingCoordinator, identifier, reason] {
     145    RunLoop::main().dispatch([scrollingCoordinator = m_scrollingCoordinator, identifier, reason] {
    155146        scrollingCoordinator->deferTestsForReason(identifier, reason);
    156147    });
     
    162153        return;
    163154   
    164     RefPtr<AsyncScrollingCoordinator> scrollingCoordinator = m_scrollingCoordinator;
    165     RunLoop::main().dispatch([scrollingCoordinator, identifier, reason] {
     155    RunLoop::main().dispatch([scrollingCoordinator = m_scrollingCoordinator, identifier, reason] {
    166156        scrollingCoordinator->removeTestDeferralForReason(identifier, reason);
    167157    });
  • trunk/Source/WebCore/platform/graphics/mac/DisplayRefreshMonitorMac.cpp

    r198745 r201575  
    102102    setMonotonicAnimationStartTime(webKitMonotonicNow + timeUntilOutput);
    103103
    104     auto weakPtr = m_weakFactory.createWeakPtr();
    105104
    106     RunLoop::main().dispatch([weakPtr] {
     105    // FIXME: Is it really okay to create a weakPtr on a background thread and then use it on the main thread?
     106    RunLoop::main().dispatch([weakPtr = m_weakFactory.createWeakPtr()] {
    107107        if (auto* monitor = weakPtr.get())
    108108            handleDisplayRefreshedNotificationOnMainThread(monitor);
  • trunk/Source/WebCore/platform/network/DataURLDecoder.cpp

    r201482 r201575  
    136136
    137137    return std::make_unique<DecodeTask>(DecodeTask {
    138         WTFMove(urlString),
     138        urlString.isolatedCopy(),
    139139        WTFMove(encodedData),
    140140        isBase64,
     
    173173    ASSERT(url.protocolIsData());
    174174
    175     auto decodeTask = createDecodeTask(url, scheduleContext, WTFMove(completionHandler));
    176     decodeQueue().dispatch([decodeTask = WTFMove(decodeTask)]() mutable {
     175    decodeQueue().dispatch([decodeTask = createDecodeTask(url, scheduleContext, WTFMove(completionHandler))]() mutable {
    177176        if (decodeTask->isBase64)
    178177            decodeBase64(*decodeTask);
  • trunk/Source/WebKit2/ChangeLog

    r201542 r201575  
     12016-06-01  Brady Eidson  <beidson@apple.com>
     2
     3        Modernize lambda usage for all callers of RunLoop::dispatch().
     4        https://bugs.webkit.org/show_bug.cgi?id=158265
     5
     6        Reviewed by Chris Dumez.
     7
     8        * DatabaseProcess/DatabaseProcess.cpp:
     9        (WebKit::DatabaseProcess::fetchWebsiteData):
     10        (WebKit::DatabaseProcess::deleteWebsiteData):
     11        (WebKit::DatabaseProcess::deleteWebsiteDataForOrigins):
     12       
     13        * NetworkProcess/NetworkProcess.cpp:
     14        (WebKit::fetchDiskCacheEntries):
     15        (WebKit::NetworkProcess::fetchWebsiteData):
     16       
     17        * NetworkProcess/cache/NetworkCacheStorage.cpp:
     18        (WebKit::NetworkCache::Storage::remove):
     19        (WebKit::NetworkCache::retrieveFromMemory):
     20       
     21        * Platform/IPC/Connection.cpp:
     22        (IPC::Connection::SyncMessageState::processIncomingMessage):
     23        (IPC::Connection::processIncomingMessage):
     24        (IPC::Connection::connectionDidClose):
     25        (IPC::Connection::enqueueIncomingMessage):
     26        * Platform/IPC/mac/ConnectionMac.mm:
     27        (IPC::Connection::receiveSourceEventHandler):
     28       
     29        * Shared/mac/CookieStorageShim.mm:
     30        (-[WKNSURLSessionLocal _getCookieHeadersForTask:completionHandler:]):
     31        * UIProcess/API/APIUserContentExtensionStore.cpp:
     32        (API::UserContentExtensionStore::lookupContentExtension):
     33        (API::UserContentExtensionStore::compileContentExtension):
     34        (API::UserContentExtensionStore::removeContentExtension):
     35       
     36        * UIProcess/Launcher/ProcessLauncher.cpp:
     37        (WebKit::ProcessLauncher::ProcessLauncher):
     38        * UIProcess/Launcher/mac/ProcessLauncherMac.mm:
     39        (WebKit::connectToService):
     40       
     41        * UIProcess/Storage/StorageManager.cpp:
     42        (WebKit::StorageManager::getSessionStorageOrigins):
     43        (WebKit::StorageManager::deleteSessionStorageOrigins):
     44        (WebKit::StorageManager::deleteSessionStorageEntriesForOrigins):
     45        (WebKit::StorageManager::getLocalStorageOrigins):
     46        (WebKit::StorageManager::getLocalStorageOriginDetails):
     47        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigin):
     48        (WebKit::StorageManager::deleteLocalStorageOriginsModifiedSince):
     49        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigins):
     50       
     51        * UIProcess/WebPageProxy.cpp:
     52        (WebKit::WebPageProxy::isWebProcessResponsive):
     53       
     54        * UIProcess/WebProcessProxy.cpp:
     55        (WebKit::WebProcessProxy::isResponsive):
     56       
     57        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
     58        (WebKit::WebsiteDataStore::fetchData):
     59       
     60        * WebProcess/Plugins/Netscape/NetscapePlugin.cpp:
     61        (WebKit::NetscapePlugin::pluginThreadAsyncCall):
     62       
     63        * WebProcess/Plugins/PluginView.cpp:
     64        (WebKit::PluginView::unprotectPluginFromDestruction):
     65       
     66        * WebProcess/WebPage/EventDispatcher.cpp:
     67        (WebKit::EventDispatcher::wheelEvent):
     68        (WebKit::EventDispatcher::gestureEvent):
     69        (WebKit::EventDispatcher::touchEvent):
     70       
     71        * WebProcess/WebPage/ViewUpdateDispatcher.cpp:
     72        (WebKit::ViewUpdateDispatcher::visibleContentRectUpdate):
     73
    1742016-05-31  Yusuke Suzuki  <utatane.tea@gmail.com>
    275
  • trunk/Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp

    r201518 r201575  
    195195void DatabaseProcess::fetchWebsiteData(SessionID, OptionSet<WebsiteDataType> websiteDataTypes, uint64_t callbackID)
    196196{
    197     struct CallbackAggregator final : public ThreadSafeRefCounted<CallbackAggregator> {
    198         explicit CallbackAggregator(std::function<void (WebsiteData)> completionHandler)
    199             : m_completionHandler(WTFMove(completionHandler))
    200         {
    201         }
    202 
    203         ~CallbackAggregator()
    204         {
    205             ASSERT(RunLoop::isMain());
    206 
    207             auto completionHandler = WTFMove(m_completionHandler);
    208             auto websiteData = WTFMove(m_websiteData);
    209 
    210             RunLoop::main().dispatch([completionHandler, websiteData] {
     197    auto completionHandler = [this, callbackID](const WebsiteData& websiteData) {
     198        parentProcessConnection()->send(Messages::DatabaseProcessProxy::DidFetchWebsiteData(callbackID, websiteData), 0);
     199    };
     200
     201#if ENABLE(INDEXED_DATABASE)
     202    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
     203        // FIXME: Pick the right database store based on the session ID.
     204        postDatabaseTask(CrossThreadTask([this, websiteDataTypes, completionHandler = WTFMove(completionHandler)]() mutable {
     205            RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), securityOrigins = indexedDatabaseOrigins()] {
     206                WebsiteData websiteData;
     207                for (const auto& securityOrigin : securityOrigins)
     208                    websiteData.entries.append({ securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
     209
    211210                completionHandler(websiteData);
    212211            });
    213         }
    214 
    215         std::function<void (WebsiteData)> m_completionHandler;
    216         WebsiteData m_websiteData;
     212        }));
     213    }
     214#endif
     215}
     216
     217void DatabaseProcess::deleteWebsiteData(WebCore::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, std::chrono::system_clock::time_point modifiedSince, uint64_t callbackID)
     218{
     219    auto completionHandler = [this, callbackID]() {
     220        parentProcessConnection()->send(Messages::DatabaseProcessProxy::DidDeleteWebsiteData(callbackID), 0);
    217221    };
    218222
    219     RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator([this, callbackID](WebsiteData websiteData) {
    220         parentProcessConnection()->send(Messages::DatabaseProcessProxy::DidFetchWebsiteData(callbackID, websiteData), 0);
    221     }));
    222 
    223 #if ENABLE(INDEXED_DATABASE)
    224     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
    225         // FIXME: Pick the right database store based on the session ID.
    226         postDatabaseTask(CrossThreadTask([callbackAggregator, websiteDataTypes, this] {
    227 
    228             Vector<RefPtr<SecurityOrigin>> securityOrigins = indexedDatabaseOrigins();
    229 
    230             RunLoop::main().dispatch([callbackAggregator, securityOrigins] {
    231                 for (const auto& securityOrigin : securityOrigins)
    232                     callbackAggregator->m_websiteData.entries.append(WebsiteData::Entry { securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
    233             });
    234         }));
    235     }
    236 #endif
    237 }
    238 
    239 void DatabaseProcess::deleteWebsiteData(WebCore::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, std::chrono::system_clock::time_point modifiedSince, uint64_t callbackID)
    240 {
    241     struct CallbackAggregator final : public ThreadSafeRefCounted<CallbackAggregator> {
    242         explicit CallbackAggregator(std::function<void ()> completionHandler)
    243             : m_completionHandler(WTFMove(completionHandler))
    244         {
    245         }
    246 
    247         ~CallbackAggregator()
    248         {
    249             ASSERT(RunLoop::isMain());
    250 
    251             RunLoop::main().dispatch(WTFMove(m_completionHandler));
    252         }
    253 
    254         std::function<void ()> m_completionHandler;
     223#if ENABLE(INDEXED_DATABASE)
     224    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
     225        idbServer().closeAndDeleteDatabasesModifiedSince(modifiedSince, WTFMove(completionHandler));
     226#endif
     227}
     228
     229void DatabaseProcess::deleteWebsiteDataForOrigins(WebCore::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<SecurityOriginData>& securityOriginDatas, uint64_t callbackID)
     230{
     231    auto completionHandler = [this, callbackID]() {
     232        parentProcessConnection()->send(Messages::DatabaseProcessProxy::DidDeleteWebsiteDataForOrigins(callbackID), 0);
    255233    };
    256234
    257     RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator([this, callbackID]() {
    258         parentProcessConnection()->send(Messages::DatabaseProcessProxy::DidDeleteWebsiteData(callbackID), 0);
    259     }));
    260 
    261235#if ENABLE(INDEXED_DATABASE)
    262236    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
    263         idbServer().closeAndDeleteDatabasesModifiedSince(modifiedSince, [callbackAggregator] { });
    264 #endif
    265 }
    266 
    267 void DatabaseProcess::deleteWebsiteDataForOrigins(WebCore::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<SecurityOriginData>& securityOriginDatas, uint64_t callbackID)
    268 {
    269     struct CallbackAggregator final : public ThreadSafeRefCounted<CallbackAggregator> {
    270         explicit CallbackAggregator(std::function<void ()> completionHandler)
    271             : m_completionHandler(WTFMove(completionHandler))
    272         {
    273         }
    274 
    275         ~CallbackAggregator()
    276         {
    277             ASSERT(RunLoop::isMain());
    278 
    279             RunLoop::main().dispatch(WTFMove(m_completionHandler));
    280         }
    281 
    282         std::function<void ()> m_completionHandler;
    283     };
    284 
    285     RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator([this, callbackID]() {
    286         parentProcessConnection()->send(Messages::DatabaseProcessProxy::DidDeleteWebsiteDataForOrigins(callbackID), 0);
    287     }));
    288 
    289 #if ENABLE(INDEXED_DATABASE)
    290     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
    291         idbServer().closeAndDeleteDatabasesForOrigins(securityOriginDatas, [callbackAggregator] { });
     237        idbServer().closeAndDeleteDatabasesForOrigins(securityOriginDatas, WTFMove(completionHandler));
    292238#endif
    293239}
  • trunk/Source/WebKit2/NetworkProcess/NetworkProcess.cpp

    r201464 r201575  
    327327                delete originsAndSizes;
    328328
    329                 RunLoop::main().dispatch([completionHandler, entries] {
     329                RunLoop::main().dispatch([completionHandler, entries = WTFMove(entries)] {
    330330                    completionHandler(entries);
    331331                });
     
    351351#endif
    352352
    353     RunLoop::main().dispatch([completionHandler, entries] {
     353    RunLoop::main().dispatch([completionHandler, entries = WTFMove(entries)] {
    354354        completionHandler(entries);
    355355    });
     
    368368            ASSERT(RunLoop::isMain());
    369369
    370             auto completionHandler = WTFMove(m_completionHandler);
    371             auto websiteData = WTFMove(m_websiteData);
    372 
    373             RunLoop::main().dispatch([completionHandler, websiteData] {
     370            RunLoop::main().dispatch([completionHandler = WTFMove(m_completionHandler), websiteData = WTFMove(m_websiteData)] {
    374371                completionHandler(websiteData);
    375372            });
  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheStorage.cpp

    r201484 r201575  
    663663        if (operation->record.key == key) {
    664664            LOG(NetworkCacheStorage, "(NetworkProcess) found write operation in progress");
    665             auto record = operation->record;
    666             RunLoop::main().dispatch([record, completionHandler] {
     665            RunLoop::main().dispatch([record = operation->record, completionHandler = WTFMove(completionHandler)] {
    667666                completionHandler(std::make_unique<Storage::Record>(record));
    668667            });
  • trunk/Source/WebKit2/Platform/IPC/Connection.cpp

    r201464 r201575  
    137137       
    138138        if (m_didScheduleDispatchMessagesWorkSet.add(&connection).isNewEntry) {
    139             RefPtr<Connection> protectedConnection(&connection);
    140             RunLoop::main().dispatch([this, protectedConnection] {
    141                 dispatchMessageAndResetDidScheduleDispatchMessagesForConnection(*protectedConnection);
     139            RunLoop::main().dispatch([this, protectedConnection = Ref<Connection>(connection)]() mutable {
     140                dispatchMessageAndResetDidScheduleDispatchMessagesForConnection(protectedConnection);
    142141            });
    143142        }
     
    648647    if (!m_workQueueMessageReceivers.isValidKey(message->messageReceiverName())) {
    649648        RefPtr<Connection> protectedThis(this);
    650         StringReference messageReceiverName = message->messageReceiverName();
    651         StringCapture capturedMessageReceiverName(messageReceiverName.isEmpty() ? "<unknown message receiver>" : String(messageReceiverName.data(), messageReceiverName.size()));
    652         StringReference messageName = message->messageName();
    653         StringCapture capturedMessageName(messageName.isEmpty() ? "<unknown message>" : String(messageName.data(), messageName.size()));
    654 
    655         RunLoop::main().dispatch([protectedThis, capturedMessageReceiverName, capturedMessageName] {
    656             protectedThis->dispatchDidReceiveInvalidMessage(capturedMessageReceiverName.string().utf8(), capturedMessageName.string().utf8());
     649        StringReference messageReceiverNameReference = message->messageReceiverName();
     650        String messageReceiverName(messageReceiverNameReference.isEmpty() ? "<unknown message receiver>" : String(messageReceiverNameReference.data(), messageReceiverNameReference.size()));
     651        StringReference messageNameReference = message->messageName();
     652        String messageName(messageNameReference.isEmpty() ? "<unknown message>" : String(messageNameReference.data(), messageNameReference.size()));
     653
     654        RunLoop::main().dispatch([protectedThis = Ref<Connection>(*this), messageReceiverName = WTFMove(messageReceiverName), messageName = WTFMove(messageName)]() mutable {
     655            protectedThis->dispatchDidReceiveInvalidMessage(messageReceiverName.utf8(), messageName.utf8());
    657656        });
    658657        return;
     
    783782        m_didCloseOnConnectionWorkQueueCallback(this);
    784783
    785     RefPtr<Connection> connection(this);
    786     RunLoop::main().dispatch([connection] {
     784    RunLoop::main().dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
    787785        // If the connection has been explicitly invalidated before dispatchConnectionDidClose was called,
    788786        // then the client will be null here.
    789         if (!connection->m_client)
     787        if (!protectedThis->m_client)
    790788            return;
    791789
     
    793791        // the client before calling didClose here. Otherwise, sendSync will try to send a message to the connection and
    794792        // will then wait indefinitely for a reply.
    795         Client* client = connection->m_client;
    796         connection->m_client = nullptr;
    797 
    798         client->didClose(*connection);
     793        Client* client = protectedThis->m_client;
     794        protectedThis->m_client = nullptr;
     795
     796        client->didClose(protectedThis.get());
    799797    });
    800798}
     
    889887    }
    890888
    891     RefPtr<Connection> protectedThis(this);
    892     RunLoop::main().dispatch([protectedThis] {
     889    RunLoop::main().dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
    893890        protectedThis->dispatchOneMessage();
    894891    });
  • trunk/Source/WebKit2/Platform/IPC/mac/ConnectionMac.mm

    r195990 r201575  
    519519        if (m_isServer) {
    520520            // Server connections aren't supposed to have their exception ports overriden. Treat this as an invalid message.
    521             RefPtr<Connection> protectedThis(this);
    522             StringReference messageReceiverName = decoder->messageReceiverName();
    523             StringCapture capturedMessageReceiverName(String(messageReceiverName.data(), messageReceiverName.size()));
    524             StringReference messageName = decoder->messageName();
    525             StringCapture capturedMessageName(String(messageName.data(), messageName.size()));
    526             RunLoop::main().dispatch([protectedThis, capturedMessageReceiverName, capturedMessageName] {
    527                 protectedThis->dispatchDidReceiveInvalidMessage(capturedMessageReceiverName.string().utf8(), capturedMessageName.string().utf8());
     521            StringReference messageReceiverNameReference = decoder->messageReceiverName();
     522            String messageReceiverName(String(messageReceiverNameReference.data(), messageReceiverNameReference.size()));
     523            StringReference messageNameReference = decoder->messageName();
     524            String messageName(String(messageNameReference.data(), messageNameReference.size()));
     525
     526            RunLoop::main().dispatch([protectedThis = Ref<Connection>(*this), messageReceiverName = WTFMove(messageReceiverName), messageName = WTFMove(messageName)]() mutable {
     527                protectedThis->dispatchDidReceiveInvalidMessage(messageReceiverName.utf8(), messageName.utf8());
    528528            });
    529529            return;
  • trunk/Source/WebKit2/Shared/mac/CookieStorageShim.mm

    r192697 r201575  
    124124    }
    125125
    126     RetainPtr<NSURLSessionTask> strongTask = task;
    127126    CompletionHandlerBlock completionHandlerCopy = [completionHandler copy];
    128     RunLoop::main().dispatch([strongTask, completionHandlerCopy] {
    129         RetainPtr<CFDictionaryRef> headers = adoptCF(WebKit::webKitCookieStorageCopyRequestHeaderFieldsForURL(nullptr, (CFURLRef)[[strongTask currentRequest] URL]));
     127    RunLoop::main().dispatch([task = RetainPtr<NSURLSessionTask>(task), completionHandlerCopy] {
     128        RetainPtr<CFDictionaryRef> headers = adoptCF(WebKit::webKitCookieStorageCopyRequestHeaderFieldsForURL(nullptr, (CFURLRef)[[task currentRequest] URL]));
    130129        completionHandlerCopy(headers.get());
    131130        [completionHandlerCopy release];
  • trunk/Source/WebKit2/UIProcess/API/APIUserContentExtensionStore.cpp

    r201457 r201575  
    307307void UserContentExtensionStore::lookupContentExtension(const WTF::String& identifier, std::function<void(RefPtr<API::UserContentExtension>, std::error_code)> completionHandler)
    308308{
    309     RefPtr<UserContentExtensionStore> self(this);
    310     StringCapture identifierCapture(identifier);
    311     StringCapture pathCapture(m_storePath);
    312 
    313     m_readQueue->dispatch([self, identifierCapture, pathCapture, completionHandler] {
    314         auto path = constructedPath(pathCapture.string(), identifierCapture.string());
     309    m_readQueue->dispatch([protectedThis = Ref<Object>(*this), identifier = identifier.isolatedCopy(), storePath = m_storePath.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
     310        auto path = constructedPath(storePath, identifier);
    315311       
    316312        ContentExtensionMetaData metaData;
    317313        Data fileData;
    318314        if (!openAndMapContentExtension(path, metaData, fileData)) {
    319             RunLoop::main().dispatch([self, completionHandler] {
     315            RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)] {
    320316                completionHandler(nullptr, Error::LookupFailed);
    321317            });
     
    324320       
    325321        if (metaData.version != UserContentExtensionStore::CurrentContentExtensionFileVersion) {
    326             RunLoop::main().dispatch([self, completionHandler] {
     322            RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)] {
    327323                completionHandler(nullptr, Error::VersionMismatch);
    328324            });
     
    330326        }
    331327       
    332         RunLoop::main().dispatch([self, identifierCapture, fileData, metaData, completionHandler] {
    333             RefPtr<API::UserContentExtension> userContentExtension = createExtension(identifierCapture.string(), metaData, fileData);
     328        RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), identifier = WTFMove(identifier), fileData = WTFMove(fileData), metaData = WTFMove(metaData), completionHandler = WTFMove(completionHandler)] {
     329            RefPtr<API::UserContentExtension> userContentExtension = createExtension(identifier, metaData, fileData);
    334330            completionHandler(userContentExtension, { });
    335331        });
     
    339335void UserContentExtensionStore::compileContentExtension(const WTF::String& identifier, WTF::String&& json, std::function<void(RefPtr<API::UserContentExtension>, std::error_code)> completionHandler)
    340336{
    341     RefPtr<UserContentExtensionStore> self(this);
    342     StringCapture identifierCapture(identifier);
    343     StringCapture jsonCapture(WTFMove(json));
    344     StringCapture pathCapture(m_storePath);
    345 
    346     m_compileQueue->dispatch([self, identifierCapture, jsonCapture, pathCapture, completionHandler] () mutable {
    347         auto path = constructedPath(pathCapture.string(), identifierCapture.string());
     337    m_compileQueue->dispatch([protectedThis = Ref<Object>(*this), identifier = identifier.isolatedCopy(), json = json.isolatedCopy(), storePath = m_storePath.isolatedCopy(), completionHandler = WTFMove(completionHandler)] () mutable {
     338        auto path = constructedPath(storePath, identifier);
    348339
    349340        ContentExtensionMetaData metaData;
    350341        Data fileData;
    351         auto error = compiledToFile(jsonCapture.releaseString(), path, metaData, fileData);
     342        auto error = compiledToFile(WTFMove(json), path, metaData, fileData);
    352343        if (error) {
    353             RunLoop::main().dispatch([self, error, completionHandler] {
     344            RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), error = WTFMove(error), completionHandler = WTFMove(completionHandler)] {
    354345                completionHandler(nullptr, error);
    355346            });
     
    357348        }
    358349
    359         RunLoop::main().dispatch([self, identifierCapture, fileData, metaData, completionHandler] {
    360             RefPtr<API::UserContentExtension> userContentExtension = createExtension(identifierCapture.string(), metaData, fileData);
     350        RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), identifier = WTFMove(identifier), fileData = WTFMove(fileData), metaData = WTFMove(metaData), completionHandler = WTFMove(completionHandler)] {
     351            RefPtr<API::UserContentExtension> userContentExtension = createExtension(identifier, metaData, fileData);
    361352            completionHandler(userContentExtension, { });
    362353        });
     
    366357void UserContentExtensionStore::removeContentExtension(const WTF::String& identifier, std::function<void(std::error_code)> completionHandler)
    367358{
    368     RefPtr<UserContentExtensionStore> self(this);
    369     StringCapture identifierCapture(identifier);
    370     StringCapture pathCapture(m_storePath);
    371 
    372     m_removeQueue->dispatch([self, identifierCapture, pathCapture, completionHandler] {
    373         auto path = constructedPath(pathCapture.string(), identifierCapture.string());
     359    m_removeQueue->dispatch([protectedThis = Ref<Object>(*this), identifier = identifier.isolatedCopy(), storePath = m_storePath.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
     360        auto path = constructedPath(storePath, identifier);
    374361
    375362        if (!WebCore::deleteFile(path)) {
    376             RunLoop::main().dispatch([self, completionHandler] {
     363            RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)] {
    377364                completionHandler(Error::RemoveFailed);
    378365            });
     
    380367        }
    381368
    382         RunLoop::main().dispatch([self, completionHandler] {
     369        RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)] {
    383370            completionHandler({ });
    384371        });
  • trunk/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.cpp

    r196661 r201575  
    4646    m_isLaunching = true;
    4747
    48     RefPtr<ProcessLauncher> processLauncher(this);
    49     processLauncherWorkQueue().dispatch([processLauncher] {
     48    processLauncherWorkQueue().dispatch([processLauncher = Ref<ProcessLauncher>(*this)]() mutable {
    5049        processLauncher->launchProcess();
    5150    });
  • trunk/Source/WebKit2/UIProcess/Launcher/mac/ProcessLauncherMac.mm

    r201038 r201575  
    181181            mach_port_mod_refs(mach_task_self(), listeningPort, MACH_PORT_RIGHT_RECEIVE, -1);
    182182
    183             RefPtr<ProcessLauncher> protector(that);
    184             RunLoop::main().dispatch([protector, didFinishLaunchingProcessFunction] {
    185                 (*protector.*didFinishLaunchingProcessFunction)(0, IPC::Connection::Identifier());
     183            RunLoop::main().dispatch([protectedThat = RefPtr<ProcessLauncher>(that), didFinishLaunchingProcessFunction]() mutable {
     184                (*protectedThat.*didFinishLaunchingProcessFunction)(0, IPC::Connection::Identifier());
    186185            });
    187186        } else {
     
    193192
    194193            // We've finished launching the process, message back to the main run loop. This takes ownership of the connection.
    195             RefPtr<ProcessLauncher> protector(that);
    196             RunLoop::main().dispatch([protector, didFinishLaunchingProcessFunction, processIdentifier, listeningPort, connection] {
    197                 (*protector.*didFinishLaunchingProcessFunction)(processIdentifier, IPC::Connection::Identifier(listeningPort, connection));
     194            RunLoop::main().dispatch([protectedThat = RefPtr<ProcessLauncher>(that), didFinishLaunchingProcessFunction, processIdentifier, listeningPort, connection] {
     195                (*protectedThat.*didFinishLaunchingProcessFunction)(processIdentifier, IPC::Connection::Identifier(listeningPort, connection));
    198196            });
    199197        }
  • trunk/Source/WebKit2/UIProcess/Storage/StorageManager.cpp

    r201464 r201575  
    558558    RefPtr<StorageManager> storageManager(this);
    559559
    560     m_queue->dispatch([storageManager, completionHandler = WTFMove(completionHandler)]() mutable {
     560    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), completionHandler = WTFMove(completionHandler)]() mutable {
    561561        HashSet<RefPtr<SecurityOrigin>> origins;
    562562
    563         for (const auto& sessionStorageNamespace : storageManager->m_sessionStorageNamespaces.values()) {
     563        for (const auto& sessionStorageNamespace : m_sessionStorageNamespaces.values()) {
    564564            for (auto& origin : sessionStorageNamespace->origins())
    565565                origins.add(WTFMove(origin));
    566566        }
    567567
    568         RunLoop::main().dispatch([origins, completionHandler = WTFMove(completionHandler)]() mutable {
     568        RunLoop::main().dispatch([origins = WTFMove(origins), completionHandler = WTFMove(completionHandler)]() mutable {
    569569            completionHandler(WTFMove(origins));
    570570        });
     
    574574void StorageManager::deleteSessionStorageOrigins(std::function<void ()>&& completionHandler)
    575575{
    576     RefPtr<StorageManager> storageManager(this);
    577 
    578     m_queue->dispatch([storageManager, completionHandler = WTFMove(completionHandler)]() mutable {
    579         for (auto& sessionStorageNamespace : storageManager->m_sessionStorageNamespaces.values())
     576    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), completionHandler = WTFMove(completionHandler)]() mutable {
     577        for (auto& sessionStorageNamespace : m_sessionStorageNamespaces.values())
    580578            sessionStorageNamespace->clearAllStorageAreas();
    581579
     
    592590        copiedOrigins.uncheckedAppend(origin->isolatedCopy());
    593591
    594     RefPtr<StorageManager> storageManager(this);
    595     m_queue->dispatch([storageManager, copiedOrigins, completionHandler = WTFMove(completionHandler)]() mutable {
     592    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), copiedOrigins = WTFMove(copiedOrigins), completionHandler = WTFMove(completionHandler)]() mutable {
    596593        for (auto& origin : copiedOrigins) {
    597             for (auto& sessionStorageNamespace : storageManager->m_sessionStorageNamespaces.values())
     594            for (auto& sessionStorageNamespace : m_sessionStorageNamespaces.values())
    598595                sessionStorageNamespace->clearStorageAreasMatchingOrigin(*origin);
    599596        }
     
    605602void StorageManager::getLocalStorageOrigins(std::function<void (HashSet<RefPtr<WebCore::SecurityOrigin>>&&)>&& completionHandler)
    606603{
    607     RefPtr<StorageManager> storageManager(this);
    608 
    609     m_queue->dispatch([storageManager, completionHandler = WTFMove(completionHandler)]() mutable {
     604    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), completionHandler = WTFMove(completionHandler)]() mutable {
    610605        HashSet<RefPtr<SecurityOrigin>> origins;
    611606
    612         for (auto& origin : storageManager->m_localStorageDatabaseTracker->origins())
     607        for (auto& origin : m_localStorageDatabaseTracker->origins())
    613608            origins.add(WTFMove(origin));
    614609
    615         for (auto& transientLocalStorageNamespace : storageManager->m_transientLocalStorageNamespaces.values()) {
     610        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values()) {
    616611            for (auto& origin : transientLocalStorageNamespace->origins())
    617612                origins.add(WTFMove(origin));
    618613        }
    619614
    620         RunLoop::main().dispatch([origins, completionHandler = WTFMove(completionHandler)]() mutable {
     615        RunLoop::main().dispatch([origins = WTFMove(origins), completionHandler = WTFMove(completionHandler)]() mutable {
    621616            completionHandler(WTFMove(origins));
    622617        });
     
    626621void StorageManager::getLocalStorageOriginDetails(std::function<void (Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler)
    627622{
    628     RefPtr<StorageManager> storageManager(this);
    629 
    630     m_queue->dispatch([storageManager, completionHandler = WTFMove(completionHandler)]() mutable {
    631         auto originDetails = storageManager->m_localStorageDatabaseTracker->originDetails();
    632 
    633         RunLoop::main().dispatch([originDetails, completionHandler = WTFMove(completionHandler)]() mutable {
     623    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), completionHandler = WTFMove(completionHandler)]() mutable {
     624        auto originDetails = m_localStorageDatabaseTracker->originDetails();
     625
     626        RunLoop::main().dispatch([originDetails = WTFMove(originDetails), completionHandler = WTFMove(completionHandler)]() mutable {
    634627            completionHandler(WTFMove(originDetails));
    635628        });
     
    639632void StorageManager::deleteLocalStorageEntriesForOrigin(const SecurityOrigin& securityOrigin)
    640633{
    641     RefPtr<StorageManager> storageManager(this);
    642 
    643     RefPtr<SecurityOrigin> copiedOrigin = securityOrigin.isolatedCopy();
    644     m_queue->dispatch([storageManager, copiedOrigin] {
    645         for (auto& localStorageNamespace : storageManager->m_localStorageNamespaces.values())
    646             localStorageNamespace->clearStorageAreasMatchingOrigin(*copiedOrigin);
    647 
    648         for (auto& transientLocalStorageNamespace : storageManager->m_transientLocalStorageNamespaces.values())
    649             transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(*copiedOrigin);
    650 
    651         storageManager->m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(copiedOrigin.get());
     634    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), copiedOrigin = securityOrigin.isolatedCopy()]() mutable {
     635        for (auto& localStorageNamespace : m_localStorageNamespaces.values())
     636            localStorageNamespace->clearStorageAreasMatchingOrigin(copiedOrigin);
     637
     638        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
     639            transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(copiedOrigin);
     640
     641        m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(copiedOrigin.ptr());
    652642    });
    653643}
     
    655645void StorageManager::deleteLocalStorageOriginsModifiedSince(std::chrono::system_clock::time_point time, std::function<void ()>&& completionHandler)
    656646{
    657     RefPtr<StorageManager> storageManager(this);
    658 
    659     m_queue->dispatch([storageManager, time, completionHandler = WTFMove(completionHandler)]() mutable {
    660         auto deletedOrigins = storageManager->m_localStorageDatabaseTracker->deleteDatabasesModifiedSince(time);
     647    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), time, completionHandler = WTFMove(completionHandler)]() mutable {
     648        auto deletedOrigins = m_localStorageDatabaseTracker->deleteDatabasesModifiedSince(time);
    661649
    662650        for (const auto& origin : deletedOrigins) {
    663             for (auto& localStorageNamespace : storageManager->m_localStorageNamespaces.values())
     651            for (auto& localStorageNamespace : m_localStorageNamespaces.values())
    664652                localStorageNamespace->clearStorageAreasMatchingOrigin(origin.get());
    665653        }
    666654
    667         for (auto& transientLocalStorageNamespace : storageManager->m_transientLocalStorageNamespaces.values())
     655        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
    668656            transientLocalStorageNamespace->clearAllStorageAreas();
    669657
     
    680668        copiedOrigins.uncheckedAppend(origin->isolatedCopy());
    681669
    682     RefPtr<StorageManager> storageManager(this);
    683     m_queue->dispatch([storageManager, copiedOrigins, completionHandler = WTFMove(completionHandler)]() mutable {
     670    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), copiedOrigins = WTFMove(copiedOrigins), completionHandler = WTFMove(completionHandler)]() mutable {
    684671        for (auto& origin : copiedOrigins) {
    685             for (auto& localStorageNamespace : storageManager->m_localStorageNamespaces.values())
     672            for (auto& localStorageNamespace : m_localStorageNamespaces.values())
    686673                localStorageNamespace->clearStorageAreasMatchingOrigin(*origin);
    687674
    688             for (auto& transientLocalStorageNamespace : storageManager->m_transientLocalStorageNamespaces.values())
     675            for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
    689676                transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(*origin);
    690677
    691             storageManager->m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin.get());
     678            m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin.get());
    692679        }
    693680
  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r201298 r201575  
    27152715{
    27162716    if (!isValid()) {
    2717         RunLoop::main().dispatch([callbackFunction] {
     2717        RunLoop::main().dispatch([callbackFunction = WTFMove(callbackFunction)] {
    27182718            bool isWebProcessResponsive = true;
    27192719            callbackFunction(isWebProcessResponsive);
  • trunk/Source/WebKit2/UIProcess/WebProcessProxy.cpp

    r197563 r201575  
    999999    if (m_isResponsive == NoOrMaybe::No) {
    10001000        if (callback) {
    1001             RunLoop::main().dispatch([callback] {
     1001            RunLoop::main().dispatch([callback = WTFMove(callback)] {
    10021002                bool isWebProcessResponsive = false;
    10031003                callback(isWebProcessResponsive);
  • trunk/Source/WebKit2/UIProcess/WebsiteData/WebsiteDataStore.cpp

    r201354 r201575  
    236236                return;
    237237
    238             RefPtr<CallbackAggregator> callbackAggregator(this);
    239             RunLoop::main().dispatch([callbackAggregator] {
     238            RunLoop::main().dispatch([callbackAggregator = Ref<CallbackAggregator>(*this)]() mutable {
    240239
    241240                WTF::Vector<WebsiteDataRecord> records;
     
    266265        m_queue->dispatch([fetchOptions, mediaCacheDirectory, callbackAggregator] {
    267266            HashSet<RefPtr<WebCore::SecurityOrigin>> origins = WebCore::HTMLMediaElement::originsInMediaCache(mediaCacheDirectory.string());
    268             WebsiteData* websiteData = new WebsiteData;
     267            WebsiteData websiteData;
    269268           
    270269            for (auto& origin : origins) {
    271270                WebsiteData::Entry entry { origin, WebsiteDataType::DiskCache, 0 };
    272                 websiteData->entries.append(WTFMove(entry));
     271                websiteData.entries.append(WTFMove(entry));
    273272            }
    274273           
    275             WTF::RunLoop::main().dispatch([callbackAggregator, origins, websiteData] {
    276                 callbackAggregator->removePendingCallback(WTFMove(*websiteData));
    277                
    278                 delete websiteData;
     274            RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins), websiteData = WTFMove(websiteData)]() mutable {
     275                callbackAggregator->removePendingCallback(WTFMove(websiteData));
    279276            });
    280277        });
     
    366363            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory.string(), applicationCacheFlatFileSubdirectoryName.string());
    367364
    368             WebsiteData* websiteData = new WebsiteData;
     365            WebsiteData websiteData;
    369366
    370367            HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
     
    375372                WebsiteData::Entry entry { origin, WebsiteDataType::OfflineWebApplicationCache, size };
    376373
    377                 websiteData->entries.append(WTFMove(entry));
    378             }
    379 
    380             WTF::RunLoop::main().dispatch([callbackAggregator, origins, websiteData]() mutable {
    381                 callbackAggregator->removePendingCallback(WTFMove(*websiteData));
    382 
    383                 delete websiteData;
     374                websiteData.entries.append(WTFMove(entry));
     375            }
     376
     377            RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins), websiteData = WTFMove(websiteData)]() mutable {
     378                callbackAggregator->removePendingCallback(WTFMove(websiteData));
    384379            });
    385380        });
     
    395390            WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory.string())->origins(origins);
    396391
    397             RunLoop::main().dispatch([callbackAggregator, origins]() mutable {
     392            RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins)]() mutable {
    398393                WebsiteData websiteData;
    399394                for (auto& origin : origins)
     
    426421            auto origins = mediaKeyOrigins(mediaKeysStorageDirectory.string());
    427422
    428             RunLoop::main().dispatch([callbackAggregator, origins]() mutable {
     423            RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins)]() mutable {
    429424                WebsiteData websiteData;
    430425                for (auto& origin : origins)
  • trunk/Source/WebKit2/WebProcess/Plugins/Netscape/NetscapePlugin.cpp

    r196223 r201575  
    303303void NetscapePlugin::pluginThreadAsyncCall(void (*function)(void*), void* userData)
    304304{
    305     RefPtr<NetscapePlugin> plugin(this);
    306     RunLoop::main().dispatch([plugin, function, userData] {
    307         if (!plugin->m_isStarted)
     305    RunLoop::main().dispatch([protectedThis = Ref<NetscapePlugin>(*this), function, userData] {
     306        if (!protectedThis->m_isStarted)
    308307            return;
    309308
  • trunk/Source/WebKit2/WebProcess/Plugins/PluginView.cpp

    r200611 r201575  
    16801680    // only one remaining reference, call deref() asynchronously.
    16811681    if (hasOneRef()) {
    1682         RunLoop::main().dispatch([this] {
    1683             deref();
     1682        RunLoop::main().dispatch([lastRef = adoptRef(*this)] {
    16841683        });
    16851684        return;
  • trunk/Source/WebKit2/WebProcess/WebPage/EventDispatcher.cpp

    r191299 r201575  
    139139#endif
    140140
    141     RefPtr<EventDispatcher> eventDispatcher = this;
    142     RunLoop::main().dispatch([eventDispatcher, pageID, wheelEvent] {
    143         eventDispatcher->dispatchWheelEvent(pageID, wheelEvent);
     141    RunLoop::main().dispatch([protectedThis = Ref<EventDispatcher>(*this), pageID, wheelEvent]() mutable {
     142        protectedThis->dispatchWheelEvent(pageID, wheelEvent);
    144143    });
    145144}
     
    148147void EventDispatcher::gestureEvent(uint64_t pageID, const WebKit::WebGestureEvent& gestureEvent)
    149148{
    150     RefPtr<EventDispatcher> eventDispatcher = this;
    151     RunLoop::main().dispatch([eventDispatcher, pageID, gestureEvent] {
    152         eventDispatcher->dispatchGestureEvent(pageID, gestureEvent);
     149    RunLoop::main().dispatch([protectedThis = Ref<EventDispatcher>(*this), pageID, gestureEvent]() mutable {
     150        protectedThis->dispatchGestureEvent(pageID, gestureEvent);
    153151    });
    154152}
     
    192190
    193191    if (updateListWasEmpty) {
    194         RefPtr<EventDispatcher> eventDispatcher = this;
    195         RunLoop::main().dispatch([eventDispatcher] {
     192        RunLoop::main().dispatch([protectedThis = Ref<EventDispatcher>(*this)]() mutable {
    196193            eventDispatcher->dispatchTouchEvents();
    197194        });
  • trunk/Source/WebKit2/WebProcess/WebPage/ViewUpdateDispatcher.cpp

    r194496 r201575  
    6868    }
    6969    if (updateListWasEmpty) {
    70         RefPtr<ViewUpdateDispatcher> protector(this);
    71         RunLoop::main().dispatch([protector] {
    72             protector->dispatchVisibleContentRectUpdate();
     70        RunLoop::main().dispatch([protectedThis = Ref<ViewUpdateDispatcher>(*this)]() mutable {
     71            protectedThis->dispatchVisibleContentRectUpdate();
    7372        });
    7473    }
Note: See TracChangeset for help on using the changeset viewer.