[webkit-changes] [201587] trunk/Source/WebKit2

Wed, 01 Jun 2016 20:39:03 -0700

Title: [201587] trunk/Source/WebKit2
Revision
201587
Author
[email protected]
Date
2016-06-01 20:38:39 -0700 (Wed, 01 Jun 2016)

Log 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):

Modified Paths

Diff

Modified: trunk/Source/WebKit2/ChangeLog (201586 => 201587)


--- trunk/Source/WebKit2/ChangeLog	2016-06-02 03:34:31 UTC (rev 201586)
+++ trunk/Source/WebKit2/ChangeLog	2016-06-02 03:38:39 UTC (rev 201587)
@@ -1,3 +1,38 @@
+2016-06-01  Brady Eidson  <[email protected]>
+
+        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):
+
 2016-06-01  Chris Dumez  <[email protected]>
 
         [iOS] Regression(r200972): Crash under WebKit::WebPage::selectTextWithGranularityAtPoint()

Modified: trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp (201586 => 201587)


--- trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp	2016-06-02 03:34:31 UTC (rev 201586)
+++ trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp	2016-06-02 03:38:39 UTC (rev 201587)
@@ -616,10 +616,8 @@
 
 void Cache::deleteDumpFile()
 {
-    auto queue = WorkQueue::create("com.apple.WebKit.Cache.delete");
-    StringCapture dumpFilePathCapture(dumpFilePath());
-    queue->dispatch([dumpFilePathCapture] {
-        WebCore::deleteFile(dumpFilePathCapture.string());
+    WorkQueue::create("com.apple.WebKit.Cache.delete")->dispatch([path = dumpFilePath().isolatedCopy()] {
+        WebCore::deleteFile(path);
     });
 }

Modified: trunk/Source/WebKit2/Platform/IPC/Connection.cpp (201586 => 201587)


--- trunk/Source/WebKit2/Platform/IPC/Connection.cpp	2016-06-02 03:34:31 UTC (rev 201586)
+++ trunk/Source/WebKit2/Platform/IPC/Connection.cpp	2016-06-02 03:38:39 UTC (rev 201587)
@@ -253,11 +253,10 @@
 {
     ASSERT(RunLoop::isMain());
 
-    RefPtr<Connection> connection(this);
-    m_connectionQueue->dispatch([connection, messageReceiverName, workQueue, workQueueMessageReceiver] {
-        ASSERT(!connection->m_workQueueMessageReceivers.contains(messageReceiverName));
+    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this), messageReceiverName = WTFMove(messageReceiverName), workQueue, workQueueMessageReceiver]() mutable {
+        ASSERT(!protectedThis->m_workQueueMessageReceivers.contains(messageReceiverName));
 
-        connection->m_workQueueMessageReceivers.add(messageReceiverName, std::make_pair(workQueue, workQueueMessageReceiver));
+        protectedThis->m_workQueueMessageReceivers.add(messageReceiverName, std::make_pair(workQueue, workQueueMessageReceiver));
     });
 }
 
@@ -265,10 +264,9 @@
 {
     ASSERT(RunLoop::isMain());
 
-    RefPtr<Connection> connection(this);
-    m_connectionQueue->dispatch([connection, messageReceiverName] {
-        ASSERT(connection->m_workQueueMessageReceivers.contains(messageReceiverName));
-        connection->m_workQueueMessageReceivers.remove(messageReceiverName);
+    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this), messageReceiverName = WTFMove(messageReceiverName)]() mutable {
+        ASSERT(protectedThis->m_workQueueMessageReceivers.contains(messageReceiverName));
+        protectedThis->m_workQueueMessageReceivers.remove(messageReceiverName);
     });
 }
 
@@ -319,8 +317,7 @@
     
     m_client = nullptr;
 
-    RefPtr<Connection> protectedThis(this);
-    m_connectionQueue->dispatch([protectedThis] {
+    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
         protectedThis->platformInvalidate();
     });
 }
@@ -377,8 +374,7 @@
     }
     
     // FIXME: We should add a boolean flag so we don't call this when work has already been scheduled.
-    RefPtr<Connection> protectedThis(this);
-    m_connectionQueue->dispatch([protectedThis] {
+    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
         protectedThis->sendOutgoingMessages();
     });
     return true;
@@ -659,11 +655,7 @@
 
     auto it = m_workQueueMessageReceivers.find(message->messageReceiverName());
     if (it != m_workQueueMessageReceivers.end()) {
-        RefPtr<Connection> protectedThis(this);
-        RefPtr<WorkQueueMessageReceiver>& workQueueMessageReceiver = it->value.second;
-        MessageDecoder* decoderPtr = message.release();
-        it->value.first->dispatch([protectedThis, workQueueMessageReceiver, decoderPtr] {
-            std::unique_ptr<MessageDecoder> decoder(decoderPtr);
+        it->value.first->dispatch([protectedThis = Ref<Connection>(*this), workQueueMessageReceiver = it->value.second, decoder = WTFMove(message)]() mutable {
             protectedThis->dispatchWorkQueueMessageReceiverMessage(*workQueueMessageReceiver, *decoder);
         });
         return;
@@ -747,9 +739,8 @@
 
 void Connection::postConnectionDidCloseOnConnectionWorkQueue()
 {
-    RefPtr<Connection> connection(this);
-    m_connectionQueue->dispatch([connection] {
-        connection->connectionDidClose();
+    m_connectionQueue->dispatch([protectedThis = Ref<Connection>(*this)]() mutable {
+        protectedThis->connectionDidClose();
     });
 }

Modified: trunk/Source/WebKit2/UIProcess/Storage/LocalStorageDatabaseTracker.cpp (201586 => 201587)


--- trunk/Source/WebKit2/UIProcess/Storage/LocalStorageDatabaseTracker.cpp	2016-06-02 03:34:31 UTC (rev 201586)
+++ trunk/Source/WebKit2/UIProcess/Storage/LocalStorageDatabaseTracker.cpp	2016-06-02 03:38:39 UTC (rev 201587)
@@ -51,9 +51,8 @@
     // Make sure the encoding is initialized before we start dispatching things to the queue.
     UTF8Encoding();
 
-    RefPtr<LocalStorageDatabaseTracker> localStorageDatabaseTracker(this);
-    m_queue->dispatch([localStorageDatabaseTracker] {
-        localStorageDatabaseTracker->importOriginIdentifiers();
+    m_queue->dispatch([protectedThis = Ref<LocalStorageDatabaseTracker>(*this)]() mutable {
+        protectedThis->importOriginIdentifiers();
     });
 }

Modified: trunk/Source/WebKit2/UIProcess/Storage/StorageManager.cpp (201586 => 201587)


--- trunk/Source/WebKit2/UIProcess/Storage/StorageManager.cpp	2016-06-02 03:34:31 UTC (rev 201586)
+++ trunk/Source/WebKit2/UIProcess/Storage/StorageManager.cpp	2016-06-02 03:38:39 UTC (rev 201587)
@@ -473,43 +473,34 @@
 
 void StorageManager::createSessionStorageNamespace(uint64_t storageNamespaceID, unsigned quotaInBytes)
 {
-    RefPtr<StorageManager> storageManager(this);
+    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), storageNamespaceID, quotaInBytes]() mutable {
+        ASSERT(!m_sessionStorageNamespaces.contains(storageNamespaceID));
 
-    m_queue->dispatch([storageManager, storageNamespaceID, quotaInBytes] {
-        ASSERT(!storageManager->m_sessionStorageNamespaces.contains(storageNamespaceID));
-
-        storageManager->m_sessionStorageNamespaces.set(storageNamespaceID, SessionStorageNamespace::create(quotaInBytes));
+        m_sessionStorageNamespaces.set(storageNamespaceID, SessionStorageNamespace::create(quotaInBytes));
     });
 }
 
 void StorageManager::destroySessionStorageNamespace(uint64_t storageNamespaceID)
 {
-    RefPtr<StorageManager> storageManager(this);
-
-    m_queue->dispatch([storageManager, storageNamespaceID] {
-        ASSERT(storageManager->m_sessionStorageNamespaces.contains(storageNamespaceID));
-        storageManager->m_sessionStorageNamespaces.remove(storageNamespaceID);
+    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), storageNamespaceID] {
+        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
+        m_sessionStorageNamespaces.remove(storageNamespaceID);
     });
 }
 
 void StorageManager::setAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection* allowedConnection)
 {
-    RefPtr<StorageManager> storageManager(this);
-    RefPtr<IPC::Connection> connection(allowedConnection);
+    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), connection = RefPtr<IPC::Connection>(allowedConnection), storageNamespaceID]() mutable {
+        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
 
-    m_queue->dispatch([storageManager, connection, storageNamespaceID] {
-        ASSERT(storageManager->m_sessionStorageNamespaces.contains(storageNamespaceID));
-
-        storageManager->m_sessionStorageNamespaces.get(storageNamespaceID)->setAllowedConnection(connection.get());
+        m_sessionStorageNamespaces.get(storageNamespaceID)->setAllowedConnection(connection.get());
     });
 }
 
 void StorageManager::cloneSessionStorageNamespace(uint64_t storageNamespaceID, uint64_t newStorageNamespaceID)
 {
-    RefPtr<StorageManager> storageManager(this);
-
-    m_queue->dispatch([storageManager, storageNamespaceID, newStorageNamespaceID] {
-        SessionStorageNamespace* sessionStorageNamespace = storageManager->m_sessionStorageNamespaces.get(storageNamespaceID);
+    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), storageNamespaceID, newStorageNamespaceID] {
+        SessionStorageNamespace* sessionStorageNamespace = m_sessionStorageNamespaces.get(storageNamespaceID);
         if (!sessionStorageNamespace) {
             // FIXME: We can get into this situation if someone closes the originating page from within a
             // createNewPage callback. We bail for now, but we should really find a way to keep the session storage alive
@@ -517,7 +508,7 @@
             return;
         }
 
-        SessionStorageNamespace* newSessionStorageNamespace = storageManager->m_sessionStorageNamespaces.get(newStorageNamespaceID);
+        SessionStorageNamespace* newSessionStorageNamespace = m_sessionStorageNamespaces.get(newStorageNamespaceID);
         ASSERT(newSessionStorageNamespace);
 
         sessionStorageNamespace->cloneTo(*newSessionStorageNamespace);
@@ -533,23 +524,18 @@
 {
     connection.removeWorkQueueMessageReceiver(Messages::StorageManager::messageReceiverName());
 
-    RefPtr<StorageManager> storageManager(this);
-    RefPtr<IPC::Connection> protectedConnection(&connection);
-
-    m_queue->dispatch([storageManager, protectedConnection] {
+    m_queue->dispatch([this, protectedThis = Ref<StorageManager>(*this), connection = Ref<IPC::Connection>(connection)]() mutable {
         Vector<std::pair<RefPtr<IPC::Connection>, uint64_t>> connectionAndStorageMapIDPairsToRemove;
-        auto storageAreasByConnection = storageManager->m_storageAreasByConnection;
-
-        for (auto it = storageAreasByConnection.begin(), end = storageAreasByConnection.end(); it != end; ++it) {
-            if (it->key.first != protectedConnection)
+        for (auto& storageArea : m_storageAreasByConnection) {
+            if (storageArea.key.first != connection.ptr())
                 continue;
 
-            it->value->removeListener(*it->key.first, it->key.second);
-            connectionAndStorageMapIDPairsToRemove.append(it->key);
+            storageArea.value->removeListener(*storageArea.key.first, storageArea.key.second);
+            connectionAndStorageMapIDPairsToRemove.append(storageArea.key);
         }
 
-        for (size_t i = 0; i < connectionAndStorageMapIDPairsToRemove.size(); ++i)
-            storageManager->m_storageAreasByConnection.remove(connectionAndStorageMapIDPairsToRemove[i]);
+        for (auto& pair : connectionAndStorageMapIDPairsToRemove)
+            m_storageAreasByConnection.remove(pair);
     });
 }

Modified: trunk/Source/WebKit2/UIProcess/WebResourceLoadStatisticsStore.cpp (201586 => 201587)


--- trunk/Source/WebKit2/UIProcess/WebResourceLoadStatisticsStore.cpp	2016-06-02 03:34:31 UTC (rev 201586)
+++ trunk/Source/WebKit2/UIProcess/WebResourceLoadStatisticsStore.cpp	2016-06-02 03:38:39 UTC (rev 201587)
@@ -117,15 +117,14 @@
     if (!m_resourceLoadStatisticsEnabled)
         return;
 
-    RefPtr<WebResourceLoadStatisticsStore> self(this);
-    m_statisticsQueue->dispatch([self] {
-        self->coreStore().clear();
+    m_statisticsQueue->dispatch([this, protectedThis = Ref<WebResourceLoadStatisticsStore>(*this)] {
+        coreStore().clear();
 
-        auto decoder = self->createDecoderFromDisk("full_browsing_session");
+        auto decoder = createDecoderFromDisk("full_browsing_session");
         if (!decoder)
             return;
 
-        self->coreStore().readDataFromDecoder(*decoder);
+        coreStore().readDataFromDecoder(*decoder);
     });
 }

Modified: trunk/Source/WebKit2/UIProcess/WebsiteData/WebsiteDataStore.cpp (201586 => 201587)


--- trunk/Source/WebKit2/UIProcess/WebsiteData/WebsiteDataStore.cpp	2016-06-02 03:34:31 UTC (rev 201586)
+++ trunk/Source/WebKit2/UIProcess/WebsiteData/WebsiteDataStore.cpp	2016-06-02 03:38:39 UTC (rev 201587)
@@ -257,13 +257,11 @@
 
     RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(fetchOptions, WTFMove(completionHandler)));
 
-    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
-        StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
-        
 #if ENABLE(VIDEO)
+    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
         callbackAggregator->addPendingCallback();
-        m_queue->dispatch([fetchOptions, mediaCacheDirectory, callbackAggregator] {
-            HashSet<RefPtr<WebCore::SecurityOrigin>> origins = WebCore::HTMLMediaElement::originsInMediaCache(mediaCacheDirectory.string());
+        m_queue->dispatch([fetchOptions, mediaCacheDirectory = m_mediaCacheDirectory.isolatedCopy(), callbackAggregator] {
+            HashSet<RefPtr<WebCore::SecurityOrigin>> origins = WebCore::HTMLMediaElement::originsInMediaCache(mediaCacheDirectory);
             WebsiteData websiteData;
             
             for (auto& origin : origins) {
@@ -275,8 +273,8 @@
                 callbackAggregator->removePendingCallback(WTFMove(websiteData));
             });
         });
-#endif
     }
+#endif
 
     auto networkProcessAccessType = computeNetworkProcessAccessTypeForDataFetch(dataTypes, !isPersistent());
     if (networkProcessAccessType != ProcessAccessType::None) {
@@ -354,13 +352,10 @@
     }
 
     if (dataTypes.contains(WebsiteDataType::OfflineWebApplicationCache) && isPersistent()) {
-        StringCapture applicationCacheDirectory { m_applicationCacheDirectory };
-        StringCapture applicationCacheFlatFileSubdirectoryName { m_applicationCacheFlatFileSubdirectoryName };
-
         callbackAggregator->addPendingCallback();
 
-        m_queue->dispatch([fetchOptions, applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName, callbackAggregator] {
-            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory.string(), applicationCacheFlatFileSubdirectoryName.string());
+        m_queue->dispatch([fetchOptions, applicationCacheDirectory = m_applicationCacheDirectory.isolatedCopy(), applicationCacheFlatFileSubdirectoryName = m_applicationCacheFlatFileSubdirectoryName.isolatedCopy(), callbackAggregator] {
+            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName);
 
             WebsiteData websiteData;
 
@@ -381,13 +376,11 @@
     }
 
     if (dataTypes.contains(WebsiteDataType::WebSQLDatabases) && isPersistent()) {
-        StringCapture webSQLDatabaseDirectory { m_webSQLDatabaseDirectory };
-
         callbackAggregator->addPendingCallback();
 
-        m_queue->dispatch([webSQLDatabaseDirectory, callbackAggregator] {
+        m_queue->dispatch([webSQLDatabaseDirectory = m_webSQLDatabaseDirectory.isolatedCopy(), callbackAggregator] {
             Vector<RefPtr<WebCore::SecurityOrigin>> origins;
-            WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory.string())->origins(origins);
+            WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory)->origins(origins);
 
             RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins)]() mutable {
                 WebsiteData websiteData;
@@ -413,12 +406,10 @@
 #endif
 
     if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
-        StringCapture mediaKeysStorageDirectory { m_mediaKeysStorageDirectory };
-
         callbackAggregator->addPendingCallback();
 
-        m_queue->dispatch([mediaKeysStorageDirectory, callbackAggregator] {
-            auto origins = mediaKeyOrigins(mediaKeysStorageDirectory.string());
+        m_queue->dispatch([mediaKeysStorageDirectory = m_mediaKeysStorageDirectory.isolatedCopy(), callbackAggregator] {
+            auto origins = mediaKeyOrigins(mediaKeysStorageDirectory);
 
             RunLoop::main().dispatch([callbackAggregator, origins = WTFMove(origins)]() mutable {
                 WebsiteData websiteData;
@@ -551,20 +542,18 @@
 
     RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(WTFMove(completionHandler)));
 
-    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
-        StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
-
 #if ENABLE(VIDEO)
+    if (dataTypes.contains(WebsiteDataType::DiskCache)) {
         callbackAggregator->addPendingCallback();
-        m_queue->dispatch([modifiedSince, mediaCacheDirectory, callbackAggregator] {
-            WebCore::HTMLMediaElement::clearMediaCache(mediaCacheDirectory.string(), modifiedSince);
+        m_queue->dispatch([modifiedSince, mediaCacheDirectory = m_mediaCacheDirectory.isolatedCopy(), callbackAggregator] {
+            WebCore::HTMLMediaElement::clearMediaCache(mediaCacheDirectory, modifiedSince);
             
             WTF::RunLoop::main().dispatch([callbackAggregator] {
                 callbackAggregator->removePendingCallback();
             });
         });
-#endif
     }
+#endif
 
     auto networkProcessAccessType = computeNetworkProcessAccessTypeForDataRemoval(dataTypes, !isPersistent());
     if (networkProcessAccessType != ProcessAccessType::None) {
@@ -632,13 +621,10 @@
     }
 
     if (dataTypes.contains(WebsiteDataType::OfflineWebApplicationCache) && isPersistent()) {
-        StringCapture applicationCacheDirectory { m_applicationCacheDirectory };
-        StringCapture applicationCacheFlatFileSubdirectoryName { m_applicationCacheFlatFileSubdirectoryName };
-
         callbackAggregator->addPendingCallback();
 
-        m_queue->dispatch([applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName, callbackAggregator] {
-            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory.string(), applicationCacheFlatFileSubdirectoryName.string());
+        m_queue->dispatch([applicationCacheDirectory = m_applicationCacheDirectory.isolatedCopy(), applicationCacheFlatFileSubdirectoryName = m_applicationCacheFlatFileSubdirectoryName.isolatedCopy(), callbackAggregator] {
+            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName);
 
             storage->deleteAllCaches();
 
@@ -649,12 +635,10 @@
     }
 
     if (dataTypes.contains(WebsiteDataType::WebSQLDatabases) && isPersistent()) {
-        StringCapture webSQLDatabaseDirectory { m_webSQLDatabaseDirectory };
-
         callbackAggregator->addPendingCallback();
 
-        m_queue->dispatch([webSQLDatabaseDirectory, callbackAggregator, modifiedSince] {
-            WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory.string())->deleteDatabasesModifiedSince(modifiedSince);
+        m_queue->dispatch([webSQLDatabaseDirectory = m_webSQLDatabaseDirectory.isolatedCopy(), callbackAggregator, modifiedSince] {
+            WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory)->deleteDatabasesModifiedSince(modifiedSince);
 
             RunLoop::main().dispatch([callbackAggregator] {
                 callbackAggregator->removePendingCallback();
@@ -676,12 +660,10 @@
 #endif
 
     if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
-        StringCapture mediaKeysStorageDirectory { m_mediaKeysStorageDirectory };
-
         callbackAggregator->addPendingCallback();
 
-        m_queue->dispatch([mediaKeysStorageDirectory, callbackAggregator, modifiedSince] {
-            removeMediaKeys(mediaKeysStorageDirectory.string(), modifiedSince);
+        m_queue->dispatch([mediaKeysStorageDirectory = m_mediaKeysStorageDirectory.isolatedCopy(), callbackAggregator, modifiedSince] {
+            removeMediaKeys(mediaKeysStorageDirectory, modifiedSince);
 
             RunLoop::main().dispatch([callbackAggregator] {
                 callbackAggregator->removePendingCallback();
@@ -795,7 +777,6 @@
     RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator(WTFMove(completionHandler)));
     
     if (dataTypes.contains(WebsiteDataType::DiskCache)) {
-        StringCapture mediaCacheDirectory { m_mediaCacheDirectory };
         HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
         for (const auto& dataRecord : dataRecords) {
             for (const auto& origin : dataRecord.origins)
@@ -804,8 +785,8 @@
         
 #if ENABLE(VIDEO)
         callbackAggregator->addPendingCallback();
-        m_queue->dispatch([origins, mediaCacheDirectory, callbackAggregator] {
-            WebCore::HTMLMediaElement::clearMediaCacheForOrigins(mediaCacheDirectory.string(), origins);
+        m_queue->dispatch([origins = WTFMove(origins), mediaCacheDirectory = m_mediaCacheDirectory.isolatedCopy(), callbackAggregator] {
+            WebCore::HTMLMediaElement::clearMediaCacheForOrigins(mediaCacheDirectory, origins);
             
             WTF::RunLoop::main().dispatch([callbackAggregator] {
                 callbackAggregator->removePendingCallback();
@@ -887,9 +868,6 @@
     }
 
     if (dataTypes.contains(WebsiteDataType::OfflineWebApplicationCache) && isPersistent()) {
-        StringCapture applicationCacheDirectory { m_applicationCacheDirectory };
-        StringCapture applicationCacheFlatFileSubdirectoryName { m_applicationCacheFlatFileSubdirectoryName };
-
         HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
         for (const auto& dataRecord : dataRecords) {
             for (const auto& origin : dataRecord.origins)
@@ -897,8 +875,8 @@
         }
 
         callbackAggregator->addPendingCallback();
-        m_queue->dispatch([origins, applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName, callbackAggregator] {
-            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory.string(), applicationCacheFlatFileSubdirectoryName.string());
+        m_queue->dispatch([origins = WTFMove(origins), applicationCacheDirectory = m_applicationCacheDirectory.isolatedCopy(), applicationCacheFlatFileSubdirectoryName = m_applicationCacheFlatFileSubdirectoryName.isolatedCopy(), callbackAggregator] {
+            auto storage = WebCore::ApplicationCacheStorage::create(applicationCacheDirectory, applicationCacheFlatFileSubdirectoryName);
 
             for (const auto& origin : origins)
                 storage->deleteCacheForOrigin(*origin);
@@ -910,8 +888,6 @@
     }
 
     if (dataTypes.contains(WebsiteDataType::WebSQLDatabases) && isPersistent()) {
-        StringCapture webSQLDatabaseDirectory { m_webSQLDatabaseDirectory };
-
         HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
         for (const auto& dataRecord : dataRecords) {
             for (const auto& origin : dataRecord.origins)
@@ -919,8 +895,8 @@
         }
 
         callbackAggregator->addPendingCallback();
-        m_queue->dispatch([origins, callbackAggregator, webSQLDatabaseDirectory] {
-            auto databaseTracker = WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory.string());
+        m_queue->dispatch([origins = WTFMove(origins), callbackAggregator, webSQLDatabaseDirectory = m_webSQLDatabaseDirectory.isolatedCopy()] {
+            auto databaseTracker = WebCore::DatabaseTracker::trackerWithDatabasePath(webSQLDatabaseDirectory);
 
             for (const auto& origin : origins)
                 databaseTracker->deleteOrigin(origin.get());
@@ -945,7 +921,6 @@
 #endif
 
     if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
-        StringCapture mediaKeysStorageDirectory { m_mediaKeysStorageDirectory };
         HashSet<RefPtr<WebCore::SecurityOrigin>> origins;
         for (const auto& dataRecord : dataRecords) {
             for (const auto& origin : dataRecord.origins)
@@ -953,9 +928,9 @@
         }
 
         callbackAggregator->addPendingCallback();
-        m_queue->dispatch([mediaKeysStorageDirectory, callbackAggregator, origins] {
+        m_queue->dispatch([mediaKeysStorageDirectory = m_mediaKeysStorageDirectory.isolatedCopy(), callbackAggregator, origins = WTFMove(origins)] {
 
-            removeMediaKeys(mediaKeysStorageDirectory.string(), origins);
+            removeMediaKeys(mediaKeysStorageDirectory, origins);
 
             RunLoop::main().dispatch([callbackAggregator] {
                 callbackAggregator->removePendingCallback();

_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to