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

Changeset 290669 in webkit


Ignore:
Timestamp:
Mar 1, 2022, 12:57:25 PM (5 years ago)
Author:
sihui_liu@apple.com
Message:

Move StorageBucket function definitions outside the class definition
​https://bugs.webkit.org/show_bug.cgi?id=237300

Reviewed by Chris Dumez.

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

(WebKit::OriginStorageManager::StorageBucket::mode const):
(WebKit::OriginStorageManager::StorageBucket::setMode):
(WebKit::OriginStorageManager::StorageBucket::StorageBucket):
(WebKit::OriginStorageManager::StorageBucket::connectionClosed):
(WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier const):
(WebKit::OriginStorageManager::StorageBucket::typeStoragePath const):
(WebKit::OriginStorageManager::StorageBucket::fileSystemStorageManager):
(WebKit::OriginStorageManager::StorageBucket::localStorageManager):
(WebKit::OriginStorageManager::StorageBucket::existingLocalStorageManager):
(WebKit::OriginStorageManager::StorageBucket::sessionStorageManager):
(WebKit::OriginStorageManager::StorageBucket::existingSessionStorageManager):
(WebKit::OriginStorageManager::StorageBucket::idbStorageManager):
(WebKit::OriginStorageManager::StorageBucket::existingIDBStorageManager):
(WebKit::OriginStorageManager::StorageBucket::isActive const):
(WebKit::OriginStorageManager::StorageBucket::isEmpty):
(WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInList):
(WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromMemory):
(WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromDisk):
(WebKit::OriginStorageManager::StorageBucket::deleteData):
(WebKit::OriginStorageManager::StorageBucket::deleteFileSystemStorageData):
(WebKit::OriginStorageManager::StorageBucket::deleteLocalStorageData):
(WebKit::OriginStorageManager::StorageBucket::deleteSessionStorageData):
(WebKit::OriginStorageManager::StorageBucket::deleteIDBStorageData):
(WebKit::OriginStorageManager::StorageBucket::moveData):
(WebKit::OriginStorageManager::StorageBucket::resolvedLocalStoragePath):
(WebKit::OriginStorageManager::StorageBucket::resolvedIDBStoragePath):
(WebKit::OriginStorageManager::StorageBucket::toWebsiteDataType): Deleted.
(WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier): Deleted.

Location:
trunk/Source/WebKit
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r290659 r290669  
     12022-03-01  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Move StorageBucket function definitions outside the class definition
     4        https://bugs.webkit.org/show_bug.cgi?id=237300
     5
     6        Reviewed by Chris Dumez.
     7
     8        * NetworkProcess/storage/NetworkStorageManager.h:
     9        * NetworkProcess/storage/OriginStorageManager.cpp:
     10        (WebKit::OriginStorageManager::StorageBucket::mode const):
     11        (WebKit::OriginStorageManager::StorageBucket::setMode):
     12        (WebKit::OriginStorageManager::StorageBucket::StorageBucket):
     13        (WebKit::OriginStorageManager::StorageBucket::connectionClosed):
     14        (WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier const):
     15        (WebKit::OriginStorageManager::StorageBucket::typeStoragePath const):
     16        (WebKit::OriginStorageManager::StorageBucket::fileSystemStorageManager):
     17        (WebKit::OriginStorageManager::StorageBucket::localStorageManager):
     18        (WebKit::OriginStorageManager::StorageBucket::existingLocalStorageManager):
     19        (WebKit::OriginStorageManager::StorageBucket::sessionStorageManager):
     20        (WebKit::OriginStorageManager::StorageBucket::existingSessionStorageManager):
     21        (WebKit::OriginStorageManager::StorageBucket::idbStorageManager):
     22        (WebKit::OriginStorageManager::StorageBucket::existingIDBStorageManager):
     23        (WebKit::OriginStorageManager::StorageBucket::isActive const):
     24        (WebKit::OriginStorageManager::StorageBucket::isEmpty):
     25        (WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInList):
     26        (WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromMemory):
     27        (WebKit::OriginStorageManager::StorageBucket::fetchDataTypesInListFromDisk):
     28        (WebKit::OriginStorageManager::StorageBucket::deleteData):
     29        (WebKit::OriginStorageManager::StorageBucket::deleteFileSystemStorageData):
     30        (WebKit::OriginStorageManager::StorageBucket::deleteLocalStorageData):
     31        (WebKit::OriginStorageManager::StorageBucket::deleteSessionStorageData):
     32        (WebKit::OriginStorageManager::StorageBucket::deleteIDBStorageData):
     33        (WebKit::OriginStorageManager::StorageBucket::moveData):
     34        (WebKit::OriginStorageManager::StorageBucket::resolvedLocalStoragePath):
     35        (WebKit::OriginStorageManager::StorageBucket::resolvedIDBStoragePath):
     36        (WebKit::OriginStorageManager::StorageBucket::toWebsiteDataType): Deleted.
     37        (WebKit::OriginStorageManager::StorageBucket::toStorageIdentifier): Deleted.
     38
    1392022-03-01  Alex Christensen  <achristensen@webkit.org>
    240

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

    r290623 r290669  
    4141#include <pal/SessionID.h>
    4242#include <wtf/Forward.h>
    43 #include <wtf/WeakHashSet.h>
    4443
    4544namespace IPC {

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

    r290632 r290669  
    4848    WTF_MAKE_FAST_ALLOCATED;
    4949public:
    50     StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath, const String& idbStoragePath, bool shouldUseCustomPaths)
    51         : m_rootPath(rootPath)
    52         , m_identifier(identifier)
    53         , m_customLocalStoragePath(localStoragePath)
    54         , m_customIDBStoragePath(idbStoragePath)
    55         , m_shouldUseCustomPaths(shouldUseCustomPaths)
    56     {
    57     }
    58 
    59     StorageBucketMode mode() const { return m_mode; }
    60     void setMode(StorageBucketMode mode) { m_mode = mode; }
    61 
    62     void connectionClosed(IPC::Connection::UniqueID connection)
    63     {
    64         if (m_fileSystemStorageManager)
    65             m_fileSystemStorageManager->connectionClosed(connection);
    66 
    67         if (m_localStorageManager)
    68             m_localStorageManager->connectionClosed(connection);
    69 
    70         if (m_sessionStorageManager)
    71             m_sessionStorageManager->connectionClosed(connection);
    72     }
    73 
    7450    enum class StorageType : uint8_t {
    7551        FileSystem,
    … …  
    7854        IndexedDB,
    7955    };
    80 
    81     static std::optional<WebsiteDataType> toWebsiteDataType(const String& storageIdentifier)
    82     {
    83         if (storageIdentifier == "FileSystem"_s)
    84             return WebsiteDataType::FileSystem;
    85         if (storageIdentifier == "LocalStorage"_s)
    86             return WebsiteDataType::LocalStorage;
    87         if (storageIdentifier == "SessionStorage"_s)
    88             return WebsiteDataType::SessionStorage;
    89         if (storageIdentifier == "IndexedDB"_s)
    90             return WebsiteDataType::IndexedDBDatabases;
    91 
    92         return std::nullopt;
    93     }
    94 
    95     static String toStorageIdentifier(StorageType type)
    96     {
    97         switch (type) {
    98         case StorageType::FileSystem:
    99             return "FileSystem"_s;
    100         case StorageType::LocalStorage:
    101             return "LocalStorage"_s;
    102         case StorageType::SessionStorage:
    103             return "SessionStorage"_s;
    104         case StorageType::IndexedDB:
    105             return "IndexedDB"_s;
    106         default:
    107             break;
    108         }
    109         ASSERT_NOT_REACHED();
    110         return ""_s;
    111     }
    112 
    113     String typeStoragePath(StorageType type) const
    114     {
    115         auto storageIdentifier = toStorageIdentifier(type);
    116         if (m_rootPath.isEmpty() || storageIdentifier.isEmpty())
    117             return emptyString();
    118 
    119         return FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
    120     }
    121 
    122     FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry& registry)
    123     {
    124         if (!m_fileSystemStorageManager)
    125             m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath(StorageType::FileSystem), registry);
    126 
    127         return *m_fileSystemStorageManager;
    128     }
    129 
    130     LocalStorageManager& localStorageManager(StorageAreaRegistry& registry)
    131     {
    132         if (!m_localStorageManager)
    133             m_localStorageManager = makeUnique<LocalStorageManager>(resolvedLocalStoragePath(), registry);
    134 
    135         return *m_localStorageManager;
    136     }
    137 
    138     LocalStorageManager* existingLocalStorageManager()
    139     {
    140         return m_localStorageManager.get();
    141     }
    142 
    143     SessionStorageManager& sessionStorageManager(StorageAreaRegistry& registry)
    144     {
    145         if (!m_sessionStorageManager)
    146             m_sessionStorageManager = makeUnique<SessionStorageManager>(registry);
    147 
    148         return *m_sessionStorageManager;
    149     }
    150 
    151     SessionStorageManager* existingSessionStorageManager()
    152     {
    153         return m_sessionStorageManager.get();
    154     }
    155 
    156     IDBStorageManager& idbStorageManager(IDBStorageRegistry& registry, IDBStorageManager::QuotaCheckFunction&& quotaCheckFunction)
    157     {
    158         if (!m_idbStorageManager)
    159             m_idbStorageManager = makeUnique<IDBStorageManager>(resolvedIDBStoragePath(), registry, WTFMove(quotaCheckFunction));
    160 
    161         return *m_idbStorageManager;
    162     }
    163 
    164     IDBStorageManager* existingIDBStorageManager()
    165     {
    166         return m_idbStorageManager.get();
    167     }
    168 
    169     bool isActive() const
    170     {
    171         // We cannot remove the bucket if it has in-memory data, otherwise session
    172         // data may be lost.
    173         return (m_fileSystemStorageManager && m_fileSystemStorageManager->isActive())
    174             || (m_localStorageManager && (m_localStorageManager->hasDataInMemory() || m_localStorageManager->isActive()))
    175             || (m_sessionStorageManager && (m_sessionStorageManager->hasDataInMemory() || m_sessionStorageManager->isActive()))
    176             || (m_idbStorageManager && (m_idbStorageManager->hasDataInMemory() || m_idbStorageManager->isActive()));
    177     }
    178 
    179     bool isEmpty()
    180     {
    181         ASSERT(!RunLoop::isMain());
    182 
    183         auto files = FileSystem::listDirectory(m_rootPath);
    184         auto hasValidFile = WTF::anyOf(files, [&](auto file) {
    185             bool isInvalidFile = (file == originFileName);
    186 #if PLATFORM(COCOA)
    187             isInvalidFile |= (file == ".DS_Store");
    188 #endif
    189             return !isInvalidFile;
    190         });
    191         if (hasValidFile)
    192             return false;
    193 
    194         auto idbStorageFiles = FileSystem::listDirectory(resolvedIDBStoragePath());
    195         return !FileSystem::fileExists(resolvedLocalStoragePath()) && idbStorageFiles.isEmpty();
    196     }
    197 
    198     OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType> types)
    199     {
    200         auto result = fetchDataTypesInListFromMemory(types);
    201         result.add(fetchDataTypesInListFromDisk(types));
    202 
    203         return result;
    204     }
    205 
    206     void deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime)
    207     {
    208         if (types.contains(WebsiteDataType::FileSystem))
    209             deleteFileSystemStorageData(modifiedSinceTime);
    210 
    211         if (types.contains(WebsiteDataType::LocalStorage))
    212             deleteLocalStorageData(modifiedSinceTime);
    213 
    214         if (types.contains(WebsiteDataType::SessionStorage) && modifiedSinceTime < WallTime::now())
    215             deleteSessionStorageData();
    216 
    217         if (types.contains(WebsiteDataType::IndexedDBDatabases))
    218             deleteIDBStorageData(modifiedSinceTime);
    219     }
    220 
    221     void moveData(OptionSet<WebsiteDataType> types, const String& localStoragePath, const String& idbStoragePath)
    222     {
    223         // This is only supported for IndexedDB and LocalStorage now.
    224         if (types.contains(WebsiteDataType::LocalStorage) && !localStoragePath.isEmpty()) {
    225             if (m_localStorageManager)
    226                 m_localStorageManager->close();
    227 
    228             auto currentLocalStoragePath = resolvedLocalStoragePath();
    229             if (!currentLocalStoragePath.isEmpty()) {
    230                 FileSystem::makeAllDirectories(FileSystem::parentPath(localStoragePath));
    231                 WebCore::SQLiteFileSystem::moveDatabaseFile(currentLocalStoragePath, localStoragePath);
    232             }
    233         }
    234 
    235         if (types.contains(WebsiteDataType::IndexedDBDatabases) && !idbStoragePath.isEmpty()) {
    236             if (m_idbStorageManager)
    237                 m_idbStorageManager->closeDatabasesForDeletion();
    238 
    239             auto currentIDBStoragePath = resolvedIDBStoragePath();
    240             if (!currentIDBStoragePath.isEmpty()) {
    241                 FileSystem::makeAllDirectories(FileSystem::parentPath(idbStoragePath));
    242                 FileSystem::moveFile(currentIDBStoragePath, idbStoragePath);
    243             }
    244         }
    245     }
    246 
    247     String resolvedLocalStoragePath()
    248     {
    249         if (!m_resolvedLocalStoragePath.isNull())
    250             return m_resolvedLocalStoragePath;
    251 
    252         if (m_shouldUseCustomPaths) {
    253             ASSERT(m_customLocalStoragePath.isEmpty() == m_rootPath.isEmpty());
    254             m_resolvedLocalStoragePath = m_customLocalStoragePath;
    255         } else if (!m_rootPath.isEmpty()) {
    256             auto localStorageDirectory = typeStoragePath(StorageType::LocalStorage);
    257             FileSystem::makeAllDirectories(localStorageDirectory);
    258             FileSystem::excludeFromBackup(localStorageDirectory);
    259 
    260             auto localStoragePath = LocalStorageManager::localStorageFilePath(localStorageDirectory);
    261             if (!m_customLocalStoragePath.isEmpty() && !FileSystem::fileExists(localStoragePath) && FileSystem::fileExists(m_customLocalStoragePath))
    262                 WebCore::SQLiteFileSystem::moveDatabaseFile(m_customLocalStoragePath, localStoragePath);
    263 
    264             m_resolvedLocalStoragePath = localStoragePath;
    265         } else
    266             m_resolvedLocalStoragePath = emptyString();
    267 
    268         return m_resolvedLocalStoragePath;
    269     }
    270 
    271     String resolvedIDBStoragePath()
    272     {
    273         ASSERT(!RunLoop::isMain());
    274 
    275         if (!m_resolvedIDBStoragePath.isNull())
    276             return m_resolvedIDBStoragePath;
    277 
    278         if (m_shouldUseCustomPaths) {
    279             ASSERT(m_customIDBStoragePath.isEmpty() == m_rootPath.isEmpty());
    280             m_resolvedIDBStoragePath = m_customIDBStoragePath;
    281         } else {
    282             auto idbStoragePath = typeStoragePath(StorageType::IndexedDB);
    283             IDBStorageManager::migrateOriginData(m_customIDBStoragePath, idbStoragePath);
    284             m_resolvedIDBStoragePath = idbStoragePath;
    285         }
    286        
    287         ASSERT(!m_resolvedIDBStoragePath.isNull());
    288         return m_resolvedIDBStoragePath;
    289     }
     56    String toStorageIdentifier(StorageType) const;
     57    StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath, const String& idbStoragePath, bool shouldUseCustomPaths);
     58    StorageBucketMode mode() const { return m_mode; }
     59    void setMode(StorageBucketMode mode) { m_mode = mode; }
     60    void connectionClosed(IPC::Connection::UniqueID);
     61    String typeStoragePath(StorageType) const;
     62    FileSystemStorageManager& fileSystemStorageManager(FileSystemStorageHandleRegistry&);
     63    LocalStorageManager& localStorageManager(StorageAreaRegistry&);
     64    LocalStorageManager* existingLocalStorageManager() { return m_localStorageManager.get(); }
     65    SessionStorageManager& sessionStorageManager(StorageAreaRegistry&);
     66    SessionStorageManager* existingSessionStorageManager() { return m_sessionStorageManager.get(); }
     67    IDBStorageManager& idbStorageManager(IDBStorageRegistry&, IDBStorageManager::QuotaCheckFunction&&);
     68    IDBStorageManager* existingIDBStorageManager() { return m_idbStorageManager.get(); }
     69    bool isActive() const;
     70    bool isEmpty();
     71    OptionSet<WebsiteDataType> fetchDataTypesInList(OptionSet<WebsiteDataType>);
     72    void deleteData(OptionSet<WebsiteDataType>, WallTime);
     73    void moveData(OptionSet<WebsiteDataType>, const String& localStoragePath, const String& idbStoragePath);
     74    String resolvedLocalStoragePath();
     75    String resolvedIDBStoragePath();
    29076
    29177private:
    292     OptionSet<WebsiteDataType> fetchDataTypesInListFromMemory(OptionSet<WebsiteDataType> types)
    293     {
    294         OptionSet<WebsiteDataType> result;
    295         if (types.contains(WebsiteDataType::LocalStorage)) {
    296             if (m_localStorageManager && m_localStorageManager->hasDataInMemory())
    297                 result.add(WebsiteDataType::LocalStorage);
    298         }
    299 
    300         if (types.contains(WebsiteDataType::SessionStorage)) {
    301             if (m_sessionStorageManager && m_sessionStorageManager->hasDataInMemory())
    302                 result.add(WebsiteDataType::SessionStorage);
    303         }
    304 
    305         if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
    306             if (m_idbStorageManager && m_idbStorageManager->hasDataInMemory())
    307                 result.add(WebsiteDataType::IndexedDBDatabases);
    308         }
    309 
    310         return result;
    311     }
    312 
    313     OptionSet<WebsiteDataType> fetchDataTypesInListFromDisk(OptionSet<WebsiteDataType> types)
    314     {
    315         OptionSet<WebsiteDataType> result;
    316         if (types.contains(WebsiteDataType::FileSystem)) {
    317             auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
    318             if (auto files = FileSystem::listDirectory(fileSystemStoragePath); !files.isEmpty())
    319                 result.add(WebsiteDataType::FileSystem);
    320         }
    321 
    322         if (types.contains(WebsiteDataType::LocalStorage)) {
    323             if (FileSystem::fileExists(resolvedLocalStoragePath()))
    324                 result.add(WebsiteDataType::LocalStorage);
    325         }
    326 
    327         if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
    328             if (auto databases = FileSystem::listDirectory(resolvedIDBStoragePath()); !databases.isEmpty())
    329                 result.add(WebsiteDataType::IndexedDBDatabases);
    330         }
    331 
    332         return result;
    333     }
    334 
    335     void deleteFileSystemStorageData(WallTime modifiedSinceTime)
    336     {
    337         m_fileSystemStorageManager = nullptr;
    338 
    339         auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
    340         FileSystem::deleteAllFilesModifiedSince(fileSystemStoragePath, modifiedSinceTime);
    341     }
    342 
    343     void deleteLocalStorageData(WallTime time)
    344     {
    345         auto currentLocalStoragePath = resolvedLocalStoragePath();
    346         if (FileSystem::fileModificationTime(currentLocalStoragePath) >= time) {
    347             if (m_localStorageManager)
    348                 m_localStorageManager->clearDataOnDisk();
    349             WebCore::SQLiteFileSystem::deleteDatabaseFile(currentLocalStoragePath);
    350         }
    351 
    352         if (!m_localStorageManager)
    353             return;
    354 
    355         m_localStorageManager->clearDataInMemory();
    356         if (!m_localStorageManager->isActive())
    357             m_localStorageManager = nullptr;
    358     }
    359 
    360     void deleteSessionStorageData()
    361     {
    362         if (!m_sessionStorageManager)
    363             return;
    364 
    365         m_sessionStorageManager->clearData();
    366         if (!m_sessionStorageManager->isActive())
    367             m_sessionStorageManager = nullptr;
    368     }
    369    
    370     void deleteIDBStorageData(WallTime time)
    371     {
    372         if (m_idbStorageManager)
    373             m_idbStorageManager->closeDatabasesForDeletion();
    374 
    375         FileSystem::deleteAllFilesModifiedSince(resolvedIDBStoragePath(), time);
    376     }
     78    OptionSet<WebsiteDataType> fetchDataTypesInListFromMemory(OptionSet<WebsiteDataType>);
     79    OptionSet<WebsiteDataType> fetchDataTypesInListFromDisk(OptionSet<WebsiteDataType>);
     80    void deleteFileSystemStorageData(WallTime);
     81    void deleteLocalStorageData(WallTime);
     82    void deleteSessionStorageData();
     83    void deleteIDBStorageData(WallTime);
    37784
    37885    String m_rootPath;
    … …  
    39097};
    39198
     99OriginStorageManager::StorageBucket::StorageBucket(const String& rootPath, const String& identifier, const String& localStoragePath, const String& idbStoragePath, bool shouldUseCustomPaths)
     100    : m_rootPath(rootPath)
     101    , m_identifier(identifier)
     102    , m_customLocalStoragePath(localStoragePath)
     103    , m_customIDBStoragePath(idbStoragePath)
     104    , m_shouldUseCustomPaths(shouldUseCustomPaths)
     105{
     106}
     107
     108void OriginStorageManager::StorageBucket::connectionClosed(IPC::Connection::UniqueID connection)
     109{
     110    if (m_fileSystemStorageManager)
     111        m_fileSystemStorageManager->connectionClosed(connection);
     112
     113    if (m_localStorageManager)
     114        m_localStorageManager->connectionClosed(connection);
     115
     116    if (m_sessionStorageManager)
     117        m_sessionStorageManager->connectionClosed(connection);
     118}
     119
     120String OriginStorageManager::StorageBucket::toStorageIdentifier(StorageType type) const
     121{
     122    switch (type) {
     123    case StorageType::FileSystem:
     124        return "FileSystem"_s;
     125    case StorageType::LocalStorage:
     126        return "LocalStorage"_s;
     127    case StorageType::SessionStorage:
     128        return "SessionStorage"_s;
     129    case StorageType::IndexedDB:
     130        return "IndexedDB"_s;
     131    default:
     132        break;
     133    }
     134    ASSERT_NOT_REACHED();
     135    return emptyString();
     136}
     137
     138String OriginStorageManager::StorageBucket::typeStoragePath(StorageType type) const
     139{
     140    auto storageIdentifier = toStorageIdentifier(type);
     141    if (m_rootPath.isEmpty() || storageIdentifier.isEmpty())
     142        return emptyString();
     143
     144    return FileSystem::pathByAppendingComponent(m_rootPath, storageIdentifier);
     145}
     146
     147FileSystemStorageManager& OriginStorageManager::StorageBucket::fileSystemStorageManager(FileSystemStorageHandleRegistry& registry)
     148{
     149    if (!m_fileSystemStorageManager)
     150        m_fileSystemStorageManager = makeUnique<FileSystemStorageManager>(typeStoragePath(StorageType::FileSystem), registry);
     151
     152    return *m_fileSystemStorageManager;
     153}
     154
     155LocalStorageManager& OriginStorageManager::StorageBucket::localStorageManager(StorageAreaRegistry& registry)
     156{
     157    if (!m_localStorageManager)
     158        m_localStorageManager = makeUnique<LocalStorageManager>(resolvedLocalStoragePath(), registry);
     159
     160    return *m_localStorageManager;
     161}
     162
     163SessionStorageManager& OriginStorageManager::StorageBucket::sessionStorageManager(StorageAreaRegistry& registry)
     164{
     165    if (!m_sessionStorageManager)
     166        m_sessionStorageManager = makeUnique<SessionStorageManager>(registry);
     167
     168    return *m_sessionStorageManager;
     169}
     170
     171IDBStorageManager& OriginStorageManager::StorageBucket::idbStorageManager(IDBStorageRegistry& registry, IDBStorageManager::QuotaCheckFunction&& quotaCheckFunction)
     172{
     173    if (!m_idbStorageManager)
     174        m_idbStorageManager = makeUnique<IDBStorageManager>(resolvedIDBStoragePath(), registry, WTFMove(quotaCheckFunction));
     175
     176    return *m_idbStorageManager;
     177}
     178
     179bool OriginStorageManager::StorageBucket::isActive() const
     180{
     181    // We cannot remove the bucket if it has in-memory data, otherwise session
     182    // data may be lost.
     183    return (m_fileSystemStorageManager && m_fileSystemStorageManager->isActive())
     184        || (m_localStorageManager && (m_localStorageManager->hasDataInMemory() || m_localStorageManager->isActive()))
     185        || (m_sessionStorageManager && (m_sessionStorageManager->hasDataInMemory() || m_sessionStorageManager->isActive()))
     186        || (m_idbStorageManager && (m_idbStorageManager->hasDataInMemory() || m_idbStorageManager->isActive()));
     187}
     188
     189bool OriginStorageManager::StorageBucket::isEmpty()
     190{
     191    ASSERT(!RunLoop::isMain());
     192
     193    auto files = FileSystem::listDirectory(m_rootPath);
     194    auto hasValidFile = WTF::anyOf(files, [&](auto file) {
     195        bool isInvalidFile = (file == originFileName);
     196#if PLATFORM(COCOA)
     197        isInvalidFile |= (file == ".DS_Store");
     198#endif
     199        return !isInvalidFile;
     200    });
     201    if (hasValidFile)
     202        return false;
     203
     204    auto idbStorageFiles = FileSystem::listDirectory(resolvedIDBStoragePath());
     205    return !FileSystem::fileExists(resolvedLocalStoragePath()) && idbStorageFiles.isEmpty();
     206}
     207
     208OptionSet<WebsiteDataType> OriginStorageManager::StorageBucket::fetchDataTypesInList(OptionSet<WebsiteDataType> types)
     209{
     210    auto result = fetchDataTypesInListFromMemory(types);
     211    result.add(fetchDataTypesInListFromDisk(types));
     212
     213    return result;
     214}
     215
     216OptionSet<WebsiteDataType> OriginStorageManager::StorageBucket::fetchDataTypesInListFromMemory(OptionSet<WebsiteDataType> types)
     217{
     218    OptionSet<WebsiteDataType> result;
     219    if (types.contains(WebsiteDataType::LocalStorage)) {
     220        if (m_localStorageManager && m_localStorageManager->hasDataInMemory())
     221            result.add(WebsiteDataType::LocalStorage);
     222    }
     223
     224    if (types.contains(WebsiteDataType::SessionStorage)) {
     225        if (m_sessionStorageManager && m_sessionStorageManager->hasDataInMemory())
     226            result.add(WebsiteDataType::SessionStorage);
     227    }
     228
     229    if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
     230        if (m_idbStorageManager && m_idbStorageManager->hasDataInMemory())
     231            result.add(WebsiteDataType::IndexedDBDatabases);
     232    }
     233
     234    return result;
     235}
     236
     237OptionSet<WebsiteDataType> OriginStorageManager::StorageBucket::fetchDataTypesInListFromDisk(OptionSet<WebsiteDataType> types)
     238{
     239    OptionSet<WebsiteDataType> result;
     240    if (types.contains(WebsiteDataType::FileSystem)) {
     241        auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
     242        if (auto files = FileSystem::listDirectory(fileSystemStoragePath); !files.isEmpty())
     243            result.add(WebsiteDataType::FileSystem);
     244    }
     245
     246    if (types.contains(WebsiteDataType::LocalStorage)) {
     247        if (FileSystem::fileExists(resolvedLocalStoragePath()))
     248            result.add(WebsiteDataType::LocalStorage);
     249    }
     250
     251    if (types.contains(WebsiteDataType::IndexedDBDatabases)) {
     252        if (auto databases = FileSystem::listDirectory(resolvedIDBStoragePath()); !databases.isEmpty())
     253            result.add(WebsiteDataType::IndexedDBDatabases);
     254    }
     255
     256    return result;
     257}
     258
     259void OriginStorageManager::StorageBucket::deleteData(OptionSet<WebsiteDataType> types, WallTime modifiedSinceTime)
     260{
     261    if (types.contains(WebsiteDataType::FileSystem))
     262        deleteFileSystemStorageData(modifiedSinceTime);
     263
     264    if (types.contains(WebsiteDataType::LocalStorage))
     265        deleteLocalStorageData(modifiedSinceTime);
     266
     267    if (types.contains(WebsiteDataType::SessionStorage) && modifiedSinceTime < WallTime::now())
     268        deleteSessionStorageData();
     269
     270    if (types.contains(WebsiteDataType::IndexedDBDatabases))
     271        deleteIDBStorageData(modifiedSinceTime);
     272}
     273
     274void OriginStorageManager::StorageBucket::deleteFileSystemStorageData(WallTime modifiedSinceTime)
     275{
     276    m_fileSystemStorageManager = nullptr;
     277
     278    auto fileSystemStoragePath = typeStoragePath(StorageType::FileSystem);
     279    FileSystem::deleteAllFilesModifiedSince(fileSystemStoragePath, modifiedSinceTime);
     280}
     281
     282void OriginStorageManager::StorageBucket::deleteLocalStorageData(WallTime time)
     283{
     284    auto currentLocalStoragePath = resolvedLocalStoragePath();
     285    if (FileSystem::fileModificationTime(currentLocalStoragePath) >= time) {
     286        if (m_localStorageManager)
     287            m_localStorageManager->clearDataOnDisk();
     288        WebCore::SQLiteFileSystem::deleteDatabaseFile(currentLocalStoragePath);
     289    }
     290
     291    if (!m_localStorageManager)
     292        return;
     293
     294    m_localStorageManager->clearDataInMemory();
     295    if (!m_localStorageManager->isActive())
     296        m_localStorageManager = nullptr;
     297}
     298
     299void OriginStorageManager::StorageBucket::deleteSessionStorageData()
     300{
     301    if (!m_sessionStorageManager)
     302        return;
     303
     304    m_sessionStorageManager->clearData();
     305    if (!m_sessionStorageManager->isActive())
     306        m_sessionStorageManager = nullptr;
     307}
     308
     309void OriginStorageManager::StorageBucket::deleteIDBStorageData(WallTime time)
     310{
     311    if (m_idbStorageManager)
     312        m_idbStorageManager->closeDatabasesForDeletion();
     313
     314    FileSystem::deleteAllFilesModifiedSince(resolvedIDBStoragePath(), time);
     315}
     316
     317void OriginStorageManager::StorageBucket::moveData(OptionSet<WebsiteDataType> types, const String& localStoragePath, const String& idbStoragePath)
     318{
     319    // This is only supported for IndexedDB and LocalStorage now.
     320    if (types.contains(WebsiteDataType::LocalStorage) && !localStoragePath.isEmpty()) {
     321        if (m_localStorageManager)
     322            m_localStorageManager->close();
     323
     324        auto currentLocalStoragePath = resolvedLocalStoragePath();
     325        if (!currentLocalStoragePath.isEmpty()) {
     326            FileSystem::makeAllDirectories(FileSystem::parentPath(localStoragePath));
     327            WebCore::SQLiteFileSystem::moveDatabaseFile(currentLocalStoragePath, localStoragePath);
     328        }
     329    }
     330
     331    if (types.contains(WebsiteDataType::IndexedDBDatabases) && !idbStoragePath.isEmpty()) {
     332        if (m_idbStorageManager)
     333            m_idbStorageManager->closeDatabasesForDeletion();
     334
     335        auto currentIDBStoragePath = resolvedIDBStoragePath();
     336        if (!currentIDBStoragePath.isEmpty()) {
     337            FileSystem::makeAllDirectories(FileSystem::parentPath(idbStoragePath));
     338            FileSystem::moveFile(currentIDBStoragePath, idbStoragePath);
     339        }
     340    }
     341}
     342
     343String OriginStorageManager::StorageBucket::resolvedLocalStoragePath()
     344{
     345    if (!m_resolvedLocalStoragePath.isNull())
     346        return m_resolvedLocalStoragePath;
     347
     348    if (m_shouldUseCustomPaths) {
     349        ASSERT(m_customLocalStoragePath.isEmpty() == m_rootPath.isEmpty());
     350        m_resolvedLocalStoragePath = m_customLocalStoragePath;
     351    } else if (!m_rootPath.isEmpty()) {
     352        auto localStorageDirectory = typeStoragePath(StorageType::LocalStorage);
     353        FileSystem::makeAllDirectories(localStorageDirectory);
     354        FileSystem::excludeFromBackup(localStorageDirectory);
     355
     356        auto localStoragePath = LocalStorageManager::localStorageFilePath(localStorageDirectory);
     357        if (!m_customLocalStoragePath.isEmpty() && !FileSystem::fileExists(localStoragePath) && FileSystem::fileExists(m_customLocalStoragePath))
     358            WebCore::SQLiteFileSystem::moveDatabaseFile(m_customLocalStoragePath, localStoragePath);
     359
     360        m_resolvedLocalStoragePath = localStoragePath;
     361    } else
     362        m_resolvedLocalStoragePath = emptyString();
     363
     364    return m_resolvedLocalStoragePath;
     365}
     366
     367String OriginStorageManager::StorageBucket::resolvedIDBStoragePath()
     368{
     369    ASSERT(!RunLoop::isMain());
     370
     371    if (!m_resolvedIDBStoragePath.isNull())
     372        return m_resolvedIDBStoragePath;
     373
     374    if (m_shouldUseCustomPaths) {
     375        ASSERT(m_customIDBStoragePath.isEmpty() == m_rootPath.isEmpty());
     376        m_resolvedIDBStoragePath = m_customIDBStoragePath;
     377    } else {
     378        auto idbStoragePath = typeStoragePath(StorageType::IndexedDB);
     379        IDBStorageManager::migrateOriginData(m_customIDBStoragePath, idbStoragePath);
     380        m_resolvedIDBStoragePath = idbStoragePath;
     381    }
     382   
     383    ASSERT(!m_resolvedIDBStoragePath.isNull());
     384    return m_resolvedIDBStoragePath;
     385}
     386
    392387String OriginStorageManager::originFileIdentifier()
    393388{
Note: See TracChangeset for help on using the changeset viewer.