⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 201587 in webkit


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

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

Reviewed by Chris Dumez.

  • NetworkProcess/cache/NetworkCache.cpp:

(WebKit::NetworkCache::Cache::deleteDumpFile):

  • Platform/IPC/Connection.cpp:

(IPC::Connection::addWorkQueueMessageReceiver):
(IPC::Connection::removeWorkQueueMessageReceiver):
(IPC::Connection::invalidate):
(IPC::Connection::sendMessage):
(IPC::Connection::processIncomingMessage):
(IPC::Connection::postConnectionDidCloseOnConnectionWorkQueue):

  • UIProcess/Storage/LocalStorageDatabaseTracker.cpp:

(WebKit::LocalStorageDatabaseTracker::LocalStorageDatabaseTracker):

  • UIProcess/Storage/StorageManager.cpp:

(WebKit::StorageManager::createSessionStorageNamespace):
(WebKit::StorageManager::destroySessionStorageNamespace):
(WebKit::StorageManager::setAllowedSessionStorageNamespaceConnection):
(WebKit::StorageManager::cloneSessionStorageNamespace):
(WebKit::StorageManager::processDidCloseConnection):

  • UIProcess/WebResourceLoadStatisticsStore.cpp:

(WebKit::WebResourceLoadStatisticsStore::readDataFromDiskIfNeeded):

  • UIProcess/WebsiteData/WebsiteDataStore.cpp:

(WebKit::WebsiteDataStore::fetchData):
(WebKit::WebsiteDataStore::removeData):

Location:
trunk/Source/WebKit2
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r201583 r201587  
     12016-06-01  Brady Eidson  <beidson@apple.com>
     2
     3        Modernize lambda usage for all callers of RunLoop::dispatch() (take 2).
     4        https://bugs.webkit.org/show_bug.cgi?id=158277
     5
     6        Reviewed by Chris Dumez.
     7
     8        * NetworkProcess/cache/NetworkCache.cpp:
     9        (WebKit::NetworkCache::Cache::deleteDumpFile):
     10
     11        * Platform/IPC/Connection.cpp:
     12        (IPC::Connection::addWorkQueueMessageReceiver):
     13        (IPC::Connection::removeWorkQueueMessageReceiver):
     14        (IPC::Connection::invalidate):
     15        (IPC::Connection::sendMessage):
     16        (IPC::Connection::processIncomingMessage):
     17        (IPC::Connection::postConnectionDidCloseOnConnectionWorkQueue):
     18
     19        * UIProcess/Storage/LocalStorageDatabaseTracker.cpp:
     20        (WebKit::LocalStorageDatabaseTracker::LocalStorageDatabaseTracker):
     21
     22        * UIProcess/Storage/StorageManager.cpp:
     23        (WebKit::StorageManager::createSessionStorageNamespace):
     24        (WebKit::StorageManager::destroySessionStorageNamespace):
     25        (WebKit::StorageManager::setAllowedSessionStorageNamespaceConnection):
     26        (WebKit::StorageManager::cloneSessionStorageNamespace):
     27        (WebKit::StorageManager::processDidCloseConnection):
     28
     29        * UIProcess/WebResourceLoadStatisticsStore.cpp:
     30        (WebKit::WebResourceLoadStatisticsStore::readDataFromDiskIfNeeded):
     31
     32        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
     33        (WebKit::WebsiteDataStore::fetchData):
     34        (WebKit::WebsiteDataStore::removeData):
     35
    1362016-06-01  Chris Dumez  <cdumez@apple.com>
    237

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp

    r201484 r201587  
    617617void Cache::deleteDumpFile()
    618618{
    619     auto queue = WorkQueue::create("com.apple.WebKit.Cache.delete");
    620     StringCapture dumpFilePathCapture(dumpFilePath());
    621     queue->dispatch([dumpFilePathCapture] {
    622         WebCore::deleteFile(dumpFilePathCapture.string());
     619    WorkQueue::create("com.apple.WebKit.Cache.delete")->dispatch([path = dumpFilePath().isolatedCopy()] {
     620        WebCore::deleteFile(path);
    623621    });
    624622}

  • trunk/Source/WebKit2/Platform/IPC/Connection.cpp

    r201575 r201587  
    254254    ASSERT(RunLoop::isMain());
    255255
    256     RefPtr<Connection> connection(this);
    257     m_connectionQueue->dispatch([connection, messageReceiverName, workQueue, workQueueMessageReceiver] {
    258         ASSERT(!connection->m_workQueueMessageReceivers.contains(messageReceiverName));
    259 
    260         connection->m_workQueueMessageReceivers.add(messageReceiverName, std::make_pair(workQueue, workQueueMessageReceiver));
     256    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this), messageReceiverName = WTFMove(messageReceiverName), workQueue, workQueueMessageReceiver]() mutable {
     257        ASSERT(!protectedThis->m_workQueueMessageReceivers.contains(messageReceiverName));
     258
     259        protectedThis->m_workQueueMessageReceivers.add(messageReceiverName, std::make_pair(workQueue, workQueueMessageReceiver));
    261260    });
    262261}
    … …  
    266265    ASSERT(RunLoop::isMain());
    267266
    268     RefPtr<Connection> connection(this);
    269     m_connectionQueue->dispatch([connection, messageReceiverName] {
    270         ASSERT(connection->m_workQueueMessageReceivers.contains(messageReceiverName));
    271         connection->m_workQueueMessageReceivers.remove(messageReceiverName);
     267    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this), messageReceiverName = WTFMove(messageReceiverName)]() mutable {
     268        ASSERT(protectedThis->m_workQueueMessageReceivers.contains(messageReceiverName));
     269        protectedThis->m_workQueueMessageReceivers.remove(messageReceiverName);
    272270    });
    273271}
    … …  
    320318    m_client = nullptr;
    321319
    322     RefPtr<Connection> protectedThis(this);
    323     m_connectionQueue->dispatch([protectedThis] {
     320    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
    324321        protectedThis->platformInvalidate();
    325322    });
    … …  
    378375   
    379376    // FIXME: We should add a boolean flag so we don't call this when work has already been scheduled.
    380     RefPtr<Connection> protectedThis(this);
    381     m_connectionQueue->dispatch([protectedThis] {
     377    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
    382378        protectedThis->sendOutgoingMessages();
    383379    });
    … …  
    660656    auto it = m_workQueueMessageReceivers.find(message->messageReceiverName());
    661657    if (it != m_workQueueMessageReceivers.end()) {
    662         RefPtr<Connection> protectedThis(this);
    663         RefPtr<WorkQueueMessageReceiver>& workQueueMessageReceiver = it->value.second;
    664         MessageDecoder* decoderPtr = message.release();
    665         it->value.first->dispatch([protectedThis, workQueueMessageReceiver, decoderPtr] {
    666             std::unique_ptr<MessageDecoder> decoder(decoderPtr);
     658        it->value.first->dispatch([protectedThis = Ref<Connection>(*this), workQueueMessageReceiver = it->value.second, decoder = WTFMove(message)]() mutable {
    667659            protectedThis->dispatchWorkQueueMessageReceiverMessage(*workQueueMessageReceiver, *decoder);
    668660        });
    … …  
    748740void Connection::postConnectionDidCloseOnConnectionWorkQueue()
    749741{
    750     RefPtr<Connection> connection(this);
    751     m_connectionQueue->dispatch([connection] {
    752         connection->connectionDidClose();
     742    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
     743        protectedThis->connectionDidClose();
    753744    });
    754745}

  • trunk/Source/WebKit2/UIProcess/Storage/LocalStorageDatabaseTracker.cpp

    r185625 r201587  
    5252    UTF8Encoding();
    5353
    54     RefPtr<LocalStorageDatabaseTracker> localStorageDatabaseTracker(this);
    55     m_queue->dispatch([localStorageDatabaseTracker] {
    56         localStorageDatabaseTracker->importOriginIdentifiers();
     54    m_queue->dispatch([protectedThis = Ref<LocalStorageDatabaseTracker>(*this)]() mutable {
     55        protectedThis->importOriginIdentifiers();
    5756    });
    5857}

  • trunk/Source/WebKit2/UIProcess/Storage/StorageManager.cpp

    r201575 r201587  
    474474void StorageManager::createSessionStorageNamespace(uint64_t storageNamespaceID, unsigned quotaInBytes)
    475475{
    476     RefPtr<StorageManager> storageManager(this);
    477 
    478     m_queue->dispatch([storageManager, storageNamespaceID, quotaInBytes] {
    479         ASSERT(!storageManager->m_sessionStorageNamespaces.contains(storageNamespaceID));
    480 
    481         storageManager->m_sessionStorageNamespaces.set(storageNamespaceID, SessionStorageNamespace::create(quotaInBytes));
     476    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), storageNamespaceID, quotaInBytes]() mutable {
     477        ASSERT(!m_sessionStorageNamespaces.contains(storageNamespaceID));
     478
     479        m_sessionStorageNamespaces.set(storageNamespaceID, SessionStorageNamespace::create(quotaInBytes));
    482480    });
    483481}
    … …  
    485483void StorageManager::destroySessionStorageNamespace(uint64_t storageNamespaceID)
    486484{
    487     RefPtr<StorageManager> storageManager(this);
    488 
    489     m_queue->dispatch([storageManager, storageNamespaceID] {
    490         ASSERT(storageManager->m_sessionStorageNamespaces.contains(storageNamespaceID));
    491         storageManager->m_sessionStorageNamespaces.remove(storageNamespaceID);
     485    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), storageNamespaceID] {
     486        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
     487        m_sessionStorageNamespaces.remove(storageNamespaceID);
    492488    });
    493489}
    … …  
    495491void StorageManager::setAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection* allowedConnection)
    496492{
    497     RefPtr<StorageManager> storageManager(this);
    498     RefPtr<IPC::Connection> connection(allowedConnection);
    499 
    500     m_queue->dispatch([storageManager, connection, storageNamespaceID] {
    501         ASSERT(storageManager->m_sessionStorageNamespaces.contains(storageNamespaceID));
    502 
    503         storageManager->m_sessionStorageNamespaces.get(storageNamespaceID)->setAllowedConnection(connection.get());
     493    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), connection = RefPtr<IPC::Connection>(allowedConnection), storageNamespaceID]() mutable {
     494        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
     495
     496        m_sessionStorageNamespaces.get(storageNamespaceID)->setAllowedConnection(connection.get());
    504497    });
    505498}
    … …  
    507500void StorageManager::cloneSessionStorageNamespace(uint64_t storageNamespaceID, uint64_t newStorageNamespaceID)
    508501{
    509     RefPtr<StorageManager> storageManager(this);
    510 
    511     m_queue->dispatch([storageManager, storageNamespaceID, newStorageNamespaceID] {
    512         SessionStorageNamespace* sessionStorageNamespace = storageManager->m_sessionStorageNamespaces.get(storageNamespaceID);
     502    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), storageNamespaceID, newStorageNamespaceID] {
     503        SessionStorageNamespace* sessionStorageNamespace = m_sessionStorageNamespaces.get(storageNamespaceID);
    513504        if (!sessionStorageNamespace) {
    514505            // FIXME: We can get into this situation if someone closes the originating page from within a
    … …  
    518509        }
    519510
    520         SessionStorageNamespace* newSessionStorageNamespace = storageManager->m_sessionStorageNamespaces.get(newStorageNamespaceID);
     511        SessionStorageNamespace* newSessionStorageNamespace = m_sessionStorageNamespaces.get(newStorageNamespaceID);
    521512        ASSERT(newSessionStorageNamespace);
    522513
    … …  
    534525    connection.removeWorkQueueMessageReceiver(Messages::StorageManager::messageReceiverName());
    535526
    536     RefPtr<StorageManager> storageManager(this);
    537     RefPtr<IPC::Connection> protectedConnection(&connection);
    538 
    539     m_queue->dispatch([storageManager, protectedConnection] {
     527    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), connection = Ref<IPC::Connection>(connection)]() mutable {
    540528        Vector<std::pair<RefPtr<IPC::Connection>, uint64_t>> connectionAndStorageMapIDPairsToRemove;
    541         auto storageAreasByConnection = storageManager->m_storageAreasByConnection;
    542 
    543         for (auto it = storageAreasByConnection.begin(), end = storageAreasByConnection.end(); it != end; ++it) {
    544             if (it->key.first != protectedConnection)
     529        for (auto& storageArea : m_storageAreasByConnection) {
     530            if (storageArea.key.first != connection.ptr())
    545531                continue;
    546532
    547             it->value->removeListener(*it->key.first, it->key.second);
    548             connectionAndStorageMapIDPairsToRemove.append(it->key);
    549         }
    550 
    551         for (size_t i = 0; i < connectionAndStorageMapIDPairsToRemove.size(); ++i)
    552             storageManager->m_storageAreasByConnection.remove(connectionAndStorageMapIDPairsToRemove[i]);
     533            storageArea.value->removeListener(*storageArea.key.first, storageArea.key.second);
     534            connectionAndStorageMapIDPairsToRemove.append(storageArea.key);
     535        }
     536
     537        for (auto& pair : connectionAndStorageMapIDPairsToRemove)
     538            m_storageAreasByConnection.remove(pair);
    553539    });
    554540}

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

    r198055 r201587  
    118118        return;
    119119
    120     RefPtr<WebResourceLoadStatisticsStore> self(this);
    121     m_statisticsQueue->dispatch([self] {
    122         self->coreStore().clear();
     120    m_statisticsQueue->dispatch([this, protectedThis = Ref<WebResourceLoadStatisticsStore>(*this)] {
     121        coreStore().clear();
    123122
    124         auto decoder = self->createDecoderFromDisk("full_browsing_session");
     123        auto decoder = createDecoderFromDisk("full_browsing_session");
    125124        if (!decoder)
    126125            return;
    127126
    128         self->coreStore().readDataFromDecoder(*decoder);
     127        coreStore().readDataFromDecoder(*decoder);
    129128    });
    130129}

  • trunk/Source/WebKit2/UIProcess/WebsiteData/WebsiteDataStore.cpp

    r201575 r201587  
    258258    RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(fetchOptions, WTFMove(completionHandler)));
    259259
     260#if ENABLE(VIDEO)
    260261    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
    261         StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
    262        
    263 #if ENABLE(VIDEO)
    264         callbackAggregator->addPendingCallback();
    265         m_queue->dispatch([fetchOptions, mediaCacheDirectory, callbackAggregator] {
    266             HashSet<RefPtr<WebCore::SecurityOrigin>> origins = WebCore::HTMLMediaElement::originsInMediaCache(mediaCacheDirectory.string());
     262        callbackAggregator->addPendingCallback();
     263        m_queue->dispatch([fetchOptions, mediaCacheDirectory = m_mediaCacheDirectory.isolatedCopy(), callbackAggregator] {
     264            HashSet<RefPtr<WebCore::SecurityOrigin>> origins = WebCore::HTMLMediaElement::originsInMediaCache(mediaCacheDirectory);
    267265            WebsiteData websiteData;
    268266           
    … …  
    276274            });
    277275        });
     276    }
    278277#endif
    279     }
    280278
    281279    auto networkProcessAccessType = computeNetworkProcessAccessTypeForDataFetch(dataTypes, !isPersistent());
    … …  
    355353
    356354    if (dataTypes.contains(WebsiteDataType::OfflineWebApplicationCache) && isPersistent()) {
    357         StringCapture applicationCacheDirectory { m_applicationCacheDirectory };
    358         StringCapture applicationCacheFlatFileSubdirectoryName { m_applicationCacheFlatFileSubdirectoryName };
    359 
    360         callbackAggregator->addPendingCallback();
    361 
    362         m_queue->dispatch([fetchOptions, applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName, callbackAggregator] {
    363             auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory.string(), applicationCacheFlatFileSubdirectoryName.string());
     355        callbackAggregator->addPendingCallback();
     356
     357        m_queue->dispatch([fetchOptions, applicationCacheDirectory = m_applicationCacheDirectory.isolatedCopy(), applicationCacheFlatFileSubdirectoryName = m_applicationCacheFlatFileSubdirectoryName.isolatedCopy(), callbackAggregator] {
     358            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName);
    364359
    365360            WebsiteData websiteData;
    … …  
    382377
    383378    if (dataTypes.contains(WebsiteDataType::WebSQLDatabases) && isPersistent()) {
    384         StringCapture webSQLDatabaseDirectory { m_webSQLDatabaseDirectory };
    385 
    386         callbackAggregator->addPendingCallback();
    387 
    388         m_queue->dispatch([webSQLDatabaseDirectory, callbackAggregator] {
     379        callbackAggregator->addPendingCallback();
     380
     381        m_queue->dispatch([webSQLDatabaseDirectory = m_webSQLDatabaseDirectory.isolatedCopy(), callbackAggregator] {
    389382            Vector<RefPtr<WebCore::SecurityOrigin>> origins;
    390             WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory.string())->origins(origins);
     383            WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory)->origins(origins);
    391384
    392385            RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins)]() mutable {
    … …  
    414407
    415408    if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
    416         StringCapture mediaKeysStorageDirectory { m_mediaKeysStorageDirectory };
    417 
    418         callbackAggregator->addPendingCallback();
    419 
    420         m_queue->dispatch([mediaKeysStorageDirectory, callbackAggregator] {
    421             auto origins = mediaKeyOrigins(mediaKeysStorageDirectory.string());
     409        callbackAggregator->addPendingCallback();
     410
     411        m_queue->dispatch([mediaKeysStorageDirectory = m_mediaKeysStorageDirectory.isolatedCopy(), callbackAggregator] {
     412            auto origins = mediaKeyOrigins(mediaKeysStorageDirectory);
    422413
    423414            RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins)]() mutable {
    … …  
    552543    RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(WTFMove(completionHandler)));
    553544
     545#if ENABLE(VIDEO)
    554546    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
    555         StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
    556 
    557 #if ENABLE(VIDEO)
    558         callbackAggregator->addPendingCallback();
    559         m_queue->dispatch([modifiedSince, mediaCacheDirectory, callbackAggregator] {
    560             WebCore::HTMLMediaElement::clearMediaCache(mediaCacheDirectory.string(), modifiedSince);
     547        callbackAggregator->addPendingCallback();
     548        m_queue->dispatch([modifiedSince, mediaCacheDirectory = m_mediaCacheDirectory.isolatedCopy(), callbackAggregator] {
     549            WebCore::HTMLMediaElement::clearMediaCache(mediaCacheDirectory, modifiedSince);
    561550           
    562551            WTF::RunLoop::main().dispatch([callbackAggregator] {
    … …  
    564553            });
    565554        });
     555    }
    566556#endif
    567     }
    568557
    569558    auto networkProcessAccessType = computeNetworkProcessAccessTypeForDataRemoval(dataTypes, !isPersistent());
    … …  
    633622
    634623    if (dataTypes.contains(WebsiteDataType::OfflineWebApplicationCache) && isPersistent()) {
    635         StringCapture applicationCacheDirectory { m_applicationCacheDirectory };
    636         StringCapture applicationCacheFlatFileSubdirectoryName { m_applicationCacheFlatFileSubdirectoryName };
    637 
    638         callbackAggregator->addPendingCallback();
    639 
    640         m_queue->dispatch([applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName, callbackAggregator] {
    641             auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory.string(), applicationCacheFlatFileSubdirectoryName.string());
     624        callbackAggregator->addPendingCallback();
     625
     626        m_queue->dispatch([applicationCacheDirectory = m_applicationCacheDirectory.isolatedCopy(), applicationCacheFlatFileSubdirectoryName = m_applicationCacheFlatFileSubdirectoryName.isolatedCopy(), callbackAggregator] {
     627            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName);
    642628
    643629            storage->deleteAllCaches();
    … …  
    650636
    651637    if (dataTypes.contains(WebsiteDataType::WebSQLDatabases) && isPersistent()) {
    652         StringCapture webSQLDatabaseDirectory { m_webSQLDatabaseDirectory };
    653 
    654         callbackAggregator->addPendingCallback();
    655 
    656         m_queue->dispatch([webSQLDatabaseDirectory, callbackAggregator, modifiedSince] {
    657             WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory.string())->deleteDatabasesModifiedSince(modifiedSince);
     638        callbackAggregator->addPendingCallback();
     639
     640        m_queue->dispatch([webSQLDatabaseDirectory = m_webSQLDatabaseDirectory.isolatedCopy(), callbackAggregator, modifiedSince] {
     641            WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory)->deleteDatabasesModifiedSince(modifiedSince);
    658642
    659643            RunLoop::main().dispatch([callbackAggregator] {
    … …  
    677661
    678662    if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
    679         StringCapture mediaKeysStorageDirectory { m_mediaKeysStorageDirectory };
    680 
    681         callbackAggregator->addPendingCallback();
    682 
    683         m_queue->dispatch([mediaKeysStorageDirectory, callbackAggregator, modifiedSince] {
    684             removeMediaKeys(mediaKeysStorageDirectory.string(), modifiedSince);
     663        callbackAggregator->addPendingCallback();
     664
     665        m_queue->dispatch([mediaKeysStorageDirectory = m_mediaKeysStorageDirectory.isolatedCopy(), callbackAggregator, modifiedSince] {
     666            removeMediaKeys(mediaKeysStorageDirectory, modifiedSince);
    685667
    686668            RunLoop::main().dispatch([callbackAggregator] {
    … …  
    796778   
    797779    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
    798         StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
    799780        HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
    800781        for (const auto& dataRecord : dataRecords) {
    … …  
    805786#if ENABLE(VIDEO)
    806787        callbackAggregator->addPendingCallback();
    807         m_queue->dispatch([origins, mediaCacheDirectory, callbackAggregator] {
    808             WebCore::HTMLMediaElement::clearMediaCacheForOrigins(mediaCacheDirectory.string(), origins);
     788        m_queue->dispatch([origins = WTFMove(origins), mediaCacheDirectory = m_mediaCacheDirectory.isolatedCopy(), callbackAggregator] {
     789            WebCore::HTMLMediaElement::clearMediaCacheForOrigins(mediaCacheDirectory, origins);
    809790           
    810791            WTF::RunLoop::main().dispatch([callbackAggregator] {
    … …  
    888869
    889870    if (dataTypes.contains(WebsiteDataType::OfflineWebApplicationCache) && isPersistent()) {
    890         StringCapture applicationCacheDirectory { m_applicationCacheDirectory };
    891         StringCapture applicationCacheFlatFileSubdirectoryName { m_applicationCacheFlatFileSubdirectoryName };
    892 
    893871        HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
    894872        for (const auto& dataRecord : dataRecords) {
    … …  
    898876
    899877        callbackAggregator->addPendingCallback();
    900         m_queue->dispatch([origins, applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName, callbackAggregator] {
    901             auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory.string(), applicationCacheFlatFileSubdirectoryName.string());
     878        m_queue->dispatch([origins = WTFMove(origins), applicationCacheDirectory = m_applicationCacheDirectory.isolatedCopy(), applicationCacheFlatFileSubdirectoryName = m_applicationCacheFlatFileSubdirectoryName.isolatedCopy(), callbackAggregator] {
     879            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName);
    902880
    903881            for (const auto& origin : origins)
    … …  
    911889
    912890    if (dataTypes.contains(WebsiteDataType::WebSQLDatabases) && isPersistent()) {
    913         StringCapture webSQLDatabaseDirectory { m_webSQLDatabaseDirectory };
    914 
    915891        HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
    916892        for (const auto& dataRecord : dataRecords) {
    … …  
    920896
    921897        callbackAggregator->addPendingCallback();
    922         m_queue->dispatch([origins, callbackAggregator, webSQLDatabaseDirectory] {
    923             auto databaseTracker = WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory.string());
     898        m_queue->dispatch([origins = WTFMove(origins), callbackAggregator, webSQLDatabaseDirectory = m_webSQLDatabaseDirectory.isolatedCopy()] {
     899            auto databaseTracker = WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory);
    924900
    925901            for (const auto& origin : origins)
    … …  
    946922
    947923    if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
    948         StringCapture mediaKeysStorageDirectory { m_mediaKeysStorageDirectory };
    949924        HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
    950925        for (const auto& dataRecord : dataRecords) {
    … …  
    954929
    955930        callbackAggregator->addPendingCallback();
    956         m_queue->dispatch([mediaKeysStorageDirectory, callbackAggregator, origins] {
    957 
    958             removeMediaKeys(mediaKeysStorageDirectory.string(), origins);
     931        m_queue->dispatch([mediaKeysStorageDirectory = m_mediaKeysStorageDirectory.isolatedCopy(), callbackAggregator, origins = WTFMove(origins)] {
     932
     933            removeMediaKeys(mediaKeysStorageDirectory, origins);
    959934
    960935            RunLoop::main().dispatch([callbackAggregator] {
Note: See TracChangeset for help on using the changeset viewer.