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

Changeset 286569 in webkit


Ignore:
Timestamp:
Dec 6, 2021, 2:17:05 PM (5 years ago)
Author:
Ryan Haddad
Message:

REGRESSION (r286507): [macOS] Many file system access layout tests became flaky failures
​https://bugs.webkit.org/show_bug.cgi?id=233892

Unreviewed, revert r286507.

Source/WebCore:

  • Modules/filesystemaccess/FileSystemStorageConnection.h:

Source/WebKit:

  • 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): Deleted.

  • NetworkProcess/storage/FileSystemStorageManager.cpp:

(WebKit::FileSystemStorageManager::~FileSystemStorageManager):
(WebKit::FileSystemStorageManager::close): Deleted.

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

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

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

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

  • 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: Removed.

Source/WTF:

  • wtf/FileSystem.cpp:

(WTF::FileSystemImpl::readEntireFile): Deleted.
(WTF::FileSystemImpl::deleteAllFilesModifiedSince): Deleted.

  • wtf/FileSystem.h:

Tools:

  • TestWebKitAPI/Tests/WebKitCocoa/FileSystemAccess.mm:
Location:
trunk
Files:
1 deleted
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r286565 r286569  
     12021-12-06  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        REGRESSION (r286507): [macOS] Many file system access layout tests became flaky failures
     4        https://bugs.webkit.org/show_bug.cgi?id=233892
     5
     6        Unreviewed, revert r286507.
     7
     8        * wtf/FileSystem.cpp:
     9        (WTF::FileSystemImpl::readEntireFile): Deleted.
     10        (WTF::FileSystemImpl::deleteAllFilesModifiedSince): Deleted.
     11        * wtf/FileSystem.h:
     12
    1132021-12-06  Simon Fraser  <simon.fraser@apple.com>
    214

  • trunk/Source/WTF/wtf/FileSystem.cpp

    r286507 r286569  
    515515}
    516516
    517 std::optional<Vector<uint8_t>> readEntireFile(PlatformFileHandle handle)
    518 {
    519     if (!FileSystem::isHandleValid(handle))
    520         return std::nullopt;
    521 
    522     auto size = FileSystem::fileSize(handle).value_or(0);
    523     if (!size)
    524         return std::nullopt;
    525 
    526     unsigned bytesToRead;
    527     if (!WTF::convertSafely(size, bytesToRead))
    528         return std::nullopt;
    529 
    530     Vector<uint8_t> buffer(bytesToRead);
    531     unsigned totalBytesRead = FileSystem::readFromFile(handle, buffer.data(), buffer.size());
    532     if (totalBytesRead != bytesToRead)
    533         return std::nullopt;
    534 
    535     return buffer;
    536 }
    537 
    538 void deleteAllFilesModifiedSince(const String& directory, WallTime time)
    539 {
    540     // This function may delete directory folder.
    541     if (time == -WallTime::infinity()) {
    542         deleteNonEmptyDirectory(directory);
    543         return;
    544     }
    545 
    546     auto children = listDirectory(directory);
    547     for (auto& child : children) {
    548         auto childPath = FileSystem::pathByAppendingComponent(directory, child);
    549         auto childType = fileType(childPath);
    550         if (!childType)
    551             continue;
    552 
    553         switch (*childType) {
    554         case FileType::Regular: {
    555             if (auto modificationTime = FileSystem::fileModificationTime(childPath); modificationTime && *modificationTime >= time)
    556                 deleteFile(childPath);
    557             break;
    558         }
    559         case FileType::Directory:
    560             deleteAllFilesModifiedSince(childPath, time);
    561             deleteEmptyDirectory(childPath);
    562             break;
    563         case FileType::SymbolicLink:
    564             break;
    565         }
    566     }
    567 
    568     FileSystem::deleteEmptyDirectory(directory);
    569 }
    570 
    571517#if HAVE(STD_FILESYSTEM) || HAVE(STD_EXPERIMENTAL_FILESYSTEM)
    572518

  • trunk/Source/WTF/wtf/FileSystem.h

    r286507 r286569  
    109109WTF_EXPORT_PRIVATE bool fileExists(const String&);
    110110WTF_EXPORT_PRIVATE bool deleteFile(const String&);
    111 WTF_EXPORT_PRIVATE void deleteAllFilesModifiedSince(const String&, WallTime);
    112111WTF_EXPORT_PRIVATE bool deleteEmptyDirectory(const String&);
    113112WTF_EXPORT_PRIVATE bool moveFile(const String& oldPath, const String& newPath);
    … …  
    148147using Salt = std::array<uint8_t, 8>;
    149148WTF_EXPORT_PRIVATE std::optional<Salt> readOrMakeSalt(const String& path);
    150 WTF_EXPORT_PRIVATE std::optional<Vector<uint8_t>> readEntireFile(PlatformFileHandle);
    151149
    152150// Prefix is what the filename should be prefixed with, not the full path.

  • trunk/Source/WebCore/ChangeLog

    r286568 r286569  
     12021-12-06  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        REGRESSION (r286507): [macOS] Many file system access layout tests became flaky failures
     4        https://bugs.webkit.org/show_bug.cgi?id=233892
     5
     6        Unreviewed, revert r286507.
     7
     8        * Modules/filesystemaccess/FileSystemStorageConnection.h:
     9
    1102021-12-06  Sam Weinig  <weinig@apple.com>
    211

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

    r286507 r286569  
    2828#include "FileSystemHandleIdentifier.h"
    2929#include "FileSystemSyncAccessHandleIdentifier.h"
    30 #include "ProcessQualified.h"
    3130#include "ScriptExecutionContextIdentifier.h"
    3231#include <wtf/CompletionHandler.h>

  • trunk/Source/WebKit/CMakeLists.txt

    r286507 r286569  
    311311    WebProcess/WebCoreSupport/RemoteWebLockRegistry
    312312    WebProcess/WebCoreSupport/WebBroadcastChannelRegistry
    313     WebProcess/WebCoreSupport/WebFileSystemStorageConnection
    314313    WebProcess/WebCoreSupport/WebSpeechRecognitionConnection
    315314

  • trunk/Source/WebKit/ChangeLog

    r286567 r286569  
     12021-12-06  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        REGRESSION (r286507): [macOS] Many file system access layout tests became flaky failures
     4        https://bugs.webkit.org/show_bug.cgi?id=233892
     5
     6        Unreviewed, revert r286507.
     7
     8        * CMakeLists.txt:
     9        * DerivedSources-input.xcfilelist:
     10        * DerivedSources-output.xcfilelist:
     11        * DerivedSources.make:
     12        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp:
     13        (WebKit::WebResourceLoadStatisticsStore::monitoredDataTypes):
     14        * NetworkProcess/NetworkProcess.cpp:
     15        (WebKit::NetworkProcess::fetchWebsiteData):
     16        (WebKit::NetworkProcess::deleteWebsiteData):
     17        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
     18        (WebKit::NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains):
     19        (WebKit::NetworkProcess::registrableDomainsWithWebsiteData):
     20        * NetworkProcess/storage/FileSystemStorageHandle.h:
     21        (WebKit::FileSystemStorageHandle::activeSyncAccessHandle const): Deleted.
     22        * NetworkProcess/storage/FileSystemStorageManager.cpp:
     23        (WebKit::FileSystemStorageManager::~FileSystemStorageManager):
     24        (WebKit::FileSystemStorageManager::close): Deleted.
     25        * NetworkProcess/storage/FileSystemStorageManager.h:
     26        * NetworkProcess/storage/NetworkStorageManager.cpp:
     27        (WebKit::originPath):
     28        (WebKit::NetworkStorageManager::localOriginStorageManager):
     29        (WebKit::readOriginFromFile): Deleted.
     30        (WebKit::writeOriginToFileIfNecessary): Deleted.
     31        (WebKit::deleteOriginFileIfNecessary): Deleted.
     32        (WebKit::originDirectoryPath): Deleted.
     33        (WebKit::originFilePath): Deleted.
     34        (WebKit::NetworkStorageManager::removeOriginStorageManagerIfPossible): Deleted.
     35        (WebKit::toWebsiteDataType): Deleted.
     36        (WebKit::NetworkStorageManager::forEachOriginDirectory): Deleted.
     37        (WebKit::NetworkStorageManager::fetchDataFromDisk): Deleted.
     38        (WebKit::NetworkStorageManager::fetchData): Deleted.
     39        (WebKit::NetworkStorageManager::deleteDataOnDisk): Deleted.
     40        (WebKit::NetworkStorageManager::deleteData): Deleted.
     41        (WebKit::NetworkStorageManager::deleteDataModifiedSince): Deleted.
     42        (WebKit::NetworkStorageManager::deleteDataForRegistrableDomains): Deleted.
     43        * NetworkProcess/storage/NetworkStorageManager.h:
     44        * NetworkProcess/storage/OriginStorageManager.cpp:
     45        (WebKit::OriginStorageManager::StorageBucket::typeStoragePath const):
     46        (WebKit::OriginStorageManager::StorageBucket::fileSystemStorageManager):
     47        (WebKit::OriginStorageManager::OriginStorageManager):
     48        (WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier): Deleted.
     49        (WebKit::OriginStorageManager::StorageBucket::isActive): Deleted.
     50        (WebKit::OriginStorageManager::StorageBucket::deleteData): Deleted.
     51        (WebKit::OriginStorageManager::StorageBucket::deleteFileSystemStorageData): Deleted.
     52        (WebKit::OriginStorageManager::isActive): Deleted.
     53        (WebKit::OriginStorageManager::deleteData): Deleted.
     54        * NetworkProcess/storage/OriginStorageManager.h:
     55        * Shared/WebsiteData/WebsiteData.cpp:
     56        (WebKit::WebsiteData::ownerProcess):
     57        * Shared/WebsiteData/WebsiteDataType.h:
     58        * UIProcess/API/Cocoa/WKWebsiteDataRecord.mm:
     59        (dataTypesToString):
     60        * UIProcess/API/Cocoa/WKWebsiteDataRecordInternal.h:
     61        (WebKit::toWebsiteDataType):
     62        (WebKit::toWKWebsiteDataTypes):
     63        * UIProcess/API/Cocoa/WKWebsiteDataRecordPrivate.h:
     64        * UIProcess/API/Cocoa/WKWebsiteDataStore.mm:
     65        (+[WKWebsiteDataStore _allWebsiteDataTypesIncludingPrivate]):
     66        * WebKit.xcodeproj/project.pbxproj:
     67        * WebProcess/Network/NetworkProcessConnection.cpp:
     68        (WebKit::NetworkProcessConnection::didReceiveMessage):
     69        * WebProcess/WebCoreSupport/WebFileSystemStorageConnection.messages.in: Removed.
     70
    1712021-12-06  Mark Lam  <mark.lam@apple.com>
    272

  • trunk/Source/WebKit/DerivedSources-input.xcfilelist

    r286507 r286569  
    222222$(PROJECT_DIR)/WebProcess/WebCoreSupport/WebBroadcastChannelRegistry.messages.in
    223223$(PROJECT_DIR)/WebProcess/WebCoreSupport/WebDeviceOrientationUpdateProvider.messages.in
    224 $(PROJECT_DIR)/WebProcess/WebCoreSupport/WebFileSystemStorageConnection.messages.in
    225224$(PROJECT_DIR)/WebProcess/WebCoreSupport/WebSpeechRecognitionConnection.messages.in
    226225$(PROJECT_DIR)/WebProcess/WebPage/Cocoa/TextCheckingControllerProxy.messages.in

  • trunk/Source/WebKit/DerivedSources-output.xcfilelist

    r286535 r286569  
    11# This file is generated by the generate-xcfilelists script.
     2<<<<<<< HEAD
    23$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/AudioCaptureSampleManagerMessageReceiver.cpp
    34$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/AudioCaptureSampleManagerMessagesReplies.h
    … …  
    494495$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebDeviceOrientationUpdateProviderProxyMessages.h
    495496$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebDeviceOrientationUpdateProviderProxyMessagesReplies.h
    496 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebFileSystemStorageConnectionMessageReceiver.cpp
    497 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebFileSystemStorageConnectionMessages.h
    498 $(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebFileSystemStorageConnectionMessagesReplies.h
    499497$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebFullScreenManagerMessageReceiver.cpp
    500498$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebFullScreenManagerMessages.h

  • trunk/Source/WebKit/DerivedSources.make

    r286507 r286569  
    223223        WebProcess/WebCoreSupport/WebBroadcastChannelRegistry \
    224224        WebProcess/WebCoreSupport/WebDeviceOrientationUpdateProvider \
    225         WebProcess/WebCoreSupport/WebFileSystemStorageConnection \
    226225        WebProcess/WebCoreSupport/WebSpeechRecognitionConnection \
    227226        WebProcess/Speech/SpeechRecognitionRealtimeMediaSourceManager \

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

    r286507 r286569  
    7575        WebsiteDataType::ServiceWorkerRegistrations,
    7676#endif
    77         WebsiteDataType::FileSystem,
    7877    }));
    7978

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

    r286507 r286569  
    15561556    }
    15571557#endif
    1558 
    1559     if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end()) {
    1560         iterator->value->fetchData(websiteDataTypes, [callbackAggregator](auto entries) mutable {
    1561             callbackAggregator->m_websiteData.entries.appendVector(WTFMove(entries));
    1562         });
    1563     }
    15641558}
    15651559
    … …  
    16361630    }
    16371631#endif
    1638 
    1639     if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end())
    1640         iterator->value->deleteDataModifiedSince(websiteDataTypes, modifiedSince, [clearTasksHandler] { });
    16411632}
    16421633
    … …  
    17451736    }
    17461737#endif
    1747 
    1748     if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end())
    1749         iterator->value->deleteData(websiteDataTypes, originDatas, [clearTasksHandler] { });
    17501738
    17511739    if (auto* networkSession = this->networkSession(sessionID)) {
    … …  
    19721960    }
    19731961
    1974     if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end()) {
    1975         iterator->value->deleteDataForRegistrableDomains(websiteDataTypes, domainsToDeleteAllNonCookieWebsiteDataFor, [callbackAggregator](auto deletedDomains) mutable {
    1976             for (auto domain : deletedDomains)
    1977                 callbackAggregator->m_domains.add(WTFMove(domain));
    1978         });
    1979     }
    1980 
    19811962    auto dataTypesForUIProcess = WebsiteData::filter(websiteDataTypes, WebsiteDataProcessType::UI);
    19821963    if (!dataTypesForUIProcess.isEmpty() && !domainsToDeleteAllNonCookieWebsiteDataFor.isEmpty()) {
    … …  
    20932074                callbackAggregator->m_websiteData.entries.appendVector(entries);
    20942075            });
    2095         });
    2096     }
    2097 
    2098     if (auto iterator = m_storageManagers.find(sessionID); iterator != m_storageManagers.end()) {
    2099         iterator->value->fetchData(websiteDataTypes, [callbackAggregator](auto entries) mutable {
    2100             callbackAggregator->m_websiteData.entries.appendVector(WTFMove(entries));
    21012076        });
    21022077    }

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

    r286507 r286569  
    6363    Expected<AccessHandleInfo, FileSystemStorageError> createSyncAccessHandle();
    6464    std::optional<FileSystemStorageError> close(WebCore::FileSystemSyncAccessHandleIdentifier);
    65     std::optional<WebCore::FileSystemSyncAccessHandleIdentifier> activeSyncAccessHandle() const { return m_activeSyncAccessHandle; }
    6665
    6766private:

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

    r286507 r286569  
    2929#include "FileSystemStorageError.h"
    3030#include "FileSystemStorageHandleRegistry.h"
    31 #include "WebFileSystemStorageConnectionMessages.h"
    3231
    3332namespace WebKit {
    … …  
    4443    ASSERT(!RunLoop::isMain());
    4544
    46     close();
     45    for (auto identifier : m_handles.keys())
     46        m_registry.unregisterHandle(identifier);
    4747}
    4848
    … …  
    150150}
    151151
    152 void FileSystemStorageManager::close()
    153 {
    154     ASSERT(!RunLoop::isMain());
    155 
    156     for (auto& [connectionID, identifiers] : m_handlesByConnection) {
    157         for (auto identifier : identifiers) {
    158             auto takenHandle = m_handles.take(identifier);
    159             m_registry.unregisterHandle(identifier);
    160 
    161             // Send message to web process to invalidate active sync access handle.
    162             if (auto accessHandleIdentifier = takenHandle->activeSyncAccessHandle())
    163                 IPC::Connection::send(connectionID, Messages::WebFileSystemStorageConnection::InvalidateAccessHandle(*accessHandleIdentifier), 0);
    164         }
    165     }
    166 
    167     ASSERT(m_handles.isEmpty());
    168     m_handlesByConnection.clear();
    169     m_lockMap.clear();
    170 }
    171 
    172152} // namespace WebKit

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

    r286507 r286569  
    5050
    5151private:
    52     void close();
    53 
    5452    String m_path;
    5553    FileSystemStorageHandleRegistry& m_registry;

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

    r286513 r286569  
    3232#include "NetworkStorageManagerMessages.h"
    3333#include "OriginStorageManager.h"
    34 #include "WebsiteDataType.h"
    3534#include <pal/crypto/CryptoDigest.h>
    36 #include <wtf/Scope.h>
    37 #include <wtf/persistence/PersistentDecoder.h>
    38 #include <wtf/persistence/PersistentEncoder.h>
    3935#include <wtf/text/Base64.h>
    4036
    4137namespace WebKit {
    42 
    43 static std::optional<WebCore::ClientOrigin> readOriginFromFile(const String& filePath)
    44 {
    45     ASSERT(!RunLoop::isMain());
    46 
    47     if (!FileSystem::fileExists(filePath))
    48         return std::nullopt;
    49 
    50     auto originFileHandle = FileSystem::openFile(filePath, FileSystem::FileOpenMode::Read);
    51     auto closeFile = makeScopeExit([&] {
    52         FileSystem::closeFile(originFileHandle);
    53     });
    54 
    55     if (!FileSystem::isHandleValid(originFileHandle))
    56         return std::nullopt;
    57 
    58     auto originContent = FileSystem::readEntireFile(originFileHandle);
    59     if (!originContent)
    60         return std::nullopt;
    61 
    62     WTF::Persistence::Decoder decoder({ originContent->data(), originContent->size() });
    63     std::optional<WebCore::ClientOrigin> origin;
    64     decoder >> origin;
    65     return origin;
    66 }
    67 
    68 static void writeOriginToFileIfNecessary(const String& filePath, const WebCore::ClientOrigin& origin)
    69 {
    70     if (FileSystem::fileExists(filePath))
    71         return;
    72 
    73     FileSystem::makeAllDirectories(FileSystem::parentPath(filePath));
    74     auto originFileHandle = FileSystem::openFile(filePath, FileSystem::FileOpenMode::ReadWrite);
    75     auto closeFile = makeScopeExit([&] {
    76         FileSystem::closeFile(originFileHandle);
    77     });
    78 
    79     if (!FileSystem::isHandleValid(originFileHandle)) {
    80         LOG_ERROR("writeOriginToFileIfNecessary: Failed to open origin file");
    81         return;
    82     }
    83 
    84     WTF::Persistence::Encoder encoder;
    85     encoder << origin;
    86     FileSystem::writeToFile(originFileHandle, encoder.buffer(), encoder.bufferSize());
    87 }
    88 
    89 static void deleteOriginFileIfNecessary(const String& filePath)
    90 {
    91     auto parentPath = FileSystem::parentPath(filePath);
    92     auto children = FileSystem::listDirectory(parentPath);
    93     if (children.size() == 1)
    94         FileSystem::deleteFile(filePath);
    95 }
    9638
    9739Ref<NetworkStorageManager> NetworkStorageManager::create(PAL::SessionID sessionID, const String& path)
    … …  
    176118}
    177119
    178 static String originDirectoryPath(const String& rootPath, const WebCore::ClientOrigin& origin, FileSystem::Salt salt)
     120static String originPath(const String& rootPath, const WebCore::ClientOrigin& origin, FileSystem::Salt salt)
    179121{
    180122    if (rootPath.isEmpty())
    … …  
    186128}
    187129
    188 static String originFilePath(const String& directory)
    189 {
    190     return FileSystem::pathByAppendingComponent(directory, "origin"_s);
    191 }
    192 
    193130OriginStorageManager& NetworkStorageManager::localOriginStorageManager(const WebCore::ClientOrigin& origin)
    194131{
    … …  
    196133
    197134    return *m_localOriginStorageManagers.ensure(origin, [&] {
    198         auto originDirectory = originDirectoryPath(m_path, origin, m_salt);
    199         writeOriginToFileIfNecessary(originFilePath(originDirectory), origin);
    200         return makeUnique<OriginStorageManager>(WTFMove(originDirectory));
     135        return makeUnique<OriginStorageManager>(originPath(m_path, origin, m_salt));
    201136    }).iterator->value;
    202 }
    203 
    204 void NetworkStorageManager::removeOriginStorageManagerIfPossible(const WebCore::ClientOrigin& origin)
    205 {
    206     if (auto iterator = m_localOriginStorageManagers.find(origin); iterator != m_localOriginStorageManagers.end()) {
    207         if (!iterator->value->isActive())
    208             m_localOriginStorageManagers.remove(iterator);
    209     }
    210137}
    211138
    … …  
    380307}
    381308
    382 static std::optional<WebsiteDataType> toWebsiteDataType(const String& storageType)
    383 {
    384     if (storageType == "FileSystem")
    385         return WebsiteDataType::FileSystem;
    386 
    387     return std::nullopt;
    388 }
    389 
    390 void NetworkStorageManager::forEachOriginDirectory(const Function<void(const String&)>& apply)
    391 {
    392     for (auto& topOrigin : FileSystem::listDirectory(m_path)) {
    393         auto topOriginDirectory = FileSystem::pathByAppendingComponent(m_path, topOrigin);
    394         auto openingOrigins = FileSystem::listDirectory(topOriginDirectory);
    395         if (openingOrigins.isEmpty()) {
    396             FileSystem::deleteEmptyDirectory(topOriginDirectory);
    397             continue;
    398         }
    399 
    400         for (auto& openingOrigin : openingOrigins) {
    401             auto openingOriginDirectory = FileSystem::pathByAppendingComponent(topOriginDirectory, openingOrigin);
    402             apply(openingOriginDirectory);
    403         }
    404     }
    405 }
    406 
    407 Vector<WebsiteData::Entry> NetworkStorageManager::fetchDataFromDisk(OptionSet<WebsiteDataType> targetTypes)
    408 {
    409     ASSERT(!RunLoop::isMain());
    410 
    411     HashMap<WebCore::SecurityOriginData, OptionSet<WebsiteDataType>> originTypes;
    412     forEachOriginDirectory([&](auto directory) mutable {
    413         auto origin = readOriginFromFile(originFilePath(directory));
    414         if (!origin)
    415             return;
    416 
    417         for (auto& storageType : FileSystem::listDirectory(directory)) {
    418             if (auto type = toWebsiteDataType(storageType); type && targetTypes.contains(*type)) {
    419                 // Return both top origin and opening origin for this data.
    420                 originTypes.add(origin->clientOrigin, OptionSet<WebsiteDataType> { }).iterator->value.add(*type);
    421                 originTypes.add(origin->topOrigin, OptionSet<WebsiteDataType> { }).iterator->value.add(*type);
    422             }
    423         }
    424     });
    425 
    426     Vector<WebsiteData::Entry> entries;
    427     for (auto [origin, types] : originTypes) {
    428         for (auto type : types)
    429             entries.append({ WebsiteData::Entry { origin, type, 0 } });
    430     }
    431 
    432     return entries;
    433 }
    434 
    435 void NetworkStorageManager::fetchData(OptionSet<WebsiteDataType> types, CompletionHandler<void(Vector<WebsiteData::Entry>&&)>&& completionHandler)
    436 {
    437     ASSERT(RunLoop::isMain());
    438     ASSERT(!m_closed);
    439 
    440     m_queue->dispatch([this, protectedThis = Ref { *this }, types, completionHandler = WTFMove(completionHandler)]() mutable {
    441         auto entries = fetchDataFromDisk(types);
    442         RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler), entries = crossThreadCopy(WTFMove(entries))]() mutable {
    443             completionHandler(WTFMove(entries));
    444         });
    445     });
    446 }
    447 
    448 Vector<WebCore::ClientOrigin> NetworkStorageManager::deleteDataOnDisk(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime, const Function<bool(const WebCore::ClientOrigin&)>& filter)
    449 {
    450     ASSERT(!RunLoop::isMain());
    451 
    452     Vector<WebCore::ClientOrigin> deletedOrigins;
    453     forEachOriginDirectory([&](auto directory) mutable {
    454         auto filePath = originFilePath(directory);
    455         auto origin = readOriginFromFile(filePath);
    456         if (!origin) {
    457             // If origin cannot be retrieved, but we are asked to remove data for all origins, remove it.
    458             RELEASE_LOG_ERROR(Storage, "NetworkStorageManager::deleteDataOnDisk failed to read origin from '%s'", filePath.utf8().data());
    459             if (filter(WebCore::ClientOrigin { })) {
    460                 FileSystem::deleteAllFilesModifiedSince(directory, modifiedSinceTime);
    461                 FileSystem::deleteEmptyDirectory(directory);
    462             }
    463             return;
    464         }
    465 
    466         if (!filter(*origin))
    467             return;
    468 
    469         deletedOrigins.append(*origin);
    470         localOriginStorageManager(*origin).deleteData(types, modifiedSinceTime);
    471         removeOriginStorageManagerIfPossible(*origin);
    472         deleteOriginFileIfNecessary(filePath);
    473         FileSystem::deleteEmptyDirectory(directory);
    474     });
    475 
    476     return deletedOrigins;
    477 }
    478 
    479 void NetworkStorageManager::deleteData(OptionSet<WebsiteDataType> types, const Vector<WebCore::SecurityOriginData>& origins, CompletionHandler<void()>&& completionHandler)
    480 {
    481     ASSERT(RunLoop::isMain());
    482     ASSERT(!m_closed);
    483 
    484     m_queue->dispatch([this, protectedThis = Ref { *this }, types, origins = crossThreadCopy(origins), completionHandler = WTFMove(completionHandler)]() mutable {
    485         HashSet<WebCore::SecurityOriginData> originSet;
    486         originSet.reserveInitialCapacity(origins.size());
    487         for (auto origin : origins)
    488             originSet.add(WTFMove(origin));
    489 
    490         deleteDataOnDisk(types, -WallTime::infinity(), [&originSet](auto origin) {
    491             return originSet.contains(origin.topOrigin) || originSet.contains(origin.clientOrigin);
    492         });
    493 
    494         RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)]() mutable {
    495             completionHandler();
    496         });
    497     });
    498 }
    499 
    500 void NetworkStorageManager::deleteDataModifiedSince(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime, CompletionHandler<void()>&& completionHandler)
    501 {
    502     ASSERT(RunLoop::isMain());
    503     ASSERT(!m_closed);
    504 
    505     m_queue->dispatch([this, protectedThis = Ref { *this }, types, modifiedSinceTime, completionHandler = WTFMove(completionHandler)]() mutable {
    506         deleteDataOnDisk(types, modifiedSinceTime, [](auto&) {
    507             return true;
    508         });
    509 
    510         RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler)]() mutable {
    511             completionHandler();
    512         });
    513     });
    514 }
    515 
    516 void NetworkStorageManager::deleteDataForRegistrableDomains(OptionSet<WebsiteDataType> types, const Vector<WebCore::RegistrableDomain>& domains, CompletionHandler<void(HashSet<WebCore::RegistrableDomain>&&)>&& completionHandler)
    517 {
    518     ASSERT(RunLoop::isMain());
    519     ASSERT(!m_closed);
    520 
    521     m_queue->dispatch([this, protectedThis = Ref { *this }, types, domains = crossThreadCopy(domains), completionHandler = WTFMove(completionHandler)]() mutable {
    522         auto deletedOrigins = deleteDataOnDisk(types, -WallTime::infinity(), [&domains](auto& origin) {
    523             auto domain = WebCore::RegistrableDomain::uncheckedCreateFromHost(origin.clientOrigin.host);
    524             return domains.contains(domain);
    525         });
    526 
    527         HashSet<WebCore::RegistrableDomain> deletedDomains;
    528         for (auto origin : deletedOrigins) {
    529             auto domain = WebCore::RegistrableDomain::uncheckedCreateFromHost(origin.clientOrigin.host);
    530             deletedDomains.add(domain);
    531         }
    532 
    533         RunLoop::main().dispatch([protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler), domains = crossThreadCopy(WTFMove(deletedDomains))]() mutable {
    534             completionHandler(WTFMove(domains));
    535         });
    536     });
    537 }
    538 
    539309} // namespace WebKit
    540310

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

    r286507 r286569  
    2929#include "FileSystemStorageError.h"
    3030#include "OriginStorageManager.h"
    31 #include "WebsiteData.h"
    3231#include <WebCore/ClientOrigin.h>
    3332#include <WebCore/FileSystemHandleIdentifier.h>
    3433#include <WebCore/FileSystemSyncAccessHandleIdentifier.h>
    3534#include <pal/SessionID.h>
    36 #include <wtf/Forward.h>
    3735
    3836namespace IPC {
    … …  
    5856    void close();
    5957    void clearStorageForTesting(CompletionHandler<void()>&&);
    60     void fetchData(OptionSet<WebsiteDataType>, CompletionHandler<void(Vector<WebsiteData::Entry>&&)>&&);
    61     void deleteData(OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, CompletionHandler<void()>&&);
    62     void deleteDataModifiedSince(OptionSet<WebsiteDataType>, WallTime, CompletionHandler<void()>&&);
    63     void deleteDataForRegistrableDomains(OptionSet<WebsiteDataType>, const Vector<WebCore::RegistrableDomain>&, CompletionHandler<void(HashSet<WebCore::RegistrableDomain>&&)>&&);
    6458
    6559private:
    … …  
    6761    ~NetworkStorageManager();
    6862    OriginStorageManager& localOriginStorageManager(const WebCore::ClientOrigin&);
    69     void removeOriginStorageManagerIfPossible(const WebCore::ClientOrigin&);
    7063    FileSystemStorageHandleRegistry& fileSystemStorageHandleRegistry();
    71 
    72     void forEachOriginDirectory(const Function<void(const String&)>&);
    73     Vector<WebsiteData::Entry> fetchDataFromDisk(OptionSet<WebsiteDataType>);
    74     Vector<WebCore::ClientOrigin> deleteDataOnDisk(OptionSet<WebsiteDataType>, WallTime, const Function<bool(const WebCore::ClientOrigin&)>&);
    7564
    7665    // IPC::MessageReceiver (implemented by generated code)

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

    r286507 r286569  
    5252    }
    5353
    54     enum class StorageType : uint8_t {
    55         FileSystem,
    56     };
    57 
    58     static String toStorageIdentifier(StorageType type)
     54    String typeStoragePath(const String& storageIdentifier) const
    5955    {
    60         switch (type) {
    61         case StorageType::FileSystem:
    62             return "FileSystem"_s;
    63         default:
    64             break;
    65         }
    66         ASSERT_NOT_REACHED();
    67         return ""_s;
    68     }
    69 
    70     String typeStoragePath(StorageType type) const
    71     {
    72         auto storageIdentifier = toStorageIdentifier(type);
    73         if (m_rootPath.isEmpty() || storageIdentifier.isEmpty())
    74             return emptyString();
    75 
    76         return FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
     56        return m_rootPath.isEmpty() ? emptyString() : FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
    7757    }
    7858
    … …  
    8060    {
    8161        if (!m_fileSystemStorageManager)
    82             m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath(StorageType::FileSystem), registry);
     62            m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath("FileSystem"), registry);
    8363
    8464        return *m_fileSystemStorageManager;
    8565    }
    8666
    87     bool isActive()
    88     {
    89         return !!m_fileSystemStorageManager;
    90     }
    91 
    92     void deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime)
    93     {
    94         if (types.contains(WebsiteDataType::FileSystem))
    95             deleteFileSystemStorageData(modifiedSinceTime);
    96 
    97         FileSystem::deleteNonEmptyDirectory(m_rootPath);
    98     }
    99 
    10067private:
    101     void deleteFileSystemStorageData(WallTime modifiedSinceTime)
    102     {
    103         m_fileSystemStorageManager = nullptr;
    104 
    105         auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
    106         FileSystem::deleteAllFilesModifiedSince(fileSystemStoragePath, modifiedSinceTime);
    107     }
    108 
    10968    String m_rootPath;
    11069    String m_identifier;
    … …  
    11675    : m_path(WTFMove(path))
    11776{
    118     ASSERT(!RunLoop::isMain());
    11977}
    12078
    … …  
    146104}
    147105
    148 bool OriginStorageManager::isActive()
    149 {
    150     return defaultBucket().isActive();
    151 }
    152 
    153 void OriginStorageManager::deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSince)
    154 {
    155     ASSERT(!RunLoop::isMain());
    156     defaultBucket().deleteData(types, modifiedSince);
    157 }
    158 
    159106} // namespace WebKit
    160107

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

    r286507 r286569  
    2929#include <wtf/text/WTFString.h>
    3030
    31 namespace WebCore {
    32 struct ClientOrigin;
    33 }
    34 
    3531namespace WebKit {
    3632
    3733class FileSystemStorageHandleRegistry;
    3834class FileSystemStorageManager;
    39 enum class WebsiteDataType : uint32_t;
    4035
    4136class OriginStorageManager {
    … …  
    4944    void persist();
    5045    FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry&);
    51     bool isActive();
    52     void deleteData(OptionSet<WebsiteDataType>, WallTime);
    5346
    5447private:
    … …  
    5649    class StorageBucket;
    5750    StorageBucket& defaultBucket();
    58 
    59     void createOriginFileIfNecessary(const WebCore::ClientOrigin&);
    60     void deleteOriginFileIfNecessary();
    6151
    6252    std::unique_ptr<StorageBucket> m_defaultBucket;

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

    r286507 r286569  
    130130        return WebsiteDataProcessType::Network;
    131131#endif
    132     case WebsiteDataType::FileSystem:
    133         return WebsiteDataProcessType::Network;
    134132    }
    135133

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

    r286507 r286569  
    5353    AlternativeServices = 1 << 18,
    5454#endif
    55     FileSystem = 1 << 19,
    5655};
    5756
    … …  
    8180        WebKit::WebsiteDataType::DOMCache,
    8281        WebKit::WebsiteDataType::DeviceIdHashSalt,
    83         WebKit::WebsiteDataType::PrivateClickMeasurements,
     82        WebKit::WebsiteDataType::PrivateClickMeasurements
    8483#if HAVE(CFNETWORK_ALTERNATIVE_SERVICE)
    85         WebKit::WebsiteDataType::AlternativeServices,
     84        , WebKit::WebsiteDataType::AlternativeServices
    8685#endif
    87         WebKit::WebsiteDataType::FileSystem
    8886    >;
    8987};

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

    r286507 r286569  
    5252NSString * const _WKWebsiteDataTypePrivateClickMeasurements = @"_WKWebsiteDataTypePrivateClickMeasurements";
    5353NSString * const _WKWebsiteDataTypeAlternativeServices = @"_WKWebsiteDataTypeAlternativeServices";
    54 NSString * const _WKWebsiteDataTypeFileSystem = @"_WKWebsiteDataTypeFileSystem";
    5554
    5655#if PLATFORM(MAC)
    … …  
    112111    if ([dataTypes containsObject:_WKWebsiteDataTypeAlternativeServices])
    113112        [array addObject:@"Alternative Services"];
    114     if ([dataTypes containsObject:_WKWebsiteDataTypeFileSystem])
    115         [array addObject:@"File System"];
    116113
    117114    return [array componentsJoinedByString:@", "];

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

    r286507 r286569  
    7878        return WebsiteDataType::AlternativeServices;
    7979#endif
    80     if ([websiteDataType isEqualToString:_WKWebsiteDataTypeFileSystem])
    81         return WebsiteDataType::FileSystem;
    8280    return std::nullopt;
    8381}
    … …  
    137135        [wkWebsiteDataTypes addObject:_WKWebsiteDataTypeAlternativeServices];
    138136#endif
    139     if (websiteDataTypes.contains(WebsiteDataType::FileSystem))
    140         [wkWebsiteDataTypes addObject:_WKWebsiteDataTypeFileSystem];
    141137
    142138    return wkWebsiteDataTypes;

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

    r286507 r286569  
    3838WK_EXTERN NSString * const _WKWebsiteDataTypePrivateClickMeasurements WK_API_AVAILABLE(macos(12.0), ios(15.0));
    3939WK_EXTERN NSString * const _WKWebsiteDataTypeAlternativeServices WK_API_AVAILABLE(macos(11.0), ios(14.0));
    40 WK_EXTERN NSString * const _WKWebsiteDataTypeFileSystem WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
    4140
    4241#if !TARGET_OS_IPHONE

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

    r286507 r286569  
    249249            _WKWebsiteDataTypeAdClickAttributions,
    250250            _WKWebsiteDataTypePrivateClickMeasurements,
    251             _WKWebsiteDataTypeAlternativeServices,
    252             _WKWebsiteDataTypeFileSystem
     251            _WKWebsiteDataTypeAlternativeServices
    253252#if !TARGET_OS_IPHONE
    254253            , _WKWebsiteDataTypePlugInData

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

    r286564 r286569  
    15051505                93D6B7B925534A170058DD3A /* WKSpeechRecognitionPermissionCallback.h in Headers */ = {isa = PBXBuildFile; fileRef = 93D6B7B725534A110058DD3A /* WKSpeechRecognitionPermissionCallback.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15061506                93E6A4EE1BC5DD3900F8A0E7 /* _WKHitTestResult.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E6A4ED1BC5DD3900F8A0E7 /* _WKHitTestResult.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1507                 93E799852756FA550074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93E799822756FA540074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp */; };
    1508                 93E799872756FAB40074008A /* WebFileSystemStorageConnectionMessagesReplies.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E799832756FA540074008A /* WebFileSystemStorageConnectionMessagesReplies.h */; };
    1509                 93E799882756FAC20074008A /* WebFileSystemStorageConnectionMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E799812756FA530074008A /* WebFileSystemStorageConnectionMessages.h */; };
    15101507                93F549B41E3174B7000E7239 /* WKSnapshotConfiguration.h in Headers */ = {isa = PBXBuildFile; fileRef = 93F549B31E3174B7000E7239 /* WKSnapshotConfiguration.h */; settings = {ATTRIBUTES = (Public, ); }; };
    15111508                950F2880252414EA00B74F1C /* WKMouseDeviceObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 950F287E252414E900B74F1C /* WKMouseDeviceObserver.h */; };
    … …  
    53265323                93D6B7B825534A120058DD3A /* WKSpeechRecognitionPermissionCallback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WKSpeechRecognitionPermissionCallback.cpp; sourceTree = "<group>"; };
    53275324                93E6A4ED1BC5DD3900F8A0E7 /* _WKHitTestResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKHitTestResult.h; sourceTree = "<group>"; };
    5328                 93E7997E2756F6700074008A /* WebFileSystemStorageConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebFileSystemStorageConnection.messages.in; sourceTree = "<group>"; };
    5329                 93E799812756FA530074008A /* WebFileSystemStorageConnectionMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFileSystemStorageConnectionMessages.h; sourceTree = "<group>"; };
    5330                 93E799822756FA540074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebFileSystemStorageConnectionMessageReceiver.cpp; sourceTree = "<group>"; };
    5331                 93E799832756FA540074008A /* WebFileSystemStorageConnectionMessagesReplies.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFileSystemStorageConnectionMessagesReplies.h; sourceTree = "<group>"; };
    53325325                93F549B31E3174B7000E7239 /* WKSnapshotConfiguration.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKSnapshotConfiguration.h; sourceTree = "<group>"; };
    53335326                93F549B51E3174DA000E7239 /* WKSnapshotConfiguration.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKSnapshotConfiguration.mm; sourceTree = "<group>"; };
    … …  
    1063510628                                9354242B2703BDCB005CA72C /* WebFileSystemStorageConnection.cpp */,
    1063610629                                9354242A2703BDCB005CA72C /* WebFileSystemStorageConnection.h */,
    10637                                 93E7997E2756F6700074008A /* WebFileSystemStorageConnection.messages.in */,
    1063810630                                BC111A58112F4FBB00337BAB /* WebFrameLoaderClient.cpp */,
    1063910631                                BC032D6A10F4378D0058C15A /* WebFrameLoaderClient.h */,
    … …  
    1211312105                                E3866B042399979C00F88FE9 /* WebDeviceOrientationUpdateProviderProxyMessageReceiver.cpp */,
    1211412106                                E3866B052399979C00F88FE9 /* WebDeviceOrientationUpdateProviderProxyMessages.h */,
    12115                                 93E799822756FA540074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp */,
    12116                                 93E799812756FA530074008A /* WebFileSystemStorageConnectionMessages.h */,
    12117                                 93E799832756FA540074008A /* WebFileSystemStorageConnectionMessagesReplies.h */,
    1211812107                                CD73BA48131ACD8E00EEDED2 /* WebFullScreenManagerMessageReceiver.cpp */,
    1211912108                                CD73BA49131ACD8E00EEDED2 /* WebFullScreenManagerMessages.h */,
    … …  
    1336213351                                BC111B5D112F629800337BAB /* WebEventFactory.h in Headers */,
    1336313352                                9354242C2703BDCB005CA72C /* WebFileSystemStorageConnection.h in Headers */,
    13364                                 93E799882756FAC20074008A /* WebFileSystemStorageConnectionMessages.h in Headers */,
    13365                                 93E799872756FAB40074008A /* WebFileSystemStorageConnectionMessagesReplies.h in Headers */,
    1336613353                                1A90C1EE1264FD50003E44D4 /* WebFindOptions.h in Headers */,
    1336713354                                BCE469541214E6CB000B98EB /* WebFormClient.h in Headers */,
    … …  
    1549215479                                E3866B092399A2D500F88FE9 /* WebDeviceOrientationUpdateProviderProxyMessageReceiver.cpp in Sources */,
    1549315480                                2D92A789212B6AB100F493FD /* WebEvent.cpp in Sources */,
    15494                                 93E799852756FA550074008A /* WebFileSystemStorageConnectionMessageReceiver.cpp in Sources */,
    1549515481                                CD73BA4E131ACDB700EEDED2 /* WebFullScreenManagerMessageReceiver.cpp in Sources */,
    1549615482                                CD73BA47131ACC9A00EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp in Sources */,

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

    r286507 r286569  
    3838#include "WebCookieJar.h"
    3939#include "WebCoreArgumentCoders.h"
    40 #include "WebFileSystemStorageConnection.h"
    41 #include "WebFileSystemStorageConnectionMessages.h"
    4240#include "WebFrame.h"
    4341#include "WebIDBConnectionToServer.h"
    … …  
    122120        return;
    123121    }
    124     if (decoder.messageReceiverName() == Messages::WebFileSystemStorageConnection::messageReceiverName()) {
    125         WebProcess::singleton().fileSystemStorageConnection().didReceiveMessage(connection, decoder);
    126         return;
    127     }
    128122
    129123#if USE(LIBWEBRTC)

  • trunk/Tools/ChangeLog

    r286554 r286569  
     12021-12-06  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        REGRESSION (r286507): [macOS] Many file system access layout tests became flaky failures
     4        https://bugs.webkit.org/show_bug.cgi?id=233892
     5
     6        Unreviewed, revert r286507.
     7
     8        * TestWebKitAPI/Tests/WebKitCocoa/FileSystemAccess.mm:
     9
    1102021-12-06  Jon Lee  <jonlee@apple.com>
    211

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

    r286507 r286569  
    3030#import "DeprecatedGlobalValues.h"
    3131#import "PlatformUtilities.h"
    32 #import "TestUIDelegate.h"
    3332#import "TestURLSchemeHandler.h"
    3433#import "TestWKWebView.h"
    … …  
    3635#import <WebKit/WKWebViewConfigurationPrivate.h>
    3736#import <WebKit/WKWebViewPrivate.h>
    38 #import <WebKit/WKWebsiteDataRecordPrivate.h>
    3937
    4038@interface FileSystemAccessMessageHandler : NSObject <WKScriptMessageHandler>
    … …  
    5149@end
    5250
    53 static NSString *workerFrameString = @"<script> \
     51static NSString *mainFrameString = @"<script> \
    5452    function start() { \
    5553        var worker = new Worker('worker.js'); \
    … …  
    118116
    119117    auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
    120     [webView loadHTMLString:workerFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
     118    [webView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
    121119    TestWebKitAPI::Util::run(&receivedScriptMessage);
    122120    receivedScriptMessage = false;
    … …  
    129127
    130128    auto secondWebView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
    131     [secondWebView loadHTMLString:workerFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
     129    [secondWebView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
    132130    TestWebKitAPI::Util::run(&receivedScriptMessage);
    133131    receivedScriptMessage = false;
    … …  
    171169
    172170    auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
    173     [webView loadHTMLString:workerFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
     171    [webView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"webkit://webkit.org"]];
    174172    TestWebKitAPI::Util::run(&receivedScriptMessage);
    175173    receivedScriptMessage = false;
    … …  
    261259}
    262260
    263 static NSString *testString = @"<script> \
    264     async function open(shouldCreateFile) \
    265     { \
    266         try { \
    267             var rootHandle = await navigator.storage.getDirectory(); \
    268             var fileHandle = await rootHandle.getFileHandle('file-system-access.txt', { 'create' : shouldCreateFile }); \
    269             window.webkit.messageHandlers.testHandler.postMessage('file is opened'); \
    270         } catch(err) { \
    271             window.webkit.messageHandlers.testHandler.postMessage('error: ' + err.name + ' - ' + err.message); \
    272         } \
    273     } \
    274     open(true); \
    275     </script>";
    276 
    277 TEST(FileSystemAccess, FetchAndRemoveData)
    278 {
    279     auto handler = adoptNS([[FileSystemAccessMessageHandler alloc] init]);
    280     auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
    281     [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
    282     auto websiteDataStore = [configuration websiteDataStore];
    283     auto types = [NSSet setWithObject:_WKWebsiteDataTypeFileSystem];
    284 
    285     // Remove existing data.
    286     done = false;
    287     [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate distantPast] completionHandler:^ {
    288         done = true;
    289     }];
    290     TestWebKitAPI::Util::run(&done);
    291 
    292     auto preferences = [configuration preferences];
    293     preferences._fileSystemAccessEnabled = YES;
    294     preferences._storageAPIEnabled = YES;
    295     auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
    296     [webView loadHTMLString:testString baseURL:[NSURL URLWithString:@"https://webkit.org"]];
    297     TestWebKitAPI::Util::run(&receivedScriptMessage);
    298     receivedScriptMessage = false;
    299     EXPECT_WK_STREQ(@"file is opened", [lastScriptMessage body]);
    300 
    301     // Fetch data and remove it by origin.
    302     done = false;
    303     [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
    304         EXPECT_EQ(records.count, 1u);
    305         auto record = [records objectAtIndex:0];
    306         EXPECT_STREQ("webkit.org", [record.displayName UTF8String]);
    307 
    308         // Remove data.
    309         [websiteDataStore removeDataOfTypes:types forDataRecords:records completionHandler:^{
    310             done = true;
    311         }];
    312     }];
    313     TestWebKitAPI::Util::run(&done);
    314 
    315     // Fetch data after removal.
    316     done = false;
    317     [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
    318         EXPECT_EQ(records.count, 0u);
    319         done = true;
    320     }];
    321 
    322     // File cannot be opened after data removal.
    323     [webView evaluateJavaScript:@"open(false)" completionHandler:nil];
    324     TestWebKitAPI::Util::run(&receivedScriptMessage);
    325     receivedScriptMessage = false;
    326     EXPECT_WK_STREQ(@"error: NotFoundError - The object can not be found here.", [lastScriptMessage body]);
    327 }
    328 
    329 TEST(FileSystemAccess, RemoveDataByModificationTime)
    330 {
    331     auto handler = adoptNS([[FileSystemAccessMessageHandler alloc] init]);
    332     auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
    333     [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
    334     auto preferences = [configuration preferences];
    335     preferences._fileSystemAccessEnabled = YES;
    336     preferences._storageAPIEnabled = YES;
    337     auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
    338     [webView loadHTMLString:testString baseURL:[NSURL URLWithString:@"https://webkit.org"]];
    339     TestWebKitAPI::Util::run(&receivedScriptMessage);
    340     receivedScriptMessage = false;
    341     EXPECT_WK_STREQ(@"file is opened", [lastScriptMessage body]);
    342 
    343     auto websiteDataStore = [configuration websiteDataStore];
    344     auto types = [NSSet setWithObject:_WKWebsiteDataTypeFileSystem];
    345     done = false;
    346     __block NSUInteger recordsCount;
    347     [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
    348         recordsCount = records.count;
    349         EXPECT_GT(recordsCount, 0u);
    350         done = true;
    351     }];
    352     TestWebKitAPI::Util::run(&done);
    353 
    354     done = false;
    355     [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate now] completionHandler:^ {
    356         [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
    357             recordsCount = records.count;
    358             EXPECT_EQ(records.count, recordsCount);
    359             done = true;
    360         }];
    361     }];
    362     TestWebKitAPI::Util::run(&done);
    363 
    364     done = false;
    365     [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate distantPast] completionHandler:^ {
    366         [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
    367             EXPECT_EQ(records.count, 0u);
    368             done = true;
    369         }];
    370     }];
    371     TestWebKitAPI::Util::run(&done);
    372 }
    373 
    374 static NSString *mainFrameString = @"<script> \
    375     function postResult(event) \
    376     { \
    377         window.webkit.messageHandlers.testHandler.postMessage(event.data); \
    378     } \
    379     addEventListener('message', postResult, false); \
    380     </script> \
    381     <iframe src='https://127.0.0.1:9091/'>";
    382 
    383 static const char* frameBytes = R"TESTRESOURCE(
    384 <script>
    385 function postMessage(message)
    386 {
    387     parent.postMessage(message, '*');
    388 }
    389 async function open()
    390 {
    391     try {
    392         var rootHandle = await navigator.storage.getDirectory();
    393         var fileHandle = await rootHandle.getFileHandle('file-system-access.txt', { 'create' : true });
    394         postMessage('file is opened');
    395     } catch(err) {
    396         postMessage('error: ' + err.name + ' - ' + err.message);
    397     }
    398 }
    399 open();
    400 </script>
    401 )TESTRESOURCE";
    402 
    403 TEST(FileSystemAccess, FetchDataForThirdParty)
    404 {
    405     TestWebKitAPI::HTTPServer server({
    406         { "/", { frameBytes } },
    407     }, TestWebKitAPI::HTTPServer::Protocol::Https, nullptr, nullptr, 9091);
    408 
    409     auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
    410     auto handler = adoptNS([[FileSystemAccessMessageHandler alloc] init]);
    411     [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
    412     auto preferences = [configuration preferences];
    413     preferences._fileSystemAccessEnabled = YES;
    414     preferences._storageAPIEnabled = YES;
    415 
    416     auto websiteDataStore = [configuration websiteDataStore];
    417     auto types = [NSSet setWithObject:_WKWebsiteDataTypeFileSystem];
    418     done = false;
    419     [websiteDataStore removeDataOfTypes:types modifiedSince:[NSDate distantPast] completionHandler:^ {
    420         done = true;
    421     }];
    422     TestWebKitAPI::Util::run(&done);
    423 
    424     auto webView = adoptNS([[WKWebView alloc] initWithFrame:CGRectMake(0, 0, 800, 600) configuration:configuration.get()]);
    425     auto navigationDelegate = adoptNS([TestNavigationDelegate new]);
    426     [navigationDelegate setDidReceiveAuthenticationChallenge:^(WKWebView *, NSURLAuthenticationChallenge *challenge, void (^callback)(NSURLSessionAuthChallengeDisposition, NSURLCredential *)) {
    427         EXPECT_WK_STREQ(challenge.protectionSpace.authenticationMethod, NSURLAuthenticationMethodServerTrust);
    428         callback(NSURLSessionAuthChallengeUseCredential, [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust]);
    429     }];
    430     [navigationDelegate setDecidePolicyForNavigationAction:[&](WKNavigationAction *action, void (^decisionHandler)(WKNavigationActionPolicy)) {
    431         decisionHandler(WKNavigationActionPolicyAllow);
    432     }];
    433     [webView setNavigationDelegate:navigationDelegate.get()];
    434 
    435     [webView loadHTMLString:mainFrameString baseURL:[NSURL URLWithString:@"https://webkit.org"]];
    436     TestWebKitAPI::Util::run(&receivedScriptMessage);
    437     receivedScriptMessage = false;
    438     EXPECT_WK_STREQ(@"file is opened", [lastScriptMessage body]);
    439 
    440     done = false;
    441     [websiteDataStore fetchDataRecordsOfTypes:types completionHandler:^(NSArray<WKWebsiteDataRecord *> *records) {
    442         // Should return both opening origin and top origin.
    443         EXPECT_EQ(records.count, 2u);
    444         auto sortFunction = ^(WKWebsiteDataRecord *record1, WKWebsiteDataRecord *record2){
    445             return [record1.displayName compare:record2.displayName];
    446         };
    447         auto sortedRecords = [records sortedArrayUsingComparator:sortFunction];
    448         EXPECT_WK_STREQ(@"127.0.0.1", [sortedRecords objectAtIndex:0].displayName);
    449         EXPECT_WK_STREQ(@"webkit.org", [sortedRecords objectAtIndex:1].displayName);
    450         done = true;
    451     }];
    452     TestWebKitAPI::Util::run(&done);
    453 }
    454 
    455261#endif // USE(APPLE_INTERNAL_SDK)
Note: See TracChangeset for help on using the changeset viewer.