Changeset 286507 in webkit

Timestamp:

Dec 3, 2021, 12:17:15 PM (5 years ago)

Author:

sihui_liu@apple.com

Message:

Fetch and remove file system data via WKWebsiteDataStore
​https://bugs.webkit.org/show_bug.cgi?id=233567

Reviewed by Youenn Fablet.

Source/WebCore:

• Modules/filesystemaccess/FileSystemStorageConnection.h:

Source/WebKit:

Introduce a new WebsiteDataType value FileSystem for FileSystemAccess data. Network process now can fetch and
delete this type of data when fetching and deleteing website data (if FileSystem type is included in target
types).

To track origins that have FileSystem data, this patch introduces a new file named origin in the origin's
directory. This file will be created when OriginStorageManager is created.

To delete existing FileSystem data, network process finds origins that are requested to be deleted and have data
on disk, closes active access handles, and deletes the files. The origin file mentioned above will be deleted if
there is no other file left in the same directory, and empty directories will be deleted.

New API tests: FileSystemAccess.FetchAndRemoveData

FileSystemAccess.RemoveDataByModificationTime
FileSystemAccess.FetchDataForThirdParty

• CMakeLists.txt:
• DerivedSources-input.xcfilelist:
• DerivedSources-output.xcfilelist:
• DerivedSources.make:
• NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp:

(WebKit::WebResourceLoadStatisticsStore::monitoredDataTypes):

• NetworkProcess/NetworkProcess.cpp:

(WebKit::NetworkProcess::fetchWebsiteData):
(WebKit::NetworkProcess::deleteWebsiteData):
(WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
(WebKit::NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains):
(WebKit::NetworkProcess::registrableDomainsWithWebsiteData):

• NetworkProcess/storage/FileSystemStorageHandle.h:

(WebKit::FileSystemStorageHandle::activeSyncAccessHandle const):

• NetworkProcess/storage/FileSystemStorageManager.cpp:

(WebKit::FileSystemStorageManager::~FileSystemStorageManager):
(WebKit::FileSystemStorageManager::close):

• NetworkProcess/storage/FileSystemStorageManager.h:
• NetworkProcess/storage/NetworkStorageManager.cpp:

(WebKit::readOriginFromFile):
(WebKit::writeOriginToFileIfNecessary):
(WebKit::deleteOriginFileIfNecessary):
(WebKit::originDirectoryPath):
(WebKit::originFilePath):
(WebKit::NetworkStorageManager::localOriginStorageManager):
(WebKit::NetworkStorageManager::removeOriginStorageManagerIfPossible):
(WebKit::toWebsiteDataType):
(WebKit::NetworkStorageManager::forEachOriginDirectory):
(WebKit::NetworkStorageManager::fetchDataFromDisk):
(WebKit::NetworkStorageManager::fetchData):
(WebKit::NetworkStorageManager::deleteDataOnDisk):
(WebKit::NetworkStorageManager::deleteData):
(WebKit::NetworkStorageManager::deleteDataModifiedSince):
(WebKit::NetworkStorageManager::deleteDataForRegistrableDomains):
(WebKit::originPath): Deleted.

• NetworkProcess/storage/NetworkStorageManager.h:
• NetworkProcess/storage/OriginStorageManager.cpp:

(WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier):
(WebKit::OriginStorageManager::StorageBucket::typeStoragePath const):
(WebKit::OriginStorageManager::StorageBucket::fileSystemStorageManager):
(WebKit::OriginStorageManager::StorageBucket::isActive):
(WebKit::OriginStorageManager::StorageBucket::deleteData):
(WebKit::OriginStorageManager::StorageBucket::deleteFileSystemStorageData):
(WebKit::OriginStorageManager::OriginStorageManager):
(WebKit::OriginStorageManager::isActive):
(WebKit::OriginStorageManager::deleteData):

• NetworkProcess/storage/OriginStorageManager.h:
• Shared/WebsiteData/WebsiteData.cpp:

(WebKit::WebsiteData::ownerProcess):

• Shared/WebsiteData/WebsiteDataType.h:
• UIProcess/API/Cocoa/WKWebsiteDataRecord.mm:

(dataTypesToString):

• UIProcess/API/Cocoa/WKWebsiteDataRecordInternal.h:

(WebKit::toWebsiteDataType):
(WebKit::toWKWebsiteDataTypes):

• UIProcess/API/Cocoa/WKWebsiteDataRecordPrivate.h:
• UIProcess/API/Cocoa/WKWebsiteDataStore.mm:

(+[WKWebsiteDataStore _allWebsiteDataTypesIncludingPrivate]):

• WebKit.xcodeproj/project.pbxproj:
• WebProcess/Network/NetworkProcessConnection.cpp:

(WebKit::NetworkProcessConnection::didReceiveMessage):

• WebProcess/WebCoreSupport/WebFileSystemStorageConnection.messages.in: Added.

Source/WTF:

• wtf/FileSystem.cpp:

(WTF::FileSystemImpl::readEntireFile): Read whole file content into a Vector.
(WTF::FileSystemImpl::deleteAllFilesModifiedSince): Recursively delete files and folders modified after
specified time in a directory.

• wtf/FileSystem.h:

Tools:

• TestWebKitAPI/Tests/WebKitCocoa/FileSystemAccess.mm:

Location:

trunk

Files:

• Source/WTF/ChangeLog (modified) (1 diff)
• Source/WTF/wtf/FileSystem.cpp (modified) (1 diff)
• Source/WTF/wtf/FileSystem.h (modified) (2 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/Modules/filesystemaccess/FileSystemStorageConnection.h (modified) (1 diff)
• Source/WebKit/CMakeLists.txt (modified) (1 diff)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/DerivedSources-input.xcfilelist (modified) (1 diff)
• Source/WebKit/DerivedSources-output.xcfilelist (modified) (1 diff)
• Source/WebKit/DerivedSources.make (modified) (1 diff)
• Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp (modified) (1 diff)
• Source/WebKit/NetworkProcess/NetworkProcess.cpp (modified) (5 diffs)
• Source/WebKit/NetworkProcess/storage/FileSystemStorageHandle.h (modified) (1 diff)
• Source/WebKit/NetworkProcess/storage/FileSystemStorageManager.cpp (modified) (3 diffs)
• Source/WebKit/NetworkProcess/storage/FileSystemStorageManager.h (modified) (1 diff)
• Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp (modified) (5 diffs)
• Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h (modified) (3 diffs)
• Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp (modified) (4 diffs)
• Source/WebKit/NetworkProcess/storage/OriginStorageManager.h (modified) (3 diffs)
• Source/WebKit/Shared/WebsiteData/WebsiteData.cpp (modified) (1 diff)
• Source/WebKit/Shared/WebsiteData/WebsiteDataType.h (modified) (2 diffs)
• Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataRecord.mm (modified) (2 diffs)
• Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataRecordInternal.h (modified) (2 diffs)
• Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataRecordPrivate.h (modified) (1 diff)
• Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm (modified) (1 diff)
• Source/WebKit/WebKit.xcodeproj/project.pbxproj (modified) (6 diffs)
• Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp (modified) (2 diffs)
• Source/WebKit/WebProcess/WebCoreSupport/WebFileSystemStorageConnection.messages.in (added)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WebKitCocoa/FileSystemAccess.mm (modified) (7 diffs)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2021-12-03  Sihui Liu  <sihui_liu@apple.com>
+
+        Fetch and remove file system data via WKWebsiteDataStore
+        https://bugs.webkit.org/show_bug.cgi?id=233567
+
+        Reviewed by Youenn Fablet.
+
+        * wtf/FileSystem.cpp:
+        (WTF::FileSystemImpl::readEntireFile): Read whole file content into a Vector.
+        (WTF::FileSystemImpl::deleteAllFilesModifiedSince): Recursively delete files and folders modified after 
+        specified time in a directory.
+        * wtf/FileSystem.h:
+
 2021-12-03  Tim Horton  <timothy_horton@apple.com>
 

trunk/Source/WTF/wtf/FileSystem.cpp

@@ -515 +515 @@
 }
 
+std::optional<Vector<uint8_t>> readEntireFile(PlatformFileHandle handle)
+{
+    if (!FileSystem::isHandleValid(handle))
+        return std::nullopt;
+
+    auto size = FileSystem::fileSize(handle).value_or(0);
+    if (!size)
+        return std::nullopt;
+
+    unsigned bytesToRead;
+    if (!WTF::convertSafely(size, bytesToRead))
+        return std::nullopt;
+
+    Vector<uint8_t> buffer(bytesToRead);
+    unsigned totalBytesRead = FileSystem::readFromFile(handle, buffer.data(), buffer.size());
+    if (totalBytesRead != bytesToRead)
+        return std::nullopt;
+
+    return buffer;
+}
+
+void deleteAllFilesModifiedSince(const String& directory, WallTime time)
+{
+    // This function may delete directory folder.
+    if (time == -WallTime::infinity()) {
+        deleteNonEmptyDirectory(directory);
+        return;
+    }
+
+    auto children = listDirectory(directory);
+    for (auto& child : children) {
+        auto childPath = FileSystem::pathByAppendingComponent(directory, child);
+        auto childType = fileType(childPath);
+        if (!childType)
+            continue;
+
+        switch (*childType) {
+        case FileType::Regular: {
+            if (auto modificationTime = FileSystem::fileModificationTime(childPath); modificationTime && *modificationTime >= time)
+                deleteFile(childPath);
+            break;
+        }
+        case FileType::Directory:
+            deleteAllFilesModifiedSince(childPath, time);
+            deleteEmptyDirectory(childPath);
+            break;
+        case FileType::SymbolicLink:
+            break;
+        }
+    }
+
+    FileSystem::deleteEmptyDirectory(directory);
+}
+
 #if HAVE(STD_FILESYSTEM) || HAVE(STD_EXPERIMENTAL_FILESYSTEM)
 

trunk/Source/WTF/wtf/FileSystem.h

@@ -109 +109 @@
 WTF_EXPORT_PRIVATE bool fileExists(const String&);
 WTF_EXPORT_PRIVATE bool deleteFile(const String&);
+WTF_EXPORT_PRIVATE void deleteAllFilesModifiedSince(const String&, WallTime);
 WTF_EXPORT_PRIVATE bool deleteEmptyDirectory(const String&);
 WTF_EXPORT_PRIVATE bool moveFile(const String& oldPath, const String& newPath);
@@ -147 +148 @@
 using Salt = std::array<uint8_t, 8>;
 WTF_EXPORT_PRIVATE std::optional<Salt> readOrMakeSalt(const String& path);
+WTF_EXPORT_PRIVATE std::optional<Vector<uint8_t>> readEntireFile(PlatformFileHandle);
 
 // Prefix is what the filename should be prefixed with, not the full path.

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2021-12-03  Sihui Liu  <sihui_liu@apple.com>
+
+        Fetch and remove file system data via WKWebsiteDataStore
+        https://bugs.webkit.org/show_bug.cgi?id=233567
+
+        Reviewed by Youenn Fablet.
+
+        * Modules/filesystemaccess/FileSystemStorageConnection.h:
+
 2021-12-03  Alan Bujtas  <zalan@apple.com>
 

trunk/Source/WebCore/Modules/filesystemaccess/FileSystemStorageConnection.h

@@ -28 +28 @@
 #include "FileSystemHandleIdentifier.h"
 #include "FileSystemSyncAccessHandleIdentifier.h"
+#include "ProcessQualified.h"
 #include "ScriptExecutionContextIdentifier.h"
 #include <wtf/CompletionHandler.h>

trunk/Source/WebKit/CMakeLists.txt

@@ -311 +311 @@
     WebProcess/WebCoreSupport/RemoteWebLockRegistry
     WebProcess/WebCoreSupport/WebBroadcastChannelRegistry
+    WebProcess/WebCoreSupport/WebFileSystemStorageConnection
     WebProcess/WebCoreSupport/WebSpeechRecognitionConnection
 

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2021-12-03  Sihui Liu  <sihui_liu@apple.com>
+
+        Fetch and remove file system data via WKWebsiteDataStore
+        https://bugs.webkit.org/show_bug.cgi?id=233567
+
+        Reviewed by Youenn Fablet.
+
+        Introduce a new WebsiteDataType value FileSystem for FileSystemAccess data. Network process now can fetch and 
+        delete this type of data when fetching and deleteing website data (if FileSystem type is included in target
+        types).
+
+        To track origins that have FileSystem data, this patch introduces a new file named origin in the origin's 
+        directory. This file will be created when OriginStorageManager is created.
+
+        To delete existing FileSystem data, network process finds origins that are requested to be deleted and have data 
+        on disk, closes active access handles, and deletes the files. The origin file mentioned above will be deleted if 
+        there is no other file left in the same directory, and empty directories will be deleted.
+
+        New API tests: FileSystemAccess.FetchAndRemoveData
+                       FileSystemAccess.RemoveDataByModificationTime
+                       FileSystemAccess.FetchDataForThirdParty
+
+        * CMakeLists.txt:
+        * DerivedSources-input.xcfilelist:
+        * DerivedSources-output.xcfilelist:
+        * DerivedSources.make:
+        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp:
+        (WebKit::WebResourceLoadStatisticsStore::monitoredDataTypes):
+        * NetworkProcess/NetworkProcess.cpp:
+        (WebKit::NetworkProcess::fetchWebsiteData):
+        (WebKit::NetworkProcess::deleteWebsiteData):
+        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
+        (WebKit::NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains):
+        (WebKit::NetworkProcess::registrableDomainsWithWebsiteData):
+        * NetworkProcess/storage/FileSystemStorageHandle.h:
+        (WebKit::FileSystemStorageHandle::activeSyncAccessHandle const):
+        * NetworkProcess/storage/FileSystemStorageManager.cpp:
+        (WebKit::FileSystemStorageManager::~FileSystemStorageManager):
+        (WebKit::FileSystemStorageManager::close):
+        * NetworkProcess/storage/FileSystemStorageManager.h:
+        * NetworkProcess/storage/NetworkStorageManager.cpp:
+        (WebKit::readOriginFromFile):
+        (WebKit::writeOriginToFileIfNecessary):
+        (WebKit::deleteOriginFileIfNecessary):
+        (WebKit::originDirectoryPath):
+        (WebKit::originFilePath):
+        (WebKit::NetworkStorageManager::localOriginStorageManager):
+        (WebKit::NetworkStorageManager::removeOriginStorageManagerIfPossible):
+        (WebKit::toWebsiteDataType):
+        (WebKit::NetworkStorageManager::forEachOriginDirectory):
+        (WebKit::NetworkStorageManager::fetchDataFromDisk):
+        (WebKit::NetworkStorageManager::fetchData):
+        (WebKit::NetworkStorageManager::deleteDataOnDisk):
+        (WebKit::NetworkStorageManager::deleteData):
+        (WebKit::NetworkStorageManager::deleteDataModifiedSince):
+        (WebKit::NetworkStorageManager::deleteDataForRegistrableDomains):
+        (WebKit::originPath): Deleted.
+        * NetworkProcess/storage/NetworkStorageManager.h:
+        * NetworkProcess/storage/OriginStorageManager.cpp:
+        (WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier):
+        (WebKit::OriginStorageManager::StorageBucket::typeStoragePath const):
+        (WebKit::OriginStorageManager::StorageBucket::fileSystemStorageManager):
+        (WebKit::OriginStorageManager::StorageBucket::isActive):
+        (WebKit::OriginStorageManager::StorageBucket::deleteData):
+        (WebKit::OriginStorageManager::StorageBucket::deleteFileSystemStorageData):
+        (WebKit::OriginStorageManager::OriginStorageManager):
+        (WebKit::OriginStorageManager::isActive):
+        (WebKit::OriginStorageManager::deleteData):
+        * NetworkProcess/storage/OriginStorageManager.h:
+        * Shared/WebsiteData/WebsiteData.cpp:
+        (WebKit::WebsiteData::ownerProcess):
+        * Shared/WebsiteData/WebsiteDataType.h:
+        * UIProcess/API/Cocoa/WKWebsiteDataRecord.mm:
+        (dataTypesToString):
+        * UIProcess/API/Cocoa/WKWebsiteDataRecordInternal.h:
+        (WebKit::toWebsiteDataType):
+        (WebKit::toWKWebsiteDataTypes):
+        * UIProcess/API/Cocoa/WKWebsiteDataRecordPrivate.h:
+        * UIProcess/API/Cocoa/WKWebsiteDataStore.mm:
+        (+[WKWebsiteDataStore _allWebsiteDataTypesIncludingPrivate]):
+        * WebKit.xcodeproj/project.pbxproj:
+        * WebProcess/Network/NetworkProcessConnection.cpp:
+        (WebKit::NetworkProcessConnection::didReceiveMessage):
+        * WebProcess/WebCoreSupport/WebFileSystemStorageConnection.messages.in: Added.
+
 2021-12-03  Chris Dumez  <cdumez@apple.com>
 

trunk/Source/WebKit/DerivedSources-input.xcfilelist

@@ -222 +222 @@
 $(PROJECT_DIR)/WebProcess/WebCoreSupport/WebBroadcastChannelRegistry.messages.in
 $(PROJECT_DIR)/WebProcess/WebCoreSupport/WebDeviceOrientationUpdateProvider.messages.in
+$(PROJECT_DIR)/WebProcess/WebCoreSupport/WebFileSystemStorageConnection.messages.in
 $(PROJECT_DIR)/WebProcess/WebCoreSupport/WebSpeechRecognitionConnection.messages.in
 $(PROJECT_DIR)/WebProcess/WebPage/Cocoa/TextCheckingControllerProxy.messages.in

trunk/Source/WebKit/DerivedSources-output.xcfilelist

@@ -494 +494 @@
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebDeviceOrientationUpdateProviderProxyMessages.h
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebDeviceOrientationUpdateProviderProxyMessagesReplies.h
+$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebFileSystemStorageConnectionMessageReceiver.cpp
+$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebFileSystemStorageConnectionMessages.h
+$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebFileSystemStorageConnectionMessagesReplies.h
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebFullScreenManagerMessageReceiver.cpp
 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit2/WebFullScreenManagerMessages.h

trunk/Source/WebKit/DerivedSources.make

@@ -223 +223 @@
         WebProcess/WebCoreSupport/WebBroadcastChannelRegistry \
         WebProcess/WebCoreSupport/WebDeviceOrientationUpdateProvider \
+        WebProcess/WebCoreSupport/WebFileSystemStorageConnection \
         WebProcess/WebCoreSupport/WebSpeechRecognitionConnection \
         WebProcess/Speech/SpeechRecognitionRealtimeMediaSourceManager \

trunk/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp

@@ -75 +75 @@
         WebsiteDataType::ServiceWorkerRegistrations,
 #endif
+        WebsiteDataType::FileSystem,
     }));
 

trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

@@ -1556 +1556 @@
     }
 #endif
+
+    if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end()) {
+        iterator->value->fetchData(websiteDataTypes, [callbackAggregator](auto entries) mutable {
+            callbackAggregator->m_websiteData.entries.appendVector(WTFMove(entries));
+        });
+    }
 }
 
@@ -1630 +1636 @@
     }
 #endif
+
+    if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end())
+        iterator->value->deleteDataModifiedSince(websiteDataTypes, modifiedSince, [clearTasksHandler] { });
 }
 
@@ -1736 +1745 @@
     }
 #endif
+
+    if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end())
+        iterator->value->deleteData(websiteDataTypes, originDatas, [clearTasksHandler] { });
 
     if (auto* networkSession = this->networkSession(sessionID)) {
@@ -1960 +1972 @@
     }
 
+    if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end()) {
+        iterator->value->deleteDataForRegistrableDomains(websiteDataTypes, domainsToDeleteAllNonCookieWebsiteDataFor, [callbackAggregator](auto deletedDomains) mutable {
+            for (auto domain : deletedDomains)
+                callbackAggregator->m_domains.add(WTFMove(domain));
+        });
+    }
+
     auto dataTypesForUIProcess = WebsiteData::filter(websiteDataTypes, WebsiteDataProcessType::UI);
     if (!dataTypesForUIProcess.isEmpty() && !domainsToDeleteAllNonCookieWebsiteDataFor.isEmpty()) {
@@ -2074 +2093 @@
                 callbackAggregator->m_websiteData.entries.appendVector(entries);
             });
+        });
+    }
+
+    if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end()) {
+        iterator->value->fetchData(websiteDataTypes, [callbackAggregator](auto entries) mutable {
+            callbackAggregator->m_websiteData.entries.appendVector(WTFMove(entries));
         });
     }

trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageHandle.h

@@ -63 +63 @@
     Expected<AccessHandleInfo, FileSystemStorageError> createSyncAccessHandle();
     std::optional<FileSystemStorageError> close(WebCore::FileSystemSyncAccessHandleIdentifier);
+    std::optional<WebCore::FileSystemSyncAccessHandleIdentifier> activeSyncAccessHandle() const { return m_activeSyncAccessHandle; }
 
 private:

trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageManager.cpp

@@ -29 +29 @@
 #include "FileSystemStorageError.h"
 #include "FileSystemStorageHandleRegistry.h"
+#include "WebFileSystemStorageConnectionMessages.h"
 
 namespace WebKit {
@@ -43 +44 @@
     ASSERT(!RunLoop::isMain());
 
-    for (auto identifier : m_handles.keys())
-        m_registry.unregisterHandle(identifier);
+    close();
 }
 
@@ -150 +150 @@
 }
 
+void FileSystemStorageManager::close()
+{
+    ASSERT(!RunLoop::isMain());
+
+    for (auto& [connectionID, identifiers] : m_handlesByConnection) {
+        for (auto identifier : identifiers) {
+            auto takenHandle = m_handles.take(identifier);
+            m_registry.unregisterHandle(identifier);
+
+            // Send message to web process to invalidate active sync access handle.
+            if (auto accessHandleIdentifier = takenHandle->activeSyncAccessHandle())
+                IPC::Connection::send(connectionID, Messages::WebFileSystemStorageConnection::InvalidateAccessHandle(*accessHandleIdentifier), 0);
+        }
+    }
+
+    ASSERT(m_handles.isEmpty());
+    m_handlesByConnection.clear();
+    m_lockMap.clear();
+}
+
 } // namespace WebKit

trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageManager.h

@@ -50 +50 @@
 
 private:
+    void close();
+
     String m_path;
     FileSystemStorageHandleRegistry& m_registry;

trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp

@@ -31 +31 @@
 #include "NetworkStorageManagerMessages.h"
 #include "OriginStorageManager.h"
+#include "WebsiteDataType.h"
 #include <pal/crypto/CryptoDigest.h>
+#include <wtf/Scope.h>
+#include <wtf/persistence/PersistentDecoder.h>
+#include <wtf/persistence/PersistentEncoder.h>
 #include <wtf/text/Base64.h>
 
 namespace WebKit {
+
+static std::optional<WebCore::ClientOrigin> readOriginFromFile(const String& filePath)
+{
+    ASSERT(!RunLoop::isMain());
+
+    if (!FileSystem::fileExists(filePath))
+        return std::nullopt;
+
+    auto originFileHandle = FileSystem::openFile(filePath, FileSystem::FileOpenMode::Read);
+    auto closeFile = makeScopeExit([&] {
+        FileSystem::closeFile(originFileHandle);
+    });
+
+    if (!FileSystem::isHandleValid(originFileHandle))
+        return std::nullopt;
+
+    auto originContent = FileSystem::readEntireFile(originFileHandle);
+    if (!originContent)
+        return std::nullopt;
+
+    WTF::Persistence::Decoder decoder({ originContent->data(), originContent->size() });
+    std::optional<WebCore::ClientOrigin> origin;
+    decoder >> origin;
+    return origin;
+}
+
+static void writeOriginToFileIfNecessary(const String& filePath, const WebCore::ClientOrigin& origin)
+{
+    if (FileSystem::fileExists(filePath))
+        return;
+
+    FileSystem::makeAllDirectories(FileSystem::parentPath(filePath));
+    auto originFileHandle = FileSystem::openFile(filePath, FileSystem::FileOpenMode::ReadWrite);
+    auto closeFile = makeScopeExit([&] {
+        FileSystem::closeFile(originFileHandle);
+    });
+
+    if (!FileSystem::isHandleValid(originFileHandle)) {
+        LOG_ERROR("writeOriginToFileIfNecessary: Failed to open origin file");
+        return;
+    }
+
+    WTF::Persistence::Encoder encoder;
+    encoder << origin;
+    FileSystem::writeToFile(originFileHandle, encoder.buffer(), encoder.bufferSize());
+}
+
+static void deleteOriginFileIfNecessary(const String& filePath)
+{
+    auto parentPath = FileSystem::parentPath(filePath);
+    auto children = FileSystem::listDirectory(parentPath);
+    if (children.size() == 1)
+        FileSystem::deleteFile(filePath);
+}
 
 Ref<NetworkStorageManager> NetworkStorageManager::create(PAL::SessionID sessionID, const String& path)
@@ -117 +175 @@
 }
 
-static String originPath(const String& rootPath, const WebCore::ClientOrigin& origin, FileSystem::Salt salt)
+static String originDirectoryPath(const String& rootPath, const WebCore::ClientOrigin& origin, FileSystem::Salt salt)
 {
     if (rootPath.isEmpty())
@@ -127 +185 @@
 }
 
+static String originFilePath(const String& directory)
+{
+    return FileSystem::pathByAppendingComponent(directory, "origin"_s);
+}
+
 OriginStorageManager& NetworkStorageManager::localOriginStorageManager(const WebCore::ClientOrigin& origin)
 {
@@ -132 +195 @@
 
     return *m_localOriginStorageManagers.ensure(origin, [&] {
-        return makeUnique<OriginStorageManager>(originPath(m_path, origin, m_salt));
+        auto originDirectory = originDirectoryPath(m_path, origin, m_salt);
+        writeOriginToFileIfNecessary(originFilePath(originDirectory), origin);
+        return makeUnique<OriginStorageManager>(WTFMove(originDirectory));
     }).iterator->value;
+}
+
+void NetworkStorageManager::removeOriginStorageManagerIfPossible(const WebCore::ClientOrigin& origin)
+{
+    if (auto iterator = m_localOriginStorageManagers.find(origin); iterator != m_localOriginStorageManagers.end()) {
+        if (!iterator->value->isActive())
+            m_localOriginStorageManagers.remove(iterator);
+    }
 }
 
@@ -306 +379 @@
 }
 
+static std::optional<WebsiteDataType> toWebsiteDataType(const String& storageType)
+{
+    if (storageType == "FileSystem")
+        return WebsiteDataType::FileSystem;
+
+    return std::nullopt;
+}
+
+void NetworkStorageManager::forEachOriginDirectory(const Function<void(const String&)>& apply)
+{
+    for (auto& topOrigin : FileSystem::listDirectory(m_path)) {
+        auto topOriginDirectory = FileSystem::pathByAppendingComponent(m_path, topOrigin);
+        auto openingOrigins = FileSystem::listDirectory(topOriginDirectory);
+        if (openingOrigins.isEmpty()) {
+            FileSystem::deleteEmptyDirectory(topOriginDirectory);
+            continue;
+        }
+
+        for (auto& openingOrigin : openingOrigins) {
+            auto openingOriginDirectory = FileSystem::pathByAppendingComponent(topOriginDirectory, openingOrigin);
+            apply(openingOriginDirectory);
+        }
+    }
+}
+
+Vector<WebsiteData::Entry> NetworkStorageManager::fetchDataFromDisk(OptionSet<WebsiteDataType> targetTypes)
+{
+    ASSERT(!RunLoop::isMain());
+
+    HashMap<WebCore::SecurityOriginData, OptionSet<WebsiteDataType>> originTypes;
+    forEachOriginDirectory([&](auto directory) mutable {
+        auto origin = readOriginFromFile(originFilePath(directory));
+        if (!origin)
+            return;
+
+        for (auto& storageType : FileSystem::listDirectory(directory)) {
+            if (auto type = toWebsiteDataType(storageType); type && targetTypes.contains(*type)) {
+                // Return both top origin and opening origin for this data.
+                originTypes.add(origin->clientOrigin, OptionSet<WebsiteDataType> { }).iterator->value.add(*type);
+                originTypes.add(origin->topOrigin, OptionSet<WebsiteDataType> { }).iterator->value.add(*type);
+            }
+        }
+    });
+
+    Vector<WebsiteData::Entry> entries;
+    for (auto [origin, types] : originTypes) {
+        for (auto type : types)
+            entries.append({ WebsiteData::Entry { origin, type, 0 } });
+    }
+
+    return entries;
+}
+
+void NetworkStorageManager::fetchData(OptionSet<WebsiteDataType> types, CompletionHandler<void(Vector<WebsiteData::Entry>&&)>&& completionHandler)
+{
+    ASSERT(RunLoop::isMain());
+    ASSERT(!m_closed);
+
+    m_queue->dispatch([this, protectedThis = Ref { *this }, types, completionHandler = WTFMove(completionHandler)]() mutable {
+        auto entries = fetchDataFromDisk(types);
+        RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler), entries = crossThreadCopy(WTFMove(entries))]() mutable {
+            completionHandler(WTFMove(entries));
+        });
+    });
+}
+
+Vector<WebCore::ClientOrigin> NetworkStorageManager::deleteDataOnDisk(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime, const Function<bool(const WebCore::ClientOrigin&)>& filter)
+{
+    ASSERT(!RunLoop::isMain());
+
+    Vector<WebCore::ClientOrigin> deletedOrigins;
+    forEachOriginDirectory([&](auto directory) mutable {
+        auto filePath = originFilePath(directory);
+        auto origin = readOriginFromFile(filePath);
+        if (!origin) {
+            // If origin cannot be retrieved, but we are asked to remove data for all origins, remove it.
+            RELEASE_LOG_ERROR(Storage, "NetworkStorageManager::deleteDataOnDisk failed to read origin from '%s'", filePath.utf8().data());
+            if (filter(WebCore::ClientOrigin { })) {
+                FileSystem::deleteAllFilesModifiedSince(directory, modifiedSinceTime);
+                FileSystem::deleteEmptyDirectory(directory);
+            }
+            return;
+        }
+
+        if (!filter(*origin))
+            return;
+
+        deletedOrigins.append(*origin);
+        localOriginStorageManager(*origin).deleteData(types, modifiedSinceTime);
+        removeOriginStorageManagerIfPossible(*origin);
+        deleteOriginFileIfNecessary(filePath);
+        FileSystem::deleteEmptyDirectory(directory);
+    });
+
+    return deletedOrigins;
+}
+
+void NetworkStorageManager::deleteData(OptionSet<WebsiteDataType> types, const Vector<WebCore::SecurityOriginData>& origins, CompletionHandler<void()>&& completionHandler)
+{
+    ASSERT(RunLoop::isMain());
+    ASSERT(!m_closed);
+
+    m_queue->dispatch([this, protectedThis = Ref { *this }, types, origins = crossThreadCopy(origins), completionHandler = WTFMove(completionHandler)]() mutable {
+        HashSet<WebCore::SecurityOriginData> originSet;
+        originSet.reserveInitialCapacity(origins.size());
+        for (auto origin : origins)
+            originSet.add(WTFMove(origin));
+
+        deleteDataOnDisk(types, -WallTime::infinity(), [&originSet](auto origin) {
+            return originSet.contains(origin.topOrigin) || originSet.contains(origin.clientOrigin);
+        });
+
+        RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)]() mutable {
+            completionHandler();
+        });
+    });
+}
+
+void NetworkStorageManager::deleteDataModifiedSince(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime, CompletionHandler<void()>&& completionHandler)
+{
+    ASSERT(RunLoop::isMain());
+    ASSERT(!m_closed);
+
+    m_queue->dispatch([this, protectedThis = Ref { *this }, types, modifiedSinceTime, completionHandler = WTFMove(completionHandler)]() mutable {
+        deleteDataOnDisk(types, modifiedSinceTime, [](auto&) {
+            return true;
+        });
+
+        RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)]() mutable {
+            completionHandler();
+        });
+    });
+}
+
+void NetworkStorageManager::deleteDataForRegistrableDomains(OptionSet<WebsiteDataType> types, const Vector<WebCore::RegistrableDomain>& domains, CompletionHandler<void(HashSet<WebCore::RegistrableDomain>&&)>&& completionHandler)
+{
+    ASSERT(RunLoop::isMain());
+    ASSERT(!m_closed);
+
+    m_queue->dispatch([this, protectedThis = Ref { *this }, types, domains = crossThreadCopy(domains), completionHandler = WTFMove(completionHandler)]() mutable {
+        auto deletedOrigins = deleteDataOnDisk(types, -WallTime::infinity(), [&domains](auto& origin) {
+            auto domain = WebCore::RegistrableDomain::uncheckedCreateFromHost(origin.clientOrigin.host);
+            return domains.contains(domain);
+        });
+
+        HashSet<WebCore::RegistrableDomain> deletedDomains;
+        for (auto origin : deletedOrigins) {
+            auto domain = WebCore::RegistrableDomain::uncheckedCreateFromHost(origin.clientOrigin.host);
+            deletedDomains.add(domain);
+        }
+
+        RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler), domains = crossThreadCopy(WTFMove(deletedDomains))]() mutable {
+            completionHandler(WTFMove(domains));
+        });
+    });
+}
+
 } // namespace WebKit
 

trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h

@@ -29 +29 @@
 #include "FileSystemStorageError.h"
 #include "OriginStorageManager.h"
+#include "WebsiteData.h"
 #include <WebCore/ClientOrigin.h>
 #include <WebCore/FileSystemHandleIdentifier.h>
 #include <WebCore/FileSystemSyncAccessHandleIdentifier.h>
 #include <pal/SessionID.h>
+#include <wtf/Forward.h>
 
 namespace IPC {
@@ -56 +58 @@
     void close();
     void clearStorageForTesting(CompletionHandler<void()>&&);
+    void fetchData(OptionSet<WebsiteDataType>, CompletionHandler<void(Vector<WebsiteData::Entry>&&)>&&);
+    void deleteData(OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, CompletionHandler<void()>&&);
+    void deleteDataModifiedSince(OptionSet<WebsiteDataType>, WallTime, CompletionHandler<void()>&&);
+    void deleteDataForRegistrableDomains(OptionSet<WebsiteDataType>, const Vector<WebCore::RegistrableDomain>&, CompletionHandler<void(HashSet<WebCore::RegistrableDomain>&&)>&&);
 
 private:
@@ -61 +67 @@
     ~NetworkStorageManager();
     OriginStorageManager& localOriginStorageManager(const WebCore::ClientOrigin&);
+    void removeOriginStorageManagerIfPossible(const WebCore::ClientOrigin&);
     FileSystemStorageHandleRegistry& fileSystemStorageHandleRegistry();
+
+    void forEachOriginDirectory(const Function<void(const String&)>&);
+    Vector<WebsiteData::Entry> fetchDataFromDisk(OptionSet<WebsiteDataType>);
+    Vector<WebCore::ClientOrigin> deleteDataOnDisk(OptionSet<WebsiteDataType>, WallTime, const Function<bool(const WebCore::ClientOrigin&)>&);
 
     // IPC::MessageReceiver (implemented by generated code)

trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp

@@ -52 +52 @@
     }
 
-    String typeStoragePath(const String& storageIdentifier) const
+    enum class StorageType : uint8_t {
+        FileSystem,
+    };
+
+    static String toStorageIdentifier(StorageType type)
     {
-        return m_rootPath.isEmpty() ? emptyString() : FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
+        switch (type) {
+        case StorageType::FileSystem:
+            return "FileSystem"_s;
+        default:
+            break;
+        }
+        ASSERT_NOT_REACHED();
+        return ""_s;
+    }
+
+    String typeStoragePath(StorageType type) const
+    {
+        auto storageIdentifier = toStorageIdentifier(type);
+        if (m_rootPath.isEmpty() || storageIdentifier.isEmpty())
+            return emptyString();
+
+        return FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
     }
 
@@ -60 +80 @@
     {
         if (!m_fileSystemStorageManager)
-            m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath("FileSystem"), registry);
+            m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath(StorageType::FileSystem), registry);
 
         return *m_fileSystemStorageManager;
     }
 
+    bool isActive()
+    {
+        return !!m_fileSystemStorageManager;
+    }
+
+    void deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime)
+    {
+        if (types.contains(WebsiteDataType::FileSystem))
+            deleteFileSystemStorageData(modifiedSinceTime);
+
+        FileSystem::deleteNonEmptyDirectory(m_rootPath);
+    }
+
 private:
+    void deleteFileSystemStorageData(WallTime modifiedSinceTime)
+    {
+        m_fileSystemStorageManager = nullptr;
+
+        auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
+        FileSystem::deleteAllFilesModifiedSince(fileSystemStoragePath, modifiedSinceTime);
+    }
+
     String m_rootPath;
     String m_identifier;
@@ -75 +116 @@
     : m_path(WTFMove(path))
 {
+    ASSERT(!RunLoop::isMain());
 }
 
@@ -104 +146 @@
 }
 
+bool OriginStorageManager::isActive()
+{
+    return defaultBucket().isActive();
+}
+
+void OriginStorageManager::deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSince)
+{
+    ASSERT(!RunLoop::isMain());
+    defaultBucket().deleteData(types, modifiedSince);
+}
+
 } // namespace WebKit
 

trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.h

@@ -29 +29 @@
 #include <wtf/text/WTFString.h>
 
+namespace WebCore {
+struct ClientOrigin;
+}
+
 namespace WebKit {
 
 class FileSystemStorageHandleRegistry;
 class FileSystemStorageManager;
+enum class WebsiteDataType : uint32_t;
 
 class OriginStorageManager {
@@ -44 +49 @@
     void persist();
     FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry&);
+    bool isActive();
+    void deleteData(OptionSet<WebsiteDataType>, WallTime);
 
 private:
@@ -49 +56 @@
     class StorageBucket;
     StorageBucket& defaultBucket();
+
+    void createOriginFileIfNecessary(const WebCore::ClientOrigin&);
+    void deleteOriginFileIfNecessary();
 
     std::unique_ptr<StorageBucket> m_defaultBucket;

trunk/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp

@@ -130 +130 @@
         return WebsiteDataProcessType::Network;
 #endif
+    case WebsiteDataType::FileSystem:
+        return WebsiteDataProcessType::Network;
     }
 

trunk/Source/WebKit/Shared/WebsiteData/WebsiteDataType.h

@@ -53 +53 @@
     AlternativeServices = 1 << 18,
 #endif
+    FileSystem = 1 << 19,
 };
 
@@ -80 +81 @@
         WebKit::WebsiteDataType::DOMCache,
         WebKit::WebsiteDataType::DeviceIdHashSalt,
-        WebKit::WebsiteDataType::PrivateClickMeasurements
+        WebKit::WebsiteDataType::PrivateClickMeasurements,
 #if HAVE(CFNETWORK_ALTERNATIVE_SERVICE)
-        , WebKit::WebsiteDataType::AlternativeServices
+        WebKit::WebsiteDataType::AlternativeServices,
 #endif
+        WebKit::WebsiteDataType::FileSystem
     >;
 };

trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataRecord.mm

@@ -52 +52 @@
 NSString * const _WKWebsiteDataTypePrivateClickMeasurements = @"_WKWebsiteDataTypePrivateClickMeasurements";
 NSString * const _WKWebsiteDataTypeAlternativeServices = @"_WKWebsiteDataTypeAlternativeServices";
+NSString * const _WKWebsiteDataTypeFileSystem = @"_WKWebsiteDataTypeFileSystem";
 
 #if PLATFORM(MAC)
@@ -111 +112 @@
     if ([dataTypes containsObject:_WKWebsiteDataTypeAlternativeServices])
         [array addObject:@"Alternative Services"];
+    if ([dataTypes containsObject:_WKWebsiteDataTypeFileSystem])
+        [array addObject:@"File System"];
 
     return [array componentsJoinedByString:@", "];

trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataRecordInternal.h

@@ -78 +78 @@
         return WebsiteDataType::AlternativeServices;
 #endif
+    if ([websiteDataType isEqualToString:_WKWebsiteDataTypeFileSystem])
+        return WebsiteDataType::FileSystem;
     return std::nullopt;
 }
@@ -135 +137 @@
         [wkWebsiteDataTypes addObject:_WKWebsiteDataTypeAlternativeServices];
 #endif
+    if (websiteDataTypes.contains(WebsiteDataType::FileSystem))
+        [wkWebsiteDataTypes addObject:_WKWebsiteDataTypeFileSystem];
 
     return wkWebsiteDataTypes;

trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataRecordPrivate.h

@@ -38 +38 @@
 WK_EXTERN NSString * const _WKWebsiteDataTypePrivateClickMeasurements WK_API_AVAILABLE(macos(12.0), ios(15.0));
 WK_EXTERN NSString * const _WKWebsiteDataTypeAlternativeServices WK_API_AVAILABLE(macos(11.0), ios(14.0));
+WK_EXTERN NSString * const _WKWebsiteDataTypeFileSystem WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
 
 #if !TARGET_OS_IPHONE

trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm

@@ -249 +249 @@
             _WKWebsiteDataTypeAdClickAttributions,
             _WKWebsiteDataTypePrivateClickMeasurements,
-            _WKWebsiteDataTypeAlternativeServices
+            _WKWebsiteDataTypeAlternativeServices,
+            _WKWebsiteDataTypeFileSystem
 #if !TARGET_OS_IPHONE
             , _WKWebsiteDataTypePlugInData

trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

@@ -1500 +1500 @@
                 93D6B7B925534A170058DD3A /* WKSpeechRecognitionPermissionCallback.h in Headers */ = {isa = PBXBuildFile; fileRef = 93D6B7B725534A110058DD3A /* WKSpeechRecognitionPermissionCallback.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 93E6A4EE1BC5DD3900F8A0E7 /* _WKHitTestResult.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E6A4ED1BC5DD3900F8A0E7 /* _WKHitTestResult.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                93E799852756FA550074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93E799822756FA540074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp */; };
+                93E799872756FAB40074008A /* WebFileSystemStorageConnectionMessagesReplies.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E799832756FA540074008A /* WebFileSystemStorageConnectionMessagesReplies.h */; };
+                93E799882756FAC20074008A /* WebFileSystemStorageConnectionMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E799812756FA530074008A /* WebFileSystemStorageConnectionMessages.h */; };
                 93F549B41E3174B7000E7239 /* WKSnapshotConfiguration.h in Headers */ = {isa = PBXBuildFile; fileRef = 93F549B31E3174B7000E7239 /* WKSnapshotConfiguration.h */; settings = {ATTRIBUTES = (Public, ); }; };
                 950F2880252414EA00B74F1C /* WKMouseDeviceObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 950F287E252414E900B74F1C /* WKMouseDeviceObserver.h */; };
@@ -5302 +5305 @@
                 93D6B7B825534A120058DD3A /* WKSpeechRecognitionPermissionCallback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WKSpeechRecognitionPermissionCallback.cpp; sourceTree = "<group>"; };
                 93E6A4ED1BC5DD3900F8A0E7 /* _WKHitTestResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKHitTestResult.h; sourceTree = "<group>"; };
+                93E7997E2756F6700074008A /* WebFileSystemStorageConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebFileSystemStorageConnection.messages.in; sourceTree = "<group>"; };
+                93E799812756FA530074008A /* WebFileSystemStorageConnectionMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFileSystemStorageConnectionMessages.h; sourceTree = "<group>"; };
+                93E799822756FA540074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebFileSystemStorageConnectionMessageReceiver.cpp; sourceTree = "<group>"; };
+                93E799832756FA540074008A /* WebFileSystemStorageConnectionMessagesReplies.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFileSystemStorageConnectionMessagesReplies.h; sourceTree = "<group>"; };
                 93F549B31E3174B7000E7239 /* WKSnapshotConfiguration.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKSnapshotConfiguration.h; sourceTree = "<group>"; };
                 93F549B51E3174DA000E7239 /* WKSnapshotConfiguration.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKSnapshotConfiguration.mm; sourceTree = "<group>"; };
@@ -10583 +10590 @@
                                 9354242B2703BDCB005CA72C /* WebFileSystemStorageConnection.cpp */,
                                 9354242A2703BDCB005CA72C /* WebFileSystemStorageConnection.h */,
+                                93E7997E2756F6700074008A /* WebFileSystemStorageConnection.messages.in */,
                                 BC111A58112F4FBB00337BAB /* WebFrameLoaderClient.cpp */,
                                 BC032D6A10F4378D0058C15A /* WebFrameLoaderClient.h */,
@@ -12060 +12068 @@
                                 E3866B042399979C00F88FE9 /* WebDeviceOrientationUpdateProviderProxyMessageReceiver.cpp */,
                                 E3866B052399979C00F88FE9 /* WebDeviceOrientationUpdateProviderProxyMessages.h */,
+                                93E799822756FA540074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp */,
+                                93E799812756FA530074008A /* WebFileSystemStorageConnectionMessages.h */,
+                                93E799832756FA540074008A /* WebFileSystemStorageConnectionMessagesReplies.h */,
                                 CD73BA48131ACD8E00EEDED2 /* WebFullScreenManagerMessageReceiver.cpp */,
                                 CD73BA49131ACD8E00EEDED2 /* WebFullScreenManagerMessages.h */,
@@ -13307 +13318 @@
                                 BC111B5D112F629800337BAB /* WebEventFactory.h in Headers */,
                                 9354242C2703BDCB005CA72C /* WebFileSystemStorageConnection.h in Headers */,
+                                93E799882756FAC20074008A /* WebFileSystemStorageConnectionMessages.h in Headers */,
+                                93E799872756FAB40074008A /* WebFileSystemStorageConnectionMessagesReplies.h in Headers */,
                                 1A90C1EE1264FD50003E44D4 /* WebFindOptions.h in Headers */,
                                 BCE469541214E6CB000B98EB /* WebFormClient.h in Headers */,
@@ -15403 +15416 @@
                                 E3866B092399A2D500F88FE9 /* WebDeviceOrientationUpdateProviderProxyMessageReceiver.cpp in Sources */,
                                 2D92A789212B6AB100F493FD /* WebEvent.cpp in Sources */,
+                                93E799852756FA550074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp in Sources */,
                                 CD73BA4E131ACDB700EEDED2 /* WebFullScreenManagerMessageReceiver.cpp in Sources */,
                                 CD73BA47131ACC9A00EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp in Sources */,

trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp

@@ -38 +38 @@
 #include "WebCookieJar.h"
 #include "WebCoreArgumentCoders.h"
+#include "WebFileSystemStorageConnection.h"
+#include "WebFileSystemStorageConnectionMessages.h"
 #include "WebFrame.h"
 #include "WebIDBConnectionToServer.h"
@@ -120 +122 @@
         return;
     }
+    if (decoder.messageReceiverName() == Messages::WebFileSystemStorageConnection::messageReceiverName()) {
+        WebProcess::singleton().fileSystemStorageConnection().didReceiveMessage(connection, decoder);
+        return;
+    }
 
 #if USE(LIBWEBRTC)

trunk/Tools/ChangeLog

@@ +1 @@
+2021-12-03  Sihui Liu  <sihui_liu@apple.com>
+
+        Fetch and remove file system data via WKWebsiteDataStore
+        https://bugs.webkit.org/show_bug.cgi?id=233567
+
+        Reviewed by Youenn Fablet.
+
+        * TestWebKitAPI/Tests/WebKitCocoa/FileSystemAccess.mm:
+
 2021-12-03  Chris Dumez  <cdumez@apple.com>
 

trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/FileSystemAccess.mm

@@ -30 +30 @@
 #import "DeprecatedGlobalValues.h"
 #import "PlatformUtilities.h"
+#import "TestUIDelegate.h"
 #import "TestURLSchemeHandler.h"
 #import "TestWKWebView.h"
@@ -35 +36 @@
 #import <WebKit/WKWebViewConfigurationPrivate.h>
 #import <WebKit/WKWebViewPrivate.h>
+#import <WebKit/WKWebsiteDataRecordPrivate.h>
 
 @interface FileSystemAccessMessageHandler : NSObject <WKScriptMessageHandler>
@@ -49 +51 @@
 @end
 
-static NSString *mainFrameString = @"<script> \
+static NSString *workerFrameString = @"<script> \
     function start() { \
         var worker = new Worker('worker.js'); \
@@ -116 +118 @@
 
     auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
-    [webView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
+    [webView loadHTMLString:workerFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
     TestWebKitAPI::Util::run(&receivedScriptMessage);
     receivedScriptMessage = false;
@@ -127 +129 @@
 
     auto secondWebView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
-    [secondWebView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
+    [secondWebView loadHTMLString:workerFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
     TestWebKitAPI::Util::run(&receivedScriptMessage);
     receivedScriptMessage = false;
@@ -169 +171 @@
 
     auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
-    [webView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
+    [webView loadHTMLString:workerFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
     TestWebKitAPI::Util::run(&receivedScriptMessage);
     receivedScriptMessage = false;
@@ -259 +261 @@
 }
 
+static NSString *testString = @"<script> \
+    async function open(shouldCreateFile) \
+    { \
+        try { \
+            var rootHandle = await navigator.storage.getDirectory(); \
+            var fileHandle = await rootHandle.getFileHandle('file-system-access.txt', { 'create' : shouldCreateFile }); \
+            window.webkit.messageHandlers.testHandler.postMessage('file is opened'); \
+        } catch(err) { \
+            window.webkit.messageHandlers.testHandler.postMessage('error: ' + err.name + ' - ' + err.message); \
+        } \
+    } \
+    open(true); \
+    </script>";
+
+TEST(FileSystemAccess, FetchAndRemoveData)
+{
+    auto handler = adoptNS([[FileSystemAccessMessageHandler alloc] init]);
+    auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
+    [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
+    auto websiteDataStore = [configuration websiteDataStore];
+    auto types = [NSSet setWithObject:_WKWebsiteDataTypeFileSystem];
+
+    // Remove existing data.
+    done = false;
+    [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate distantPast] completionHandler:^ {
+        done = true;
+    }];
+    TestWebKitAPI::Util::run(&done);
+
+    auto preferences = [configuration preferences];
+    preferences._fileSystemAccessEnabled = YES;
+    preferences._storageAPIEnabled = YES;
+    auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
+    [webView loadHTMLString:testString baseURL:[NSURL URLWithString:@"https://webkit.org"]];
+    TestWebKitAPI::Util::run(&receivedScriptMessage);
+    receivedScriptMessage = false;
+    EXPECT_WK_STREQ(@"file is opened", [lastScriptMessage body]);
+
+    // Fetch data and remove it by origin.
+    done = false;
+    [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
+        EXPECT_EQ(records.count, 1u);
+        auto record = [records objectAtIndex:0];
+        EXPECT_STREQ("webkit.org", [record.displayName UTF8String]);
+
+        // Remove data.
+        [websiteDataStore removeDataOfTypes:types forDataRecords:records completionHandler:^{
+            done = true;
+        }];
+    }];
+    TestWebKitAPI::Util::run(&done);
+
+    // Fetch data after removal.
+    done = false;
+    [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
+        EXPECT_EQ(records.count, 0u);
+        done = true;
+    }];
+
+    // File cannot be opened after data removal.
+    [webView evaluateJavaScript:@"open(false)" completionHandler:nil];
+    TestWebKitAPI::Util::run(&receivedScriptMessage);
+    receivedScriptMessage = false;
+    EXPECT_WK_STREQ(@"error: NotFoundError - The object can not be found here.", [lastScriptMessage body]);
+}
+
+TEST(FileSystemAccess, RemoveDataByModificationTime)
+{
+    auto handler = adoptNS([[FileSystemAccessMessageHandler alloc] init]);
+    auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
+    [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
+    auto preferences = [configuration preferences];
+    preferences._fileSystemAccessEnabled = YES;
+    preferences._storageAPIEnabled = YES;
+    auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
+    [webView loadHTMLString:testString baseURL:[NSURL URLWithString:@"https://webkit.org"]];
+    TestWebKitAPI::Util::run(&receivedScriptMessage);
+    receivedScriptMessage = false;
+    EXPECT_WK_STREQ(@"file is opened", [lastScriptMessage body]);
+
+    auto websiteDataStore = [configuration websiteDataStore];
+    auto types = [NSSet setWithObject:_WKWebsiteDataTypeFileSystem];
+    done = false;
+    __block NSUInteger recordsCount;
+    [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
+        recordsCount = records.count;
+        EXPECT_GT(recordsCount, 0u);
+        done = true;
+    }];
+    TestWebKitAPI::Util::run(&done);
+
+    done = false;
+    [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate now] completionHandler:^ {
+        [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
+            recordsCount = records.count;
+            EXPECT_EQ(records.count, recordsCount);
+            done = true;
+        }];
+    }];
+    TestWebKitAPI::Util::run(&done);
+
+    done = false;
+    [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate distantPast] completionHandler:^ {
+        [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
+            EXPECT_EQ(records.count, 0u);
+            done = true;
+        }];
+    }];
+    TestWebKitAPI::Util::run(&done);
+}
+
+static NSString *mainFrameString = @"<script> \
+    function postResult(event) \
+    { \
+        window.webkit.messageHandlers.testHandler.postMessage(event.data); \
+    } \
+    addEventListener('message', postResult, false); \
+    </script> \
+    <iframe src='https://127.0.0.1:9091/'>";
+
+static const char* frameBytes = R"TESTRESOURCE(
+<script>
+function postMessage(message)
+{
+    parent.postMessage(message, '*');
+}
+async function open()
+{
+    try {
+        var rootHandle = await navigator.storage.getDirectory();
+        var fileHandle = await rootHandle.getFileHandle('file-system-access.txt', { 'create' : true });
+        postMessage('file is opened');
+    } catch(err) {
+        postMessage('error: ' + err.name + ' - ' + err.message);
+    }
+}
+open();
+</script>
+)TESTRESOURCE";
+
+TEST(FileSystemAccess, FetchDataForThirdParty)
+{
+    TestWebKitAPI::HTTPServer server({
+        { "/", { frameBytes } },
+    }, TestWebKitAPI::HTTPServer::Protocol::Https, nullptr, nullptr, 9091);
+
+    auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
+    auto handler = adoptNS([[FileSystemAccessMessageHandler alloc] init]);
+    [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
+    auto preferences = [configuration preferences];
+    preferences._fileSystemAccessEnabled = YES;
+    preferences._storageAPIEnabled = YES;
+
+    auto websiteDataStore = [configuration websiteDataStore];
+    auto types = [NSSet setWithObject:_WKWebsiteDataTypeFileSystem];
+    done = false;
+    [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate distantPast] completionHandler:^ {
+        done = true;
+    }];
+    TestWebKitAPI::Util::run(&done);
+
+    auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
+    auto navigationDelegate = adoptNS([TestNavigationDelegate new]);
+    [navigationDelegate setDidReceiveAuthenticationChallenge:^(WKWebView *, NSURLAuthenticationChallenge *challenge, void (^callback)(NSURLSessionAuthChallengeDisposition, NSURLCredential *)) {
+        EXPECT_WK_STREQ(challenge.protectionSpace.authenticationMethod, NSURLAuthenticationMethodServerTrust);
+        callback(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
+    }];
+    [navigationDelegate setDecidePolicyForNavigationAction:[&](WKNavigationAction *action, void (^decisionHandler)(WKNavigationActionPolicy)) {
+        decisionHandler(WKNavigationActionPolicyAllow);
+    }];
+    [webView setNavigationDelegate:navigationDelegate.get()];
+
+    [webView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"https://webkit.org"]];
+    TestWebKitAPI::Util::run(&receivedScriptMessage);
+    receivedScriptMessage = false;
+    EXPECT_WK_STREQ(@"file is opened", [lastScriptMessage body]);
+
+    done = false;
+    [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
+        // Should return both opening origin and top origin.
+        EXPECT_EQ(records.count, 2u);
+        auto sortFunction = ^(WKWebsiteDataRecord *record1, WKWebsiteDataRecord *record2){
+            return [record1.displayName compare:record2.displayName];
+        };
+        auto sortedRecords = [records sortedArrayUsingComparator:sortFunction];
+        EXPECT_WK_STREQ(@"127.0.0.1", [sortedRecords objectAtIndex:0].displayName);
+        EXPECT_WK_STREQ(@"webkit.org", [sortedRecords objectAtIndex:1].displayName);
+        done = true;
+    }];
+    TestWebKitAPI::Util::run(&done);
+}
+
 #endif // USE(APPLE_INTERNAL_SDK)