Modified: trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp (290668 => 290669)
--- trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp 2022-03-01 20:08:39 UTC (rev 290668)
+++ trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.cpp 2022-03-01 20:57:25 UTC (rev 290669)
@@ -47,30 +47,6 @@
class OriginStorageManager::StorageBucket {
WTF_MAKE_FAST_ALLOCATED;
public:
- StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath, const String& idbStoragePath, bool shouldUseCustomPaths)
- : m_rootPath(rootPath)
- , m_identifier(identifier)
- , m_customLocalStoragePath(localStoragePath)
- , m_customIDBStoragePath(idbStoragePath)
- , m_shouldUseCustomPaths(shouldUseCustomPaths)
- {
- }
-
- StorageBucketMode mode() const { return m_mode; }
- void setMode(StorageBucketMode mode) { m_mode = mode; }
-
- void connectionClosed(IPC::Connection::UniqueID connection)
- {
- if (m_fileSystemStorageManager)
- m_fileSystemStorageManager->connectionClosed(connection);
-
- if (m_localStorageManager)
- m_localStorageManager->connectionClosed(connection);
-
- if (m_sessionStorageManager)
- m_sessionStorageManager->connectionClosed(connection);
- }
-
enum class StorageType : uint8_t {
FileSystem,
LocalStorage,
@@ -77,318 +53,337 @@
SessionStorage,
IndexedDB,
};
+ String toStorageIdentifier(StorageType) const;
+ StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath, const String& idbStoragePath, bool shouldUseCustomPaths);
+ StorageBucketMode mode() const { return m_mode; }
+ void setMode(StorageBucketMode mode) { m_mode = mode; }
+ void connectionClosed(IPC::Connection::UniqueID);
+ String typeStoragePath(StorageType) const;
+ FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry&);
+ LocalStorageManager& localStorageManager(StorageAreaRegistry&);
+ LocalStorageManager* existingLocalStorageManager() { return m_localStorageManager.get(); }
+ SessionStorageManager& sessionStorageManager(StorageAreaRegistry&);
+ SessionStorageManager* existingSessionStorageManager() { return m_sessionStorageManager.get(); }
+ IDBStorageManager& idbStorageManager(IDBStorageRegistry&, IDBStorageManager::QuotaCheckFunction&&);
+ IDBStorageManager* existingIDBStorageManager() { return m_idbStorageManager.get(); }
+ bool isActive() const;
+ bool isEmpty();
+ OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType>);
+ void deleteData(OptionSet<WebsiteDataType>, WallTime);
+ void moveData(OptionSet<WebsiteDataType>, const String& localStoragePath, const String& idbStoragePath);
+ String resolvedLocalStoragePath();
+ String resolvedIDBStoragePath();
- static std::optional<WebsiteDataType> toWebsiteDataType(const String& storageIdentifier)
- {
- if (storageIdentifier == "FileSystem"_s)
- return WebsiteDataType::FileSystem;
- if (storageIdentifier == "LocalStorage"_s)
- return WebsiteDataType::LocalStorage;
- if (storageIdentifier == "SessionStorage"_s)
- return WebsiteDataType::SessionStorage;
- if (storageIdentifier == "IndexedDB"_s)
- return WebsiteDataType::IndexedDBDatabases;
+private:
+ OptionSet<WebsiteDataType> fetchDataTypesInListFromMemory(OptionSet<WebsiteDataType>);
+ OptionSet<WebsiteDataType> fetchDataTypesInListFromDisk(OptionSet<WebsiteDataType>);
+ void deleteFileSystemStorageData(WallTime);
+ void deleteLocalStorageData(WallTime);
+ void deleteSessionStorageData();
+ void deleteIDBStorageData(WallTime);
- return std::nullopt;
- }
+ String m_rootPath;
+ String m_identifier;
+ StorageBucketMode m_mode { StorageBucketMode::BestEffort };
+ std::unique_ptr<FileSystemStorageManager> m_fileSystemStorageManager;
+ std::unique_ptr<LocalStorageManager> m_localStorageManager;
+ String m_customLocalStoragePath;
+ String m_resolvedLocalStoragePath;
+ std::unique_ptr<SessionStorageManager> m_sessionStorageManager;
+ std::unique_ptr<IDBStorageManager> m_idbStorageManager;
+ String m_customIDBStoragePath;
+ String m_resolvedIDBStoragePath;
+ bool m_shouldUseCustomPaths;
+};
- static String toStorageIdentifier(StorageType type)
- {
- switch (type) {
- case StorageType::FileSystem:
- return "FileSystem"_s;
- case StorageType::LocalStorage:
- return "LocalStorage"_s;
- case StorageType::SessionStorage:
- return "SessionStorage"_s;
- case StorageType::IndexedDB:
- return "IndexedDB"_s;
- default:
- break;
- }
- ASSERT_NOT_REACHED();
- return ""_s;
- }
+OriginStorageManager::StorageBucket::StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath, const String& idbStoragePath, bool shouldUseCustomPaths)
+ : m_rootPath(rootPath)
+ , m_identifier(identifier)
+ , m_customLocalStoragePath(localStoragePath)
+ , m_customIDBStoragePath(idbStoragePath)
+ , m_shouldUseCustomPaths(shouldUseCustomPaths)
+{
+}
- String typeStoragePath(StorageType type) const
- {
- auto storageIdentifier = toStorageIdentifier(type);
- if (m_rootPath.isEmpty() || storageIdentifier.isEmpty())
- return emptyString();
+void OriginStorageManager::StorageBucket::connectionClosed(IPC::Connection::UniqueID connection)
+{
+ if (m_fileSystemStorageManager)
+ m_fileSystemStorageManager->connectionClosed(connection);
- return FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
- }
+ if (m_localStorageManager)
+ m_localStorageManager->connectionClosed(connection);
- FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry& registry)
- {
- if (!m_fileSystemStorageManager)
- m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath(StorageType::FileSystem), registry);
+ if (m_sessionStorageManager)
+ m_sessionStorageManager->connectionClosed(connection);
+}
- return *m_fileSystemStorageManager;
+String OriginStorageManager::StorageBucket::toStorageIdentifier(StorageType type) const
+{
+ switch (type) {
+ case StorageType::FileSystem:
+ return "FileSystem"_s;
+ case StorageType::LocalStorage:
+ return "LocalStorage"_s;
+ case StorageType::SessionStorage:
+ return "SessionStorage"_s;
+ case StorageType::IndexedDB:
+ return "IndexedDB"_s;
+ default:
+ break;
}
+ ASSERT_NOT_REACHED();
+ return emptyString();
+}
- LocalStorageManager& localStorageManager(StorageAreaRegistry& registry)
- {
- if (!m_localStorageManager)
- m_localStorageManager = makeUnique<LocalStorageManager>(resolvedLocalStoragePath(), registry);
+String OriginStorageManager::StorageBucket::typeStoragePath(StorageType type) const
+{
+ auto storageIdentifier = toStorageIdentifier(type);
+ if (m_rootPath.isEmpty() || storageIdentifier.isEmpty())
+ return emptyString();
- return *m_localStorageManager;
- }
+ return FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
+}
- LocalStorageManager* existingLocalStorageManager()
- {
- return m_localStorageManager.get();
- }
+FileSystemStorageManager& OriginStorageManager::StorageBucket::fileSystemStorageManager(FileSystemStorageHandleRegistry& registry)
+{
+ if (!m_fileSystemStorageManager)
+ m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath(StorageType::FileSystem), registry);
- SessionStorageManager& sessionStorageManager(StorageAreaRegistry& registry)
- {
- if (!m_sessionStorageManager)
- m_sessionStorageManager = makeUnique<SessionStorageManager>(registry);
+ return *m_fileSystemStorageManager;
+}
- return *m_sessionStorageManager;
- }
+LocalStorageManager& OriginStorageManager::StorageBucket::localStorageManager(StorageAreaRegistry& registry)
+{
+ if (!m_localStorageManager)
+ m_localStorageManager = makeUnique<LocalStorageManager>(resolvedLocalStoragePath(), registry);
- SessionStorageManager* existingSessionStorageManager()
- {
- return m_sessionStorageManager.get();
- }
+ return *m_localStorageManager;
+}
- IDBStorageManager& idbStorageManager(IDBStorageRegistry& registry, IDBStorageManager::QuotaCheckFunction&& quotaCheckFunction)
- {
- if (!m_idbStorageManager)
- m_idbStorageManager = makeUnique<IDBStorageManager>(resolvedIDBStoragePath(), registry, WTFMove(quotaCheckFunction));
+SessionStorageManager& OriginStorageManager::StorageBucket::sessionStorageManager(StorageAreaRegistry& registry)
+{
+ if (!m_sessionStorageManager)
+ m_sessionStorageManager = makeUnique<SessionStorageManager>(registry);
- return *m_idbStorageManager;
- }
+ return *m_sessionStorageManager;
+}
- IDBStorageManager* existingIDBStorageManager()
- {
- return m_idbStorageManager.get();
- }
+IDBStorageManager& OriginStorageManager::StorageBucket::idbStorageManager(IDBStorageRegistry& registry, IDBStorageManager::QuotaCheckFunction&& quotaCheckFunction)
+{
+ if (!m_idbStorageManager)
+ m_idbStorageManager = makeUnique<IDBStorageManager>(resolvedIDBStoragePath(), registry, WTFMove(quotaCheckFunction));
- bool isActive() const
- {
- // We cannot remove the bucket if it has in-memory data, otherwise session
- // data may be lost.
- return (m_fileSystemStorageManager && m_fileSystemStorageManager->isActive())
- || (m_localStorageManager && (m_localStorageManager->hasDataInMemory() || m_localStorageManager->isActive()))
- || (m_sessionStorageManager && (m_sessionStorageManager->hasDataInMemory() || m_sessionStorageManager->isActive()))
- || (m_idbStorageManager && (m_idbStorageManager->hasDataInMemory() || m_idbStorageManager->isActive()));
- }
+ return *m_idbStorageManager;
+}
- bool isEmpty()
- {
- ASSERT(!RunLoop::isMain());
+bool OriginStorageManager::StorageBucket::isActive() const
+{
+ // We cannot remove the bucket if it has in-memory data, otherwise session
+ // data may be lost.
+ return (m_fileSystemStorageManager && m_fileSystemStorageManager->isActive())
+ || (m_localStorageManager && (m_localStorageManager->hasDataInMemory() || m_localStorageManager->isActive()))
+ || (m_sessionStorageManager && (m_sessionStorageManager->hasDataInMemory() || m_sessionStorageManager->isActive()))
+ || (m_idbStorageManager && (m_idbStorageManager->hasDataInMemory() || m_idbStorageManager->isActive()));
+}
- auto files = FileSystem::listDirectory(m_rootPath);
- auto hasValidFile = WTF::anyOf(files, [&](auto file) {
- bool isInvalidFile = (file == originFileName);
+bool OriginStorageManager::StorageBucket::isEmpty()
+{
+ ASSERT(!RunLoop::isMain());
+
+ auto files = FileSystem::listDirectory(m_rootPath);
+ auto hasValidFile = WTF::anyOf(files, [&](auto file) {
+ bool isInvalidFile = (file == originFileName);
#if PLATFORM(COCOA)
- isInvalidFile |= (file == ".DS_Store");
+ isInvalidFile |= (file == ".DS_Store");
#endif
- return !isInvalidFile;
- });
- if (hasValidFile)
- return false;
+ return !isInvalidFile;
+ });
+ if (hasValidFile)
+ return false;
- auto idbStorageFiles = FileSystem::listDirectory(resolvedIDBStoragePath());
- return !FileSystem::fileExists(resolvedLocalStoragePath()) && idbStorageFiles.isEmpty();
+ auto idbStorageFiles = FileSystem::listDirectory(resolvedIDBStoragePath());
+ return !FileSystem::fileExists(resolvedLocalStoragePath()) && idbStorageFiles.isEmpty();
+}
+
+OptionSet<WebsiteDataType> OriginStorageManager::StorageBucket::fetchDataTypesInList(OptionSet<WebsiteDataType> types)
+{
+ auto result = fetchDataTypesInListFromMemory(types);
+ result.add(fetchDataTypesInListFromDisk(types));
+
+ return result;
+}
+
+OptionSet<WebsiteDataType> OriginStorageManager::StorageBucket::fetchDataTypesInListFromMemory(OptionSet<WebsiteDataType> types)
+{
+ OptionSet<WebsiteDataType> result;
+ if (types.contains(WebsiteDataType::LocalStorage)) {
+ if (m_localStorageManager && m_localStorageManager->hasDataInMemory())
+ result.add(WebsiteDataType::LocalStorage);
}
- OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType> types)
- {
- auto result = fetchDataTypesInListFromMemory(types);
- result.add(fetchDataTypesInListFromDisk(types));
+ if (types.contains(WebsiteDataType::SessionStorage)) {
+ if (m_sessionStorageManager && m_sessionStorageManager->hasDataInMemory())
+ result.add(WebsiteDataType::SessionStorage);
+ }
- return result;
+ if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
+ if (m_idbStorageManager && m_idbStorageManager->hasDataInMemory())
+ result.add(WebsiteDataType::IndexedDBDatabases);
}
- void deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime)
- {
- if (types.contains(WebsiteDataType::FileSystem))
- deleteFileSystemStorageData(modifiedSinceTime);
+ return result;
+}
- if (types.contains(WebsiteDataType::LocalStorage))
- deleteLocalStorageData(modifiedSinceTime);
+OptionSet<WebsiteDataType> OriginStorageManager::StorageBucket::fetchDataTypesInListFromDisk(OptionSet<WebsiteDataType> types)
+{
+ OptionSet<WebsiteDataType> result;
+ if (types.contains(WebsiteDataType::FileSystem)) {
+ auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
+ if (auto files = FileSystem::listDirectory(fileSystemStoragePath); !files.isEmpty())
+ result.add(WebsiteDataType::FileSystem);
+ }
- if (types.contains(WebsiteDataType::SessionStorage) && modifiedSinceTime < WallTime::now())
- deleteSessionStorageData();
+ if (types.contains(WebsiteDataType::LocalStorage)) {
+ if (FileSystem::fileExists(resolvedLocalStoragePath()))
+ result.add(WebsiteDataType::LocalStorage);
+ }
- if (types.contains(WebsiteDataType::IndexedDBDatabases))
- deleteIDBStorageData(modifiedSinceTime);
+ if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
+ if (auto databases = FileSystem::listDirectory(resolvedIDBStoragePath()); !databases.isEmpty())
+ result.add(WebsiteDataType::IndexedDBDatabases);
}
- void moveData(OptionSet<WebsiteDataType> types, const String& localStoragePath, const String& idbStoragePath)
- {
- // This is only supported for IndexedDB and LocalStorage now.
- if (types.contains(WebsiteDataType::LocalStorage) && !localStoragePath.isEmpty()) {
- if (m_localStorageManager)
- m_localStorageManager->close();
+ return result;
+}
- auto currentLocalStoragePath = resolvedLocalStoragePath();
- if (!currentLocalStoragePath.isEmpty()) {
- FileSystem::makeAllDirectories(FileSystem::parentPath(localStoragePath));
- WebCore::SQLiteFileSystem::moveDatabaseFile(currentLocalStoragePath, localStoragePath);
- }
- }
+void OriginStorageManager::StorageBucket::deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime)
+{
+ if (types.contains(WebsiteDataType::FileSystem))
+ deleteFileSystemStorageData(modifiedSinceTime);
- if (types.contains(WebsiteDataType::IndexedDBDatabases) && !idbStoragePath.isEmpty()) {
- if (m_idbStorageManager)
- m_idbStorageManager->closeDatabasesForDeletion();
+ if (types.contains(WebsiteDataType::LocalStorage))
+ deleteLocalStorageData(modifiedSinceTime);
- auto currentIDBStoragePath = resolvedIDBStoragePath();
- if (!currentIDBStoragePath.isEmpty()) {
- FileSystem::makeAllDirectories(FileSystem::parentPath(idbStoragePath));
- FileSystem::moveFile(currentIDBStoragePath, idbStoragePath);
- }
- }
- }
+ if (types.contains(WebsiteDataType::SessionStorage) && modifiedSinceTime < WallTime::now())
+ deleteSessionStorageData();
- String resolvedLocalStoragePath()
- {
- if (!m_resolvedLocalStoragePath.isNull())
- return m_resolvedLocalStoragePath;
+ if (types.contains(WebsiteDataType::IndexedDBDatabases))
+ deleteIDBStorageData(modifiedSinceTime);
+}
- if (m_shouldUseCustomPaths) {
- ASSERT(m_customLocalStoragePath.isEmpty() == m_rootPath.isEmpty());
- m_resolvedLocalStoragePath = m_customLocalStoragePath;
- } else if (!m_rootPath.isEmpty()) {
- auto localStorageDirectory = typeStoragePath(StorageType::LocalStorage);
- FileSystem::makeAllDirectories(localStorageDirectory);
- FileSystem::excludeFromBackup(localStorageDirectory);
+void OriginStorageManager::StorageBucket::deleteFileSystemStorageData(WallTime modifiedSinceTime)
+{
+ m_fileSystemStorageManager = nullptr;
- auto localStoragePath = LocalStorageManager::localStorageFilePath(localStorageDirectory);
- if (!m_customLocalStoragePath.isEmpty() && !FileSystem::fileExists(localStoragePath) && FileSystem::fileExists(m_customLocalStoragePath))
- WebCore::SQLiteFileSystem::moveDatabaseFile(m_customLocalStoragePath, localStoragePath);
+ auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
+ FileSystem::deleteAllFilesModifiedSince(fileSystemStoragePath, modifiedSinceTime);
+}
- m_resolvedLocalStoragePath = localStoragePath;
- } else
- m_resolvedLocalStoragePath = emptyString();
-
- return m_resolvedLocalStoragePath;
+void OriginStorageManager::StorageBucket::deleteLocalStorageData(WallTime time)
+{
+ auto currentLocalStoragePath = resolvedLocalStoragePath();
+ if (FileSystem::fileModificationTime(currentLocalStoragePath) >= time) {
+ if (m_localStorageManager)
+ m_localStorageManager->clearDataOnDisk();
+ WebCore::SQLiteFileSystem::deleteDatabaseFile(currentLocalStoragePath);
}
- String resolvedIDBStoragePath()
- {
- ASSERT(!RunLoop::isMain());
+ if (!m_localStorageManager)
+ return;
- if (!m_resolvedIDBStoragePath.isNull())
- return m_resolvedIDBStoragePath;
+ m_localStorageManager->clearDataInMemory();
+ if (!m_localStorageManager->isActive())
+ m_localStorageManager = nullptr;
+}
- if (m_shouldUseCustomPaths) {
- ASSERT(m_customIDBStoragePath.isEmpty() == m_rootPath.isEmpty());
- m_resolvedIDBStoragePath = m_customIDBStoragePath;
- } else {
- auto idbStoragePath = typeStoragePath(StorageType::IndexedDB);
- IDBStorageManager::migrateOriginData(m_customIDBStoragePath, idbStoragePath);
- m_resolvedIDBStoragePath = idbStoragePath;
- }
-
- ASSERT(!m_resolvedIDBStoragePath.isNull());
- return m_resolvedIDBStoragePath;
- }
+void OriginStorageManager::StorageBucket::deleteSessionStorageData()
+{
+ if (!m_sessionStorageManager)
+ return;
-private:
- OptionSet<WebsiteDataType> fetchDataTypesInListFromMemory(OptionSet<WebsiteDataType> types)
- {
- OptionSet<WebsiteDataType> result;
- if (types.contains(WebsiteDataType::LocalStorage)) {
- if (m_localStorageManager && m_localStorageManager->hasDataInMemory())
- result.add(WebsiteDataType::LocalStorage);
- }
+ m_sessionStorageManager->clearData();
+ if (!m_sessionStorageManager->isActive())
+ m_sessionStorageManager = nullptr;
+}
- if (types.contains(WebsiteDataType::SessionStorage)) {
- if (m_sessionStorageManager && m_sessionStorageManager->hasDataInMemory())
- result.add(WebsiteDataType::SessionStorage);
- }
+void OriginStorageManager::StorageBucket::deleteIDBStorageData(WallTime time)
+{
+ if (m_idbStorageManager)
+ m_idbStorageManager->closeDatabasesForDeletion();
- if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
- if (m_idbStorageManager && m_idbStorageManager->hasDataInMemory())
- result.add(WebsiteDataType::IndexedDBDatabases);
- }
+ FileSystem::deleteAllFilesModifiedSince(resolvedIDBStoragePath(), time);
+}
- return result;
- }
+void OriginStorageManager::StorageBucket::moveData(OptionSet<WebsiteDataType> types, const String& localStoragePath, const String& idbStoragePath)
+{
+ // This is only supported for IndexedDB and LocalStorage now.
+ if (types.contains(WebsiteDataType::LocalStorage) && !localStoragePath.isEmpty()) {
+ if (m_localStorageManager)
+ m_localStorageManager->close();
- OptionSet<WebsiteDataType> fetchDataTypesInListFromDisk(OptionSet<WebsiteDataType> types)
- {
- OptionSet<WebsiteDataType> result;
- if (types.contains(WebsiteDataType::FileSystem)) {
- auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
- if (auto files = FileSystem::listDirectory(fileSystemStoragePath); !files.isEmpty())
- result.add(WebsiteDataType::FileSystem);
+ auto currentLocalStoragePath = resolvedLocalStoragePath();
+ if (!currentLocalStoragePath.isEmpty()) {
+ FileSystem::makeAllDirectories(FileSystem::parentPath(localStoragePath));
+ WebCore::SQLiteFileSystem::moveDatabaseFile(currentLocalStoragePath, localStoragePath);
}
+ }
- if (types.contains(WebsiteDataType::LocalStorage)) {
- if (FileSystem::fileExists(resolvedLocalStoragePath()))
- result.add(WebsiteDataType::LocalStorage);
- }
+ if (types.contains(WebsiteDataType::IndexedDBDatabases) && !idbStoragePath.isEmpty()) {
+ if (m_idbStorageManager)
+ m_idbStorageManager->closeDatabasesForDeletion();
- if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
- if (auto databases = FileSystem::listDirectory(resolvedIDBStoragePath()); !databases.isEmpty())
- result.add(WebsiteDataType::IndexedDBDatabases);
+ auto currentIDBStoragePath = resolvedIDBStoragePath();
+ if (!currentIDBStoragePath.isEmpty()) {
+ FileSystem::makeAllDirectories(FileSystem::parentPath(idbStoragePath));
+ FileSystem::moveFile(currentIDBStoragePath, idbStoragePath);
}
-
- return result;
}
+}
- void deleteFileSystemStorageData(WallTime modifiedSinceTime)
- {
- m_fileSystemStorageManager = nullptr;
+String OriginStorageManager::StorageBucket::resolvedLocalStoragePath()
+{
+ if (!m_resolvedLocalStoragePath.isNull())
+ return m_resolvedLocalStoragePath;
- auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
- FileSystem::deleteAllFilesModifiedSince(fileSystemStoragePath, modifiedSinceTime);
- }
+ if (m_shouldUseCustomPaths) {
+ ASSERT(m_customLocalStoragePath.isEmpty() == m_rootPath.isEmpty());
+ m_resolvedLocalStoragePath = m_customLocalStoragePath;
+ } else if (!m_rootPath.isEmpty()) {
+ auto localStorageDirectory = typeStoragePath(StorageType::LocalStorage);
+ FileSystem::makeAllDirectories(localStorageDirectory);
+ FileSystem::excludeFromBackup(localStorageDirectory);
- void deleteLocalStorageData(WallTime time)
- {
- auto currentLocalStoragePath = resolvedLocalStoragePath();
- if (FileSystem::fileModificationTime(currentLocalStoragePath) >= time) {
- if (m_localStorageManager)
- m_localStorageManager->clearDataOnDisk();
- WebCore::SQLiteFileSystem::deleteDatabaseFile(currentLocalStoragePath);
- }
+ auto localStoragePath = LocalStorageManager::localStorageFilePath(localStorageDirectory);
+ if (!m_customLocalStoragePath.isEmpty() && !FileSystem::fileExists(localStoragePath) && FileSystem::fileExists(m_customLocalStoragePath))
+ WebCore::SQLiteFileSystem::moveDatabaseFile(m_customLocalStoragePath, localStoragePath);
- if (!m_localStorageManager)
- return;
+ m_resolvedLocalStoragePath = localStoragePath;
+ } else
+ m_resolvedLocalStoragePath = emptyString();
- m_localStorageManager->clearDataInMemory();
- if (!m_localStorageManager->isActive())
- m_localStorageManager = nullptr;
- }
+ return m_resolvedLocalStoragePath;
+}
- void deleteSessionStorageData()
- {
- if (!m_sessionStorageManager)
- return;
+String OriginStorageManager::StorageBucket::resolvedIDBStoragePath()
+{
+ ASSERT(!RunLoop::isMain());
- m_sessionStorageManager->clearData();
- if (!m_sessionStorageManager->isActive())
- m_sessionStorageManager = nullptr;
+ if (!m_resolvedIDBStoragePath.isNull())
+ return m_resolvedIDBStoragePath;
+
+ if (m_shouldUseCustomPaths) {
+ ASSERT(m_customIDBStoragePath.isEmpty() == m_rootPath.isEmpty());
+ m_resolvedIDBStoragePath = m_customIDBStoragePath;
+ } else {
+ auto idbStoragePath = typeStoragePath(StorageType::IndexedDB);
+ IDBStorageManager::migrateOriginData(m_customIDBStoragePath, idbStoragePath);
+ m_resolvedIDBStoragePath = idbStoragePath;
}
- void deleteIDBStorageData(WallTime time)
- {
- if (m_idbStorageManager)
- m_idbStorageManager->closeDatabasesForDeletion();
+ ASSERT(!m_resolvedIDBStoragePath.isNull());
+ return m_resolvedIDBStoragePath;
+}
- FileSystem::deleteAllFilesModifiedSince(resolvedIDBStoragePath(), time);
- }
-
- String m_rootPath;
- String m_identifier;
- StorageBucketMode m_mode { StorageBucketMode::BestEffort };
- std::unique_ptr<FileSystemStorageManager> m_fileSystemStorageManager;
- std::unique_ptr<LocalStorageManager> m_localStorageManager;
- String m_customLocalStoragePath;
- String m_resolvedLocalStoragePath;
- std::unique_ptr<SessionStorageManager> m_sessionStorageManager;
- std::unique_ptr<IDBStorageManager> m_idbStorageManager;
- String m_customIDBStoragePath;
- String m_resolvedIDBStoragePath;
- bool m_shouldUseCustomPaths;
-};
-
String OriginStorageManager::originFileIdentifier()
{
return originFileName;
