Attachment 341599 Details for Bug 186104 – Patch

[patch] Patch

bug-186104-20180530133129.patch (text/plain), 22.25 KB, created by Sihui Liu on 2018-05-30 13:31:30 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Sihui Liu

Created: 2018-05-30 13:31:30 PDT

Size: 22.25 KB

patch

obsolete

>Subversion Revision: 232261
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index bc0ea74ecb7dc89c21a3c320b511504c1e2f43df..749da9078baad18daf71fb44000b69c8ed86bf08 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,14 @@
>+2018-05-30  Sihui Liu  <sihui_liu@apple.com>
>+
>+        Stop using StorageTracker.db in LocalStroageDatabaseTracker
>+        https://bugs.webkit.org/show_bug.cgi?id=186104
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No behaviour change.
>+
>+        * platform/sql/SQLiteFileSystem.h:
>+
> 2018-05-29  Nan Wang  <n_wang@apple.com>
> 
>         AX: setValue on contenteditable should preserve whitespace
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 94a926cfb63d335fde6b86dabf848a13b469720d..916a41c59ecd3bbc4fce4d7ec49f738f10e5c9ca 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,40 @@
>+2018-05-30  Sihui Liu  <sihui_liu@apple.com>
>+
>+        Stop using StorageTracker.db in LocalStroageDatabaseTracker
>+        https://bugs.webkit.org/show_bug.cgi?id=186104
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Remove StorageTracker.db from LocalStorageDatabaseTracker for efficiency and simplicity: we could 
>+        compute file path based on origin, so we don't need to maintain a database.
>+
>+        This patch also fixes bugs including not deleting correct database files because StorageTracker.db
>+        stores absolute path and not eliminating correct origins because of typo.
>+
>+        * 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::LocalStorageDatabaseTracker::importOrigins):
>+        (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:
>+
> 2018-05-29  Per Arne Vollan  <pvollan@apple.com>
> 
>         Follow-up fixes after r228907.
>diff --git a/Source/WebCore/platform/sql/SQLiteFileSystem.h b/Source/WebCore/platform/sql/SQLiteFileSystem.h
>index 6a48200ada5dab6b7761f33d9cdf5ec285d4147a..8220f31cd6c79c1fe86dd111e854e27a98c1750f 100644
>--- a/Source/WebCore/platform/sql/SQLiteFileSystem.h
>+++ b/Source/WebCore/platform/sql/SQLiteFileSystem.h
>@@ -57,13 +57,13 @@ public:
>     //
>     // path - The directory.
>     // fileName - The file name.
>-    static String appendDatabaseFileNameToPath(const String& path, const String& fileName);
>+    WEBCORE_EXPORT static String appendDatabaseFileNameToPath(const String& path, const String& fileName);
> 
>     // Makes sure the given directory exists, by creating all missing directories
>     // on the given path.
>     //
>     // path - The directory.
>-    static bool ensureDatabaseDirectoryExists(const String& path);
>+    WEBCORE_EXPORT static bool ensureDatabaseDirectoryExists(const String& path);
> 
>     // If 'checkPathOnly' is false, then this method only checks if the given file exists.
>     // If 'checkPathOnly' is true, then this method makes sure all directories on the
>@@ -97,8 +97,8 @@ public:
> #endif
>     
>     static long long getDatabaseFileSize(const String& fileName);
>-    static double databaseCreationTime(const String& fileName);
>-    static double databaseModificationTime(const String& fileName);
>+    WEBCORE_EXPORT static double databaseCreationTime(const String& fileName);
>+    WEBCORE_EXPORT static double databaseModificationTime(const String& fileName);
> 
> private:
>     // do not instantiate this class
>diff --git a/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp b/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>index 4e39dad82a5225b9d9dd24ef81fa8af753a35b14..391f85e375ef2653a0e241899eb0fd354075418d 100644
>--- a/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>@@ -102,9 +102,9 @@ void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerR
> 
>             detailsMap.set(toImpl(WKKeyValueStorageManagerGetOriginKey())->string(), origin);
>             if (originDetails.creationTime)
>-                detailsMap.set(toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(originDetails.creationTime.value_or(0)));
>+                detailsMap.set(toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(originDetails.creationTime.secondsSinceEpoch().value()));
>             if (originDetails.modificationTime)
>-                detailsMap.set(toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(originDetails.modificationTime.value_or(0)));
>+                detailsMap.set(toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(originDetails.modificationTime.secondsSinceEpoch().value()));
> 
>             result.uncheckedAppend(API::Dictionary::create(WTFMove(detailsMap)));
>         }
>diff --git a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>index ca56d057dec40625c07258e6830e30bb5f60bc42..985b0ee96d6f5cd04127815ad144c7fae90d8d84 100644
>--- a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>+++ b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>@@ -56,7 +56,10 @@ LocalStorageDatabaseTracker::LocalStorageDatabaseTracker(Ref<WorkQueue>&& queue,
>     UTF8Encoding();
> 
>     m_queue->dispatch([protectedThis = makeRef(*this)]() mutable {
>-        protectedThis->importOriginIdentifiers();
>+        protectedThis->importOrigins();
>+        
>+        // Delete legacy storageTracker database file.
>+        SQLiteFileSystem::deleteDatabaseFile(protectedThis->databasePath("StorageTracker.db"));
>     });
> }
> 
>@@ -71,99 +74,48 @@ String LocalStorageDatabaseTracker::databasePath(const SecurityOriginData& secur
> 
> void LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
> {
>-    addDatabaseWithOriginIdentifier(securityOrigin.databaseIdentifier(), databasePath(securityOrigin));
>+    m_origins.add(securityOrigin);
>+
>+    // FIXME: Tell clients that the origin was added.
> }
> 
> void LocalStorageDatabaseTracker::deleteDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
> {
>-    removeDatabaseWithOriginIdentifier(securityOrigin.databaseIdentifier());
>+    m_origins.remove(securityOrigin);
>+
>+    auto path = databasePath(securityOrigin);
>+    if (!path.isEmpty())
>+        SQLiteFileSystem::deleteDatabaseFile(path);
>+
>+    // FIXME: Tell clients that the origin was removed.
> }
> 
> void LocalStorageDatabaseTracker::deleteAllDatabases()
> {
>     m_origins.clear();
>-
>-    openTrackerDatabase(SkipIfNonExistent);
>-    if (!m_database.isOpen())
>-        return;
>-
>-    SQLiteStatement statement(m_database, "SELECT origin, path FROM Origins");
>-    if (statement.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Failed to prepare statement.");
>-        return;
>-    }
>-
>-    int result;
>-    while ((result = statement.step()) == SQLITE_ROW) {
>-        FileSystem::deleteFile(statement.getColumnText(1));
>+    
>+    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
>+    for (auto path : paths) {
>+        SQLiteFileSystem::deleteDatabaseFile(path);
> 
>         // FIXME: Call out to the client.
>     }
> 
>-    if (result != SQLITE_DONE)
>-        LOG_ERROR("Failed to read in all origins from the database.");
>-
>-    if (m_database.isOpen())
>-        m_database.close();
>-
>-    if (!FileSystem::deleteFile(trackerDatabasePath())) {
>-        // In the case where it is not possible to delete the database file (e.g some other program
>-        // like a virus scanner is accessing it), make sure to remove all entries.
>-        openTrackerDatabase(SkipIfNonExistent);
>-        if (!m_database.isOpen())
>-            return;
>-
>-        SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins");
>-        if (deleteStatement.prepare() != SQLITE_OK) {
>-            LOG_ERROR("Unable to prepare deletion of all origins");
>-            return;
>-        }
>-        if (!deleteStatement.executeCommand()) {
>-            LOG_ERROR("Unable to execute deletion of all origins");
>-            return;
>-        }
>-    }
>-
>-    FileSystem::deleteEmptyDirectory(m_localStorageDirectory);
>-}
>-
>-static std::optional<time_t> fileCreationTime(const String& filePath)
>-{
>-    time_t time;
>-    return FileSystem::getFileCreationTime(filePath, time) ? time : std::optional<time_t>(std::nullopt);
>-}
>-
>-static std::optional<time_t> fileModificationTime(const String& filePath)
>-{
>-    time_t time;
>-    if (!FileSystem::getFileModificationTime(filePath, time))
>-        return std::nullopt;
>-
>-    return time;
>+    SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_localStorageDirectory);
> }
> 
> Vector<SecurityOriginData> LocalStorageDatabaseTracker::databasesModifiedSince(WallTime time)
> {
>     ASSERT(!RunLoop::isMain());
>-    importOriginIdentifiers();
>-    Vector<String> originIdentifiersModified;
>-    
>-    for (const String& origin : m_origins) {
>-        String filePath = pathForDatabaseWithOriginIdentifier(origin);
>-        
>-        auto modificationTime = FileSystem::getFileModificationTime(filePath);
>-        if (!modificationTime || modificationTime.value() >= time)
>-            originIdentifiersModified.append(origin);
>-    }
>+    importOrigins();
>     
>     Vector<SecurityOriginData> databaseOriginsModified;
>-    databaseOriginsModified.reserveInitialCapacity(originIdentifiersModified.size());
>     
>-    for (const auto& originIdentifier : originIdentifiersModified) {
>-        if (auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier))
>-            databaseOriginsModified.uncheckedAppend(*origin);
>-        else
>-            ASSERT_NOT_REACHED();
>+    for (auto origin : m_origins) {
>+        auto path = databasePath(origin);
>+        auto modificationTime = WallTime::fromRawSeconds(SQLiteFileSystem::databaseModificationTime(path));
>+        if (modificationTime >= time)
>+            databaseOriginsModified.append(origin);
>     }
>     
>     return databaseOriginsModified;
>@@ -171,17 +123,7 @@ Vector<SecurityOriginData> LocalStorageDatabaseTracker::databasesModifiedSince(W
> 
> Vector<SecurityOriginData> LocalStorageDatabaseTracker::origins() const
> {
>-    Vector<SecurityOriginData> origins;
>-    origins.reserveInitialCapacity(m_origins.size());
>-
>-    for (const String& originIdentifier : m_origins) {
>-        if (auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier))
>-            origins.uncheckedAppend(*origin);
>-        else
>-            ASSERT_NOT_REACHED();
>-    }
>-
>-    return origins;
>+    return copyToVector(m_origins);
> }
> 
> Vector<LocalStorageDatabaseTracker::OriginDetails> LocalStorageDatabaseTracker::originDetails()
>@@ -189,13 +131,13 @@ Vector<LocalStorageDatabaseTracker::OriginDetails> LocalStorageDatabaseTracker::
>     Vector<OriginDetails> result;
>     result.reserveInitialCapacity(m_origins.size());
> 
>-    for (const String& origin : m_origins) {
>-        String filePath = pathForDatabaseWithOriginIdentifier(origin);
>+    for (auto origin : m_origins) {
>+        String path = databasePath(origin);
> 
>         OriginDetails details;
>-        details.originIdentifier = origin.isolatedCopy();
>-        details.creationTime = fileCreationTime(filePath);
>-        details.modificationTime = fileModificationTime(filePath);
>+        details.originIdentifier = origin.databaseIdentifier();
>+        details.creationTime = WallTime::fromRawSeconds(SQLiteFileSystem::databaseCreationTime(path));
>+        details.modificationTime = WallTime::fromRawSeconds(SQLiteFileSystem::databaseModificationTime(path));
>         result.uncheckedAppend(details);
>     }
> 
>@@ -204,7 +146,7 @@ Vector<LocalStorageDatabaseTracker::OriginDetails> LocalStorageDatabaseTracker::
> 
> String LocalStorageDatabaseTracker::databasePath(const String& filename) const
> {
>-    if (!FileSystem::makeAllDirectories(m_localStorageDirectory)) {
>+    if (!SQLiteFileSystem::ensureDatabaseDirectoryExists(m_localStorageDirectory)) {
>         LOG_ERROR("Unable to create LocalStorage database path %s", m_localStorageDirectory.utf8().data());
>         return String();
>     }
>@@ -213,172 +155,23 @@ String LocalStorageDatabaseTracker::databasePath(const String& filename) const
>     platformMaybeExcludeFromBackup();
> #endif
> 
>-    return FileSystem::pathByAppendingComponent(m_localStorageDirectory, filename);
>-}
>-
>-String LocalStorageDatabaseTracker::trackerDatabasePath() const
>-{
>-    return databasePath("StorageTracker.db");
>-}
>-
>-void LocalStorageDatabaseTracker::openTrackerDatabase(DatabaseOpeningStrategy openingStrategy)
>-{
>-    if (m_database.isOpen())
>-        return;
>-
>-    String databasePath = trackerDatabasePath();
>-
>-    if (!FileSystem::fileExists(databasePath) && openingStrategy == SkipIfNonExistent)
>-        return;
>-
>-    if (!m_database.open(databasePath)) {
>-        LOG_ERROR("Failed to open databasePath %s.", databasePath.ascii().data());
>-        return;
>-    }
>-
>-    // Since a WorkQueue isn't bound to a specific thread, we have to disable threading checks
>-    // even though we never access the database from different threads simultaneously.
>-    m_database.disableThreadingChecks();
>-
>-    if (m_database.tableExists("Origins"))
>-        return;
>-
>-    if (!m_database.executeCommand("CREATE TABLE Origins (origin TEXT UNIQUE ON CONFLICT REPLACE, path TEXT);"))
>-        LOG_ERROR("Failed to create Origins table.");
>+    return SQLiteFileSystem::appendDatabaseFileNameToPath(m_localStorageDirectory, filename);
> }
> 
>-void LocalStorageDatabaseTracker::importOriginIdentifiers()
>+void LocalStorageDatabaseTracker::importOrigins()
> {
>-    openTrackerDatabase(SkipIfNonExistent);
>-
>-    if (m_database.isOpen()) {
>-        SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
>-        if (statement.prepare() != SQLITE_OK) {
>-            LOG_ERROR("Failed to prepare statement.");
>-            return;
>-        }
>-
>-        int result;
>-
>-        while ((result = statement.step()) == SQLITE_ROW)
>-            m_origins.add(statement.getColumnText(0));
>-
>-        if (result != SQLITE_DONE) {
>-            LOG_ERROR("Failed to read in all origins from the database.");
>-            return;
>-        }
>-    }
>-
>-    updateTrackerDatabaseFromLocalStorageDatabaseFiles();
>-}
>-
>-void LocalStorageDatabaseTracker::updateTrackerDatabaseFromLocalStorageDatabaseFiles()
>-{
>-    Vector<String> paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
>-
>-    HashSet<String> origins(m_origins);
>-    HashSet<String> originsFromLocalStorageDatabaseFiles;
>-
>-    for (size_t i = 0; i < paths.size(); ++i) {
>-        const String& path = paths[i];
>-
>+    m_origins.clear();
>+    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
>+    for (auto path : paths) {
>         if (!path.endsWith(".localstorage"))
>             continue;
>-
>-        String filename = FileSystem::pathGetFileName(path);
>-
>-        String originIdentifier = filename.substring(0, filename.length() - strlen(".localstorage"));
>-
>-        if (!m_origins.contains(originIdentifier))
>-            addDatabaseWithOriginIdentifier(originIdentifier, path);
>-
>-        originsFromLocalStorageDatabaseFiles.add(originIdentifier);
>-    }
>-
>-    for (auto it = origins.begin(), end = origins.end(); it != end; ++it) {
>-        const String& originIdentifier = *it;
>-        if (origins.contains(originIdentifier))
>-            continue;
>-
>-        removeDatabaseWithOriginIdentifier(originIdentifier);
>-    }
>-}
>-
>-void LocalStorageDatabaseTracker::addDatabaseWithOriginIdentifier(const String& originIdentifier, const String& databasePath)
>-{
>-    openTrackerDatabase(CreateIfNonExistent);
>-    if (!m_database.isOpen())
>-        return;
>-
>-    SQLiteStatement statement(m_database, "INSERT INTO Origins VALUES (?, ?)");
>-    if (statement.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.utf8().data());
>-        return;
>-    }
>-
>-    statement.bindText(1, originIdentifier);
>-    statement.bindText(2, databasePath);
>-
>-    if (statement.step() != SQLITE_DONE)
>-        LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.utf8().data());
>-
>-    m_origins.add(originIdentifier);
>-
>-    // FIXME: Tell clients that the origin was added.
>-}
>-
>-void LocalStorageDatabaseTracker::removeDatabaseWithOriginIdentifier(const String& originIdentifier)
>-{
>-    openTrackerDatabase(SkipIfNonExistent);
>-    if (!m_database.isOpen())
>-        return;
>-
>-    String path = pathForDatabaseWithOriginIdentifier(originIdentifier);
>-    if (path.isEmpty())
>-        return;
>-
>-    SQLiteStatement deleteStatement(m_database, "DELETE FROM Origins where origin=?");
>-    if (deleteStatement.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Unable to prepare deletion of origin '%s'", originIdentifier.ascii().data());
>-        return;
>-    }
>-    deleteStatement.bindText(1, originIdentifier);
>-    if (!deleteStatement.executeCommand()) {
>-        LOG_ERROR("Unable to execute deletion of origin '%s'", originIdentifier.ascii().data());
>-        return;
>-    }
>-
>-    SQLiteFileSystem::deleteDatabaseFile(path);
>-
>-    m_origins.remove(originIdentifier);
>-    if (m_origins.isEmpty()) {
>-        // There are no origins left; delete the tracker database.
>-        m_database.close();
>-        SQLiteFileSystem::deleteDatabaseFile(trackerDatabasePath());
>-        FileSystem::deleteEmptyDirectory(m_localStorageDirectory);
>-    }
>-
>-    // FIXME: Tell clients that the origin was removed.
>-}
>-
>-String LocalStorageDatabaseTracker::pathForDatabaseWithOriginIdentifier(const String& originIdentifier)
>-{
>-    if (!m_database.isOpen())
>-        return String();
>-
>-    SQLiteStatement pathStatement(m_database, "SELECT path FROM Origins WHERE origin=?");
>-    if (pathStatement.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Unable to prepare selection of path for origin '%s'", originIdentifier.utf8().data());
>-        return String();
>+        
>+        auto filename = FileSystem::pathGetFileName(path);
>+        auto originIdentifier = filename.substring(0, filename.length() - strlen(".localstorage"));
>+        auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier);
>+        if (origin)
>+            m_origins.add(origin.value());
>     }
>-
>-    pathStatement.bindText(1, originIdentifier);
>-
>-    int result = pathStatement.step();
>-    if (result != SQLITE_ROW)
>-        return String();
>-
>-    return pathStatement.getColumnText(0);
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h
>index 63de96f69c2eb4054e12a61409d3572ba8aad565..be9746943bdac7650caff91d479fa32ad98cb293 100644
>--- a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h
>+++ b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h
>@@ -25,7 +25,7 @@
> 
> #pragma once
> 
>-#include <WebCore/SQLiteDatabase.h>
>+#include <WebCore/SecurityOriginData.h>
> #include <wtf/HashSet.h>
> #include <wtf/Optional.h>
> #include <wtf/RefPtr.h>
>@@ -35,11 +35,6 @@
> #include <wtf/text/StringHash.h>
> #include <wtf/text/WTFString.h>
> 
>-namespace WebCore {
>-class SecurityOrigin;
>-struct SecurityOriginData;
>-}
>-
> namespace WebKit {
> 
> struct LocalStorageDetails;
>@@ -62,8 +57,8 @@ public:
> 
>     struct OriginDetails {
>         String originIdentifier;
>-        std::optional<time_t> creationTime;
>-        std::optional<time_t> modificationTime;
>+        WallTime creationTime;
>+        WallTime modificationTime;
>     };
>     Vector<OriginDetails> originDetails();
> 
>@@ -71,26 +66,19 @@ private:
>     LocalStorageDatabaseTracker(Ref<WorkQueue>&&, const String& localStorageDirectory);
> 
>     String databasePath(const String& filename) const;
>-    String trackerDatabasePath() const;
> 
>     enum DatabaseOpeningStrategy {
>         CreateIfNonExistent,
>         SkipIfNonExistent
>     };
>-    void openTrackerDatabase(DatabaseOpeningStrategy);
>-
>-    void importOriginIdentifiers();
>-    void updateTrackerDatabaseFromLocalStorageDatabaseFiles();
> 
>-    void addDatabaseWithOriginIdentifier(const String& originIdentifier, const String& databasePath);
>-    void removeDatabaseWithOriginIdentifier(const String& originIdentifier);
>-    String pathForDatabaseWithOriginIdentifier(const String& originIdentifier);
>+    void importOrigins();
>+    void updateOriginsFromLocalStorageDatabaseFiles();
> 
>     RefPtr<WorkQueue> m_queue;
>     String m_localStorageDirectory;
> 
>-    WebCore::SQLiteDatabase m_database;
>-    HashSet<String> m_origins;
>+    HashSet<WebCore::SecurityOriginData> m_origins;
> 
> #if PLATFORM(IOS)
>     void platformMaybeExcludeFromBackup() const;
>diff --git a/Source/WebKit/UIProcess/WebStorage/StorageManager.h b/Source/WebKit/UIProcess/WebStorage/StorageManager.h
>index 8423b99345f8d911707e0f8b5c5fe6ad040e2337..b6ba0aa5648bb4cfb44c6af23b23bbcf540c7b03 100644
>--- a/Source/WebKit/UIProcess/WebStorage/StorageManager.h
>+++ b/Source/WebKit/UIProcess/WebStorage/StorageManager.h
>@@ -27,8 +27,6 @@
> 
> #include "Connection.h"
> #include "LocalStorageDatabaseTracker.h"
>-#include <WebCore/SecurityOriginData.h>
>-#include <WebCore/SecurityOriginHash.h>
> #include <wtf/Forward.h>
> #include <wtf/Function.h>
> #include <wtf/HashSet.h>

Actions: View | Formatted Diff | Diff

Attachments on bug 186104: 341588 | 341597 | 341599 | 341624