Changeset 232410 in webkit


Ignore:
Timestamp:
Jun 1, 2018 1:13:08 PM (6 years ago)
Author:
sihui_liu@apple.com
Message:

Stop using StorageTracker.db in LocalStorageDatabaseTracker
https://bugs.webkit.org/show_bug.cgi?id=186104

Reviewed by Geoffrey Garen.

Source/WebCore:

No behavior change.

  • platform/sql/SQLiteFileSystem.h:

Source/WebKit:

Stop using StorageTracker.db and stop caching origins in LocalStorageDatabaseTracker for efficiency
and simplicity. Since functions in LocalStorageDatabaseTracker are not frequently called, we get
little benefits from caching origins.

  • Platform/Logging.h:
  • UIProcess/API/C/WKKeyValueStorageManager.cpp:

(WKKeyValueStorageManagerGetStorageDetailsByOrigin):

  • UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp:

(WebKit::LocalStorageDatabaseTracker::LocalStorageDatabaseTracker):
(WebKit::LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin):
(WebKit::LocalStorageDatabaseTracker::deleteDatabaseWithOrigin):
(WebKit::LocalStorageDatabaseTracker::deleteAllDatabases):
(WebKit::LocalStorageDatabaseTracker::databasesModifiedSince):
(WebKit::LocalStorageDatabaseTracker::origins const):
(WebKit::LocalStorageDatabaseTracker::originDetails):
(WebKit::LocalStorageDatabaseTracker::databasePath const):
(WebKit::fileCreationTime): Deleted.
(WebKit::fileModificationTime): Deleted.
(WebKit::LocalStorageDatabaseTracker::trackerDatabasePath const): Deleted.
(WebKit::LocalStorageDatabaseTracker::openTrackerDatabase): Deleted.
(WebKit::LocalStorageDatabaseTracker::importOriginIdentifiers): Deleted.
(WebKit::LocalStorageDatabaseTracker::updateTrackerDatabaseFromLocalStorageDatabaseFiles): Deleted.
(WebKit::LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier): Deleted.
(WebKit::LocalStorageDatabaseTracker::removeDatabaseWithOriginIdentifier): Deleted.
(WebKit::LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier): Deleted.

  • UIProcess/WebStorage/LocalStorageDatabaseTracker.h:
  • UIProcess/WebStorage/StorageManager.h:
Location:
trunk/Source
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r232394 r232410  
     12018-06-01  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Stop using StorageTracker.db in LocalStorageDatabaseTracker
     4        https://bugs.webkit.org/show_bug.cgi?id=186104
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        No behavior change.
     9
     10        * platform/sql/SQLiteFileSystem.h:
     11
    1122018-06-01  Zalan Bujtas  <zalan@apple.com>
    213
  • trunk/Source/WebCore/platform/sql/SQLiteFileSystem.h

    r218799 r232410  
    5858    // path - The directory.
    5959    // fileName - The file name.
    60     static String appendDatabaseFileNameToPath(const String& path, const String& fileName);
     60    WEBCORE_EXPORT static String appendDatabaseFileNameToPath(const String& path, const String& fileName);
    6161
    6262    // Makes sure the given directory exists, by creating all missing directories
     
    6464    //
    6565    // path - The directory.
    66     static bool ensureDatabaseDirectoryExists(const String& path);
     66    WEBCORE_EXPORT static bool ensureDatabaseDirectoryExists(const String& path);
    6767
    6868    // If 'checkPathOnly' is false, then this method only checks if the given file exists.
     
    9898   
    9999    static long long getDatabaseFileSize(const String& fileName);
    100     static double databaseCreationTime(const String& fileName);
    101     static double databaseModificationTime(const String& fileName);
     100    WEBCORE_EXPORT static double databaseCreationTime(const String& fileName);
     101    WEBCORE_EXPORT static double databaseModificationTime(const String& fileName);
    102102
    103103private:
  • trunk/Source/WebKit/ChangeLog

    r232397 r232410  
     12018-06-01  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Stop using StorageTracker.db in LocalStorageDatabaseTracker
     4        https://bugs.webkit.org/show_bug.cgi?id=186104
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        Stop using StorageTracker.db and stop caching origins in LocalStorageDatabaseTracker for efficiency
     9        and simplicity. Since functions in LocalStorageDatabaseTracker are not frequently called, we get
     10        little benefits from caching origins.
     11
     12        * Platform/Logging.h:
     13        * UIProcess/API/C/WKKeyValueStorageManager.cpp:
     14        (WKKeyValueStorageManagerGetStorageDetailsByOrigin):
     15        * UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp:
     16        (WebKit::LocalStorageDatabaseTracker::LocalStorageDatabaseTracker):
     17        (WebKit::LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin):
     18        (WebKit::LocalStorageDatabaseTracker::deleteDatabaseWithOrigin):
     19        (WebKit::LocalStorageDatabaseTracker::deleteAllDatabases):
     20        (WebKit::LocalStorageDatabaseTracker::databasesModifiedSince):
     21        (WebKit::LocalStorageDatabaseTracker::origins const):
     22        (WebKit::LocalStorageDatabaseTracker::originDetails):
     23        (WebKit::LocalStorageDatabaseTracker::databasePath const):
     24        (WebKit::fileCreationTime): Deleted.
     25        (WebKit::fileModificationTime): Deleted.
     26        (WebKit::LocalStorageDatabaseTracker::trackerDatabasePath const): Deleted.
     27        (WebKit::LocalStorageDatabaseTracker::openTrackerDatabase): Deleted.
     28        (WebKit::LocalStorageDatabaseTracker::importOriginIdentifiers): Deleted.
     29        (WebKit::LocalStorageDatabaseTracker::updateTrackerDatabaseFromLocalStorageDatabaseFiles): Deleted.
     30        (WebKit::LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier): Deleted.
     31        (WebKit::LocalStorageDatabaseTracker::removeDatabaseWithOriginIdentifier): Deleted.
     32        (WebKit::LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier): Deleted.
     33        * UIProcess/WebStorage/LocalStorageDatabaseTracker.h:
     34        * UIProcess/WebStorage/StorageManager.h:
     35
    1362018-06-01  Michael Catanzaro  <mcatanzaro@igalia.com>
    237
  • trunk/Source/WebKit/Platform/Logging.h

    r230834 r232410  
    5353    M(Layers) \
    5454    M(Loading) \
     55    M(LocalStorageDatabaseTracker) \
    5556    M(MouseHandling) \
    5657    M(Network) \
  • trunk/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp

    r229979 r232410  
    103103            detailsMap.set(toImpl(WKKeyValueStorageManagerGetOriginKey())->string(), origin);
    104104            if (originDetails.creationTime)
    105                 detailsMap.set(toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(originDetails.creationTime.value_or(0)));
     105                detailsMap.set(toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(originDetails.creationTime.secondsSinceEpoch().value()));
    106106            if (originDetails.modificationTime)
    107                 detailsMap.set(toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(originDetails.modificationTime.value_or(0)));
     107                detailsMap.set(toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(originDetails.modificationTime.secondsSinceEpoch().value()));
    108108
    109109            result.uncheckedAppend(API::Dictionary::create(WTFMove(detailsMap)));
  • trunk/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp

    r231837 r232410  
    2727#include "LocalStorageDatabaseTracker.h"
    2828
     29#include "Logging.h"
    2930#include <WebCore/FileSystem.h>
    3031#include <WebCore/SQLiteFileSystem.h>
    3132#include <WebCore/SQLiteStatement.h>
    32 #include <WebCore/SecurityOrigin.h>
    33 #include <WebCore/SecurityOriginData.h>
    3433#include <WebCore/TextEncoding.h>
    3534#include <wtf/MainThread.h>
     
    5756
    5857    m_queue->dispatch([protectedThis = makeRef(*this)]() mutable {
    59         protectedThis->importOriginIdentifiers();
     58        // Delete legacy storageTracker database file.
     59        SQLiteFileSystem::deleteDatabaseFile(protectedThis->databasePath("StorageTracker.db"));
    6060    });
    6161}
     
    7272void LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
    7373{
    74     addDatabaseWithOriginIdentifier(securityOrigin.databaseIdentifier(), databasePath(securityOrigin));
     74    // FIXME: Tell clients that the origin was added.
    7575}
    7676
    7777void LocalStorageDatabaseTracker::deleteDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
    7878{
    79     removeDatabaseWithOriginIdentifier(securityOrigin.databaseIdentifier());
     79    auto path = databasePath(securityOrigin);
     80    if (!path.isEmpty())
     81        SQLiteFileSystem::deleteDatabaseFile(path);
     82
     83    // FIXME: Tell clients that the origin was removed.
    8084}
    8185
    8286void LocalStorageDatabaseTracker::deleteAllDatabases()
    8387{
    84     m_origins.clear();
    85 
    86     openTrackerDatabase(SkipIfNonExistent);
    87     if (!m_database.isOpen())
    88         return;
    89 
    90     SQLiteStatement statement(m_database, "SELECT origin, path FROM Origins");
    91     if (statement.prepare() != SQLITE_OK) {
    92         LOG_ERROR("Failed to prepare statement.");
    93         return;
    94     }
    95 
    96     int result;
    97     while ((result = statement.step()) == SQLITE_ROW) {
    98         FileSystem::deleteFile(statement.getColumnText(1));
     88    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
     89    for (auto path : paths) {
     90        SQLiteFileSystem::deleteDatabaseFile(path);
    9991
    10092        // FIXME: Call out to the client.
    10193    }
    10294
    103     if (result != SQLITE_DONE)
    104         LOG_ERROR("Failed to read in all origins from the database.");
    105 
    106     if (m_database.isOpen())
    107         m_database.close();
    108 
    109     if (!FileSystem::deleteFile(trackerDatabasePath())) {
    110         // In the case where it is not possible to delete the database file (e.g some other program
    111         // like a virus scanner is accessing it), make sure to remove all entries.
    112         openTrackerDatabase(SkipIfNonExistent);
    113         if (!m_database.isOpen())
    114             return;
    115 
    116         SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins");
    117         if (deleteStatement.prepare() != SQLITE_OK) {
    118             LOG_ERROR("Unable to prepare deletion of all origins");
    119             return;
    120         }
    121         if (!deleteStatement.executeCommand()) {
    122             LOG_ERROR("Unable to execute deletion of all origins");
    123             return;
    124         }
    125     }
    126 
    127     FileSystem::deleteEmptyDirectory(m_localStorageDirectory);
    128 }
    129 
    130 static std::optional<time_t> fileCreationTime(const String& filePath)
    131 {
    132     time_t time;
    133     return FileSystem::getFileCreationTime(filePath, time) ? time : std::optional<time_t>(std::nullopt);
    134 }
    135 
    136 static std::optional<time_t> fileModificationTime(const String& filePath)
    137 {
    138     time_t time;
    139     if (!FileSystem::getFileModificationTime(filePath, time))
    140         return std::nullopt;
    141 
    142     return time;
     95    SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_localStorageDirectory);
    14396}
    14497
    14598Vector<SecurityOriginData> LocalStorageDatabaseTracker::databasesModifiedSince(WallTime time)
    14699{
    147     ASSERT(!RunLoop::isMain());
    148     importOriginIdentifiers();
    149     Vector<String> originIdentifiersModified;
     100    Vector<SecurityOriginData> databaseOriginsModified;
     101    auto databaseOrigins = origins();
    150102   
    151     for (const String& origin : m_origins) {
    152         String filePath = pathForDatabaseWithOriginIdentifier(origin);
     103    for (auto origin : databaseOrigins) {
     104        auto path = databasePath(origin);
    153105       
    154         auto modificationTime = FileSystem::getFileModificationTime(filePath);
    155         if (!modificationTime || modificationTime.value() >= time)
    156             originIdentifiersModified.append(origin);
     106        auto modificationTime = WallTime::fromRawSeconds(SQLiteFileSystem::databaseModificationTime(path));
     107        if (modificationTime >= time)
     108            databaseOriginsModified.append(origin);
    157109    }
    158    
    159     Vector<SecurityOriginData> databaseOriginsModified;
    160     databaseOriginsModified.reserveInitialCapacity(originIdentifiersModified.size());
    161    
    162     for (const auto& originIdentifier : originIdentifiersModified) {
    163         if (auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier))
    164             databaseOriginsModified.uncheckedAppend(*origin);
    165         else
    166             ASSERT_NOT_REACHED();
    167     }
    168    
     110
    169111    return databaseOriginsModified;
    170112}
     
    172114Vector<SecurityOriginData> LocalStorageDatabaseTracker::origins() const
    173115{
    174     Vector<SecurityOriginData> origins;
    175     origins.reserveInitialCapacity(m_origins.size());
    176 
    177     for (const String& originIdentifier : m_origins) {
    178         if (auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier))
    179             origins.uncheckedAppend(*origin);
     116    Vector<SecurityOriginData> databaseOrigins;
     117    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
     118   
     119    for (auto path : paths) {
     120        auto filename = FileSystem::pathGetFileName(path);
     121        auto originIdentifier = filename.substring(0, filename.length() - strlen(".localstorage"));
     122        auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier);
     123        if (origin)
     124            databaseOrigins.append(origin.value());
    180125        else
    181             ASSERT_NOT_REACHED();
     126            RELEASE_LOG_ERROR(LocalStorageDatabaseTracker, "Unable to extract origin from path %s", path.utf8().data());
    182127    }
    183128
    184     return origins;
     129    return databaseOrigins;
    185130}
    186131
     
    188133{
    189134    Vector<OriginDetails> result;
    190     result.reserveInitialCapacity(m_origins.size());
     135    auto databaseOrigins = origins();
     136    result.reserveInitialCapacity(databaseOrigins.size());
    191137
    192     for (const String& origin : m_origins) {
    193         String filePath = pathForDatabaseWithOriginIdentifier(origin);
     138    for (auto origin : databaseOrigins) {
     139        String path = databasePath(origin);
    194140
    195141        OriginDetails details;
    196         details.originIdentifier = origin.isolatedCopy();
    197         details.creationTime = fileCreationTime(filePath);
    198         details.modificationTime = fileModificationTime(filePath);
     142        details.originIdentifier = origin.databaseIdentifier();
     143        details.creationTime = WallTime::fromRawSeconds(SQLiteFileSystem::databaseCreationTime(path));
     144        details.modificationTime = WallTime::fromRawSeconds(SQLiteFileSystem::databaseModificationTime(path));
    199145        result.uncheckedAppend(details);
    200146    }
     
    205151String LocalStorageDatabaseTracker::databasePath(const String& filename) const
    206152{
    207     if (!FileSystem::makeAllDirectories(m_localStorageDirectory)) {
     153    if (!SQLiteFileSystem::ensureDatabaseDirectoryExists(m_localStorageDirectory)) {
    208154        LOG_ERROR("Unable to create LocalStorage database path %s", m_localStorageDirectory.utf8().data());
    209155        return String();
     
    214160#endif
    215161
    216     return FileSystem::pathByAppendingComponent(m_localStorageDirectory, filename);
    217 }
    218 
    219 String LocalStorageDatabaseTracker::trackerDatabasePath() const
    220 {
    221     return databasePath("StorageTracker.db");
    222 }
    223 
    224 void LocalStorageDatabaseTracker::openTrackerDatabase(DatabaseOpeningStrategy openingStrategy)
    225 {
    226     if (m_database.isOpen())
    227         return;
    228 
    229     String databasePath = trackerDatabasePath();
    230 
    231     if (!FileSystem::fileExists(databasePath) && openingStrategy == SkipIfNonExistent)
    232         return;
    233 
    234     if (!m_database.open(databasePath)) {
    235         LOG_ERROR("Failed to open databasePath %s.", databasePath.ascii().data());
    236         return;
    237     }
    238 
    239     // Since a WorkQueue isn't bound to a specific thread, we have to disable threading checks
    240     // even though we never access the database from different threads simultaneously.
    241     m_database.disableThreadingChecks();
    242 
    243     if (m_database.tableExists("Origins"))
    244         return;
    245 
    246     if (!m_database.executeCommand("CREATE TABLE Origins (origin TEXT UNIQUE ON CONFLICT REPLACE, path TEXT);"))
    247         LOG_ERROR("Failed to create Origins table.");
    248 }
    249 
    250 void LocalStorageDatabaseTracker::importOriginIdentifiers()
    251 {
    252     openTrackerDatabase(SkipIfNonExistent);
    253 
    254     if (m_database.isOpen()) {
    255         SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
    256         if (statement.prepare() != SQLITE_OK) {
    257             LOG_ERROR("Failed to prepare statement.");
    258             return;
    259         }
    260 
    261         int result;
    262 
    263         while ((result = statement.step()) == SQLITE_ROW)
    264             m_origins.add(statement.getColumnText(0));
    265 
    266         if (result != SQLITE_DONE) {
    267             LOG_ERROR("Failed to read in all origins from the database.");
    268             return;
    269         }
    270     }
    271 
    272     updateTrackerDatabaseFromLocalStorageDatabaseFiles();
    273 }
    274 
    275 void LocalStorageDatabaseTracker::updateTrackerDatabaseFromLocalStorageDatabaseFiles()
    276 {
    277     Vector<String> paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
    278 
    279     HashSet<String> origins(m_origins);
    280     HashSet<String> originsFromLocalStorageDatabaseFiles;
    281 
    282     for (size_t i = 0; i < paths.size(); ++i) {
    283         const String& path = paths[i];
    284 
    285         if (!path.endsWith(".localstorage"))
    286             continue;
    287 
    288         String filename = FileSystem::pathGetFileName(path);
    289 
    290         String originIdentifier = filename.substring(0, filename.length() - strlen(".localstorage"));
    291 
    292         if (!m_origins.contains(originIdentifier))
    293             addDatabaseWithOriginIdentifier(originIdentifier, path);
    294 
    295         originsFromLocalStorageDatabaseFiles.add(originIdentifier);
    296     }
    297 
    298     for (auto it = origins.begin(), end = origins.end(); it != end; ++it) {
    299         const String& originIdentifier = *it;
    300         if (origins.contains(originIdentifier))
    301             continue;
    302 
    303         removeDatabaseWithOriginIdentifier(originIdentifier);
    304     }
    305 }
    306 
    307 void LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier(const String& originIdentifier, const String& databasePath)
    308 {
    309     openTrackerDatabase(CreateIfNonExistent);
    310     if (!m_database.isOpen())
    311         return;
    312 
    313     SQLiteStatement statement(m_database, "INSERT INTO Origins VALUES (?, ?)");
    314     if (statement.prepare() != SQLITE_OK) {
    315         LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.utf8().data());
    316         return;
    317     }
    318 
    319     statement.bindText(1, originIdentifier);
    320     statement.bindText(2, databasePath);
    321 
    322     if (statement.step() != SQLITE_DONE)
    323         LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.utf8().data());
    324 
    325     m_origins.add(originIdentifier);
    326 
    327     // FIXME: Tell clients that the origin was added.
    328 }
    329 
    330 void LocalStorageDatabaseTracker::removeDatabaseWithOriginIdentifier(const String& originIdentifier)
    331 {
    332     openTrackerDatabase(SkipIfNonExistent);
    333     if (!m_database.isOpen())
    334         return;
    335 
    336     String path = pathForDatabaseWithOriginIdentifier(originIdentifier);
    337     if (path.isEmpty())
    338         return;
    339 
    340     SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins where origin=?");
    341     if (deleteStatement.prepare() != SQLITE_OK) {
    342         LOG_ERROR("Unable to prepare deletion of origin '%s'", originIdentifier.ascii().data());
    343         return;
    344     }
    345     deleteStatement.bindText(1, originIdentifier);
    346     if (!deleteStatement.executeCommand()) {
    347         LOG_ERROR("Unable to execute deletion of origin '%s'", originIdentifier.ascii().data());
    348         return;
    349     }
    350 
    351     SQLiteFileSystem::deleteDatabaseFile(path);
    352 
    353     m_origins.remove(originIdentifier);
    354     if (m_origins.isEmpty()) {
    355         // There are no origins left; delete the tracker database.
    356         m_database.close();
    357         SQLiteFileSystem::deleteDatabaseFile(trackerDatabasePath());
    358         FileSystem::deleteEmptyDirectory(m_localStorageDirectory);
    359     }
    360 
    361     // FIXME: Tell clients that the origin was removed.
    362 }
    363 
    364 String LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier(const String& originIdentifier)
    365 {
    366     if (!m_database.isOpen())
    367         return String();
    368 
    369     SQLiteStatement pathStatement(m_database, "SELECT path FROM Origins WHERE origin=?");
    370     if (pathStatement.prepare() != SQLITE_OK) {
    371         LOG_ERROR("Unable to prepare selection of path for origin '%s'", originIdentifier.utf8().data());
    372         return String();
    373     }
    374 
    375     pathStatement.bindText(1, originIdentifier);
    376 
    377     int result = pathStatement.step();
    378     if (result != SQLITE_ROW)
    379         return String();
    380 
    381     return pathStatement.getColumnText(0);
     162    return SQLiteFileSystem::appendDatabaseFileNameToPath(m_localStorageDirectory, filename);
    382163}
    383164
  • trunk/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h

    r231837 r232410  
    2626#pragma once
    2727
    28 #include <WebCore/SQLiteDatabase.h>
     28#include <WebCore/SecurityOriginData.h>
    2929#include <wtf/HashSet.h>
    3030#include <wtf/Optional.h>
     
    3535#include <wtf/text/StringHash.h>
    3636#include <wtf/text/WTFString.h>
    37 
    38 namespace WebCore {
    39 class SecurityOrigin;
    40 struct SecurityOriginData;
    41 }
    4237
    4338namespace WebKit {
     
    6358    struct OriginDetails {
    6459        String originIdentifier;
    65         std::optional<time_t> creationTime;
    66         std::optional<time_t> modificationTime;
     60        WallTime creationTime;
     61        WallTime modificationTime;
    6762    };
    6863    Vector<OriginDetails> originDetails();
     
    7267
    7368    String databasePath(const String& filename) const;
    74     String trackerDatabasePath() const;
    7569
    7670    enum DatabaseOpeningStrategy {
     
    7872        SkipIfNonExistent
    7973    };
    80     void openTrackerDatabase(DatabaseOpeningStrategy);
    81 
    82     void importOriginIdentifiers();
    83     void updateTrackerDatabaseFromLocalStorageDatabaseFiles();
    84 
    85     void addDatabaseWithOriginIdentifier(const String& originIdentifier, const String& databasePath);
    86     void removeDatabaseWithOriginIdentifier(const String& originIdentifier);
    87     String pathForDatabaseWithOriginIdentifier(const String& originIdentifier);
    8874
    8975    RefPtr<WorkQueue> m_queue;
    9076    String m_localStorageDirectory;
    91 
    92     WebCore::SQLiteDatabase m_database;
    93     HashSet<String> m_origins;
    9477
    9578#if PLATFORM(IOS)
  • trunk/Source/WebKit/UIProcess/WebStorage/StorageManager.h

    r229979 r232410  
    2828#include "Connection.h"
    2929#include "LocalStorageDatabaseTracker.h"
    30 #include <WebCore/SecurityOriginData.h>
    31 #include <WebCore/SecurityOriginHash.h>
    3230#include <wtf/Forward.h>
    3331#include <wtf/Function.h>
Note: See TracChangeset for help on using the changeset viewer.