Modern IDB: Rename some "UniqueIDBDatabase" classes that conflict with new classes...
authorbeidson@apple.com <beidson@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 18 Feb 2016 01:25:21 +0000 (01:25 +0000)
committerbeidson@apple.com <beidson@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 18 Feb 2016 01:25:21 +0000 (01:25 +0000)
https://bugs.webkit.org/show_bug.cgi?id=154363.

Reviewed by Alex Christensen.

Adding "Legacy" to the front of the name fixes problems for now.

And all of this gunk will go away after Modern IDB is done, anyways.

* CMakeLists.txt:
* DatabaseProcess/DatabaseProcess.cpp:
(WebKit::DatabaseProcess::getOrCreateLegacyUniqueIDBDatabase):
(WebKit::DatabaseProcess::removeLegacyUniqueIDBDatabase):
(WebKit::DatabaseProcess::getOrCreateUniqueIDBDatabase): Deleted.
(WebKit::DatabaseProcess::removeUniqueIDBDatabase): Deleted.
* DatabaseProcess/DatabaseProcess.h:
* DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp:
(WebKit::DatabaseProcessIDBConnection::establishConnection):
* DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h:
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp.
(WebKit::LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename):
(WebKit::LegacyUniqueIDBDatabase::LegacyUniqueIDBDatabase):
(WebKit::LegacyUniqueIDBDatabase::~LegacyUniqueIDBDatabase):
(WebKit::LegacyUniqueIDBDatabase::filenameForDatabaseName):
(WebKit::LegacyUniqueIDBDatabase::databaseFilenameIdentifier):
(WebKit::LegacyUniqueIDBDatabase::canShareDatabases):
(WebKit::LegacyUniqueIDBDatabase::registerConnection):
(WebKit::LegacyUniqueIDBDatabase::unregisterConnection):
(WebKit::LegacyUniqueIDBDatabase::shutdown):
(WebKit::LegacyUniqueIDBDatabase::shutdownBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didShutdownBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteDatabase):
(WebKit::LegacyUniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata):
(WebKit::LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata):
(WebKit::LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata):
(WebKit::LegacyUniqueIDBDatabase::openTransaction):
(WebKit::LegacyUniqueIDBDatabase::beginTransaction):
(WebKit::LegacyUniqueIDBDatabase::commitTransaction):
(WebKit::LegacyUniqueIDBDatabase::resetTransaction):
(WebKit::LegacyUniqueIDBDatabase::rollbackTransaction):
(WebKit::LegacyUniqueIDBDatabase::postTransactionOperation):
(WebKit::LegacyUniqueIDBDatabase::didCompleteTransactionOperation):
(WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersion):
(WebKit::LegacyUniqueIDBDatabase::didChangeDatabaseVersion):
(WebKit::LegacyUniqueIDBDatabase::didCreateObjectStore):
(WebKit::LegacyUniqueIDBDatabase::didDeleteObjectStore):
(WebKit::LegacyUniqueIDBDatabase::didClearObjectStore):
(WebKit::LegacyUniqueIDBDatabase::didCreateIndex):
(WebKit::LegacyUniqueIDBDatabase::didDeleteIndex):
(WebKit::LegacyUniqueIDBDatabase::didCompleteBoolRequest):
(WebKit::LegacyUniqueIDBDatabase::createObjectStore):
(WebKit::LegacyUniqueIDBDatabase::deleteObjectStore):
(WebKit::LegacyUniqueIDBDatabase::clearObjectStore):
(WebKit::LegacyUniqueIDBDatabase::createIndex):
(WebKit::LegacyUniqueIDBDatabase::deleteIndex):
(WebKit::LegacyUniqueIDBDatabase::putRecord):
(WebKit::LegacyUniqueIDBDatabase::getRecord):
(WebKit::LegacyUniqueIDBDatabase::openCursor):
(WebKit::LegacyUniqueIDBDatabase::cursorAdvance):
(WebKit::LegacyUniqueIDBDatabase::cursorIterate):
(WebKit::LegacyUniqueIDBDatabase::count):
(WebKit::LegacyUniqueIDBDatabase::deleteRange):
(WebKit::LegacyUniqueIDBDatabase::openBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::beginBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::commitBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::resetBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction):
(WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::createObjectStoreInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::createIndexInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteIndexInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::putRecordInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didPutRecordInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::getRecordFromBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didGetRecordFromBackingStore):
(WebKit::LegacyUniqueIDBDatabase::openCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didOpenCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::advanceCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::iterateCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didIterateCursorInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::countInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didCountInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::deleteRangeInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore):
(WebKit::LegacyUniqueIDBDatabase::didEstablishTransaction):
(WebKit::LegacyUniqueIDBDatabase::didResetTransaction):
(WebKit::LegacyUniqueIDBDatabase::resetAllTransactions):
(WebKit::LegacyUniqueIDBDatabase::finalizeRollback):
(WebKit::LegacyUniqueIDBDatabase::absoluteDatabaseDirectory):
(WebKit::LegacyUniqueIDBDatabase::postMainThreadTask):
(WebKit::LegacyUniqueIDBDatabase::performNextMainThreadTask):
(WebKit::LegacyUniqueIDBDatabase::postDatabaseTask):
(WebKit::LegacyUniqueIDBDatabase::performNextDatabaseTask):
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h.
(WebKit::LegacyUniqueIDBDatabase::create):
(WebKit::LegacyUniqueIDBDatabase::identifier):
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp.
(WebKit::LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::isHashTableDeletedValue):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::hash):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::isNull):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::isolatedCopy):
(WebKit::operator==):
* DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h.
(WebKit::LegacyUniqueIDBDatabaseIdentifier::databaseName):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::openingOrigin):
(WebKit::LegacyUniqueIDBDatabaseIdentifier::mainFrameOrigin):
(WebKit::LegacyUniqueIDBDatabaseIdentifierHash::hash):
(WebKit::LegacyUniqueIDBDatabaseIdentifierHash::equal):
(WebKit::LegacyUniqueIDBDatabaseIdentifierHashTraits::isEmptyValue):
* DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite):
(WebKit::UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata):
* DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h:
* Shared/WebCrossThreadCopier.cpp:
(WebCore::LegacyUniqueIDBDatabaseIdentifier>::copy):
(WebCore::UniqueIDBDatabaseIdentifier>::copy): Deleted.
* Shared/WebCrossThreadCopier.h:
* WebKit2.xcodeproj/project.pbxproj:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@196735 268f45cc-cd09-0410-ab3c-d52691b4dbfc

15 files changed:
Source/WebKit2/CMakeLists.txt
Source/WebKit2/ChangeLog
Source/WebKit2/DatabaseProcess/DatabaseProcess.cpp
Source/WebKit2/DatabaseProcess/DatabaseProcess.h
Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp
Source/WebKit2/DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h
Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp [moved from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp with 59% similarity]
Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h [moved from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h with 92% similarity]
Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp [moved from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp with 76% similarity]
Source/WebKit2/DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h [moved from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h with 62% similarity]
Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp
Source/WebKit2/DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h
Source/WebKit2/Shared/WebCrossThreadCopier.cpp
Source/WebKit2/Shared/WebCrossThreadCopier.h
Source/WebKit2/WebKit2.xcodeproj/project.pbxproj

index 2af27b6..3c98fa8 100644 (file)
@@ -196,8 +196,8 @@ set(WebKit2_SOURCES
 
     DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp
     DatabaseProcess/IndexedDB/IDBSerialization.cpp
-    DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp
-    DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp
+    DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp
+    DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp
     DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp
 
     DatabaseProcess/IndexedDB/sqlite/SQLiteIDBCursor.cpp
index e6c6574..6e7af28 100644 (file)
@@ -1,3 +1,128 @@
+2016-02-17  Brady Eidson  <beidson@apple.com>
+
+        Modern IDB: Rename some "UniqueIDBDatabase" classes that conflict with new classes in WebCore.
+        https://bugs.webkit.org/show_bug.cgi?id=154363.
+
+        Reviewed by Alex Christensen.
+
+        Adding "Legacy" to the front of the name fixes problems for now.
+        
+        And all of this gunk will go away after Modern IDB is done, anyways.
+        
+        * CMakeLists.txt:
+        * DatabaseProcess/DatabaseProcess.cpp:
+        (WebKit::DatabaseProcess::getOrCreateLegacyUniqueIDBDatabase):
+        (WebKit::DatabaseProcess::removeLegacyUniqueIDBDatabase):
+        (WebKit::DatabaseProcess::getOrCreateUniqueIDBDatabase): Deleted.
+        (WebKit::DatabaseProcess::removeUniqueIDBDatabase): Deleted.
+        * DatabaseProcess/DatabaseProcess.h:
+        * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.cpp:
+        (WebKit::DatabaseProcessIDBConnection::establishConnection):
+        * DatabaseProcess/IndexedDB/DatabaseProcessIDBConnection.h:
+        * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp.
+        (WebKit::LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename):
+        (WebKit::LegacyUniqueIDBDatabase::LegacyUniqueIDBDatabase):
+        (WebKit::LegacyUniqueIDBDatabase::~LegacyUniqueIDBDatabase):
+        (WebKit::LegacyUniqueIDBDatabase::filenameForDatabaseName):
+        (WebKit::LegacyUniqueIDBDatabase::databaseFilenameIdentifier):
+        (WebKit::LegacyUniqueIDBDatabase::canShareDatabases):
+        (WebKit::LegacyUniqueIDBDatabase::registerConnection):
+        (WebKit::LegacyUniqueIDBDatabase::unregisterConnection):
+        (WebKit::LegacyUniqueIDBDatabase::shutdown):
+        (WebKit::LegacyUniqueIDBDatabase::shutdownBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didShutdownBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::deleteDatabase):
+        (WebKit::LegacyUniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata):
+        (WebKit::LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata):
+        (WebKit::LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata):
+        (WebKit::LegacyUniqueIDBDatabase::openTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::beginTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::commitTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::resetTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::rollbackTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::postTransactionOperation):
+        (WebKit::LegacyUniqueIDBDatabase::didCompleteTransactionOperation):
+        (WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersion):
+        (WebKit::LegacyUniqueIDBDatabase::didChangeDatabaseVersion):
+        (WebKit::LegacyUniqueIDBDatabase::didCreateObjectStore):
+        (WebKit::LegacyUniqueIDBDatabase::didDeleteObjectStore):
+        (WebKit::LegacyUniqueIDBDatabase::didClearObjectStore):
+        (WebKit::LegacyUniqueIDBDatabase::didCreateIndex):
+        (WebKit::LegacyUniqueIDBDatabase::didDeleteIndex):
+        (WebKit::LegacyUniqueIDBDatabase::didCompleteBoolRequest):
+        (WebKit::LegacyUniqueIDBDatabase::createObjectStore):
+        (WebKit::LegacyUniqueIDBDatabase::deleteObjectStore):
+        (WebKit::LegacyUniqueIDBDatabase::clearObjectStore):
+        (WebKit::LegacyUniqueIDBDatabase::createIndex):
+        (WebKit::LegacyUniqueIDBDatabase::deleteIndex):
+        (WebKit::LegacyUniqueIDBDatabase::putRecord):
+        (WebKit::LegacyUniqueIDBDatabase::getRecord):
+        (WebKit::LegacyUniqueIDBDatabase::openCursor):
+        (WebKit::LegacyUniqueIDBDatabase::cursorAdvance):
+        (WebKit::LegacyUniqueIDBDatabase::cursorIterate):
+        (WebKit::LegacyUniqueIDBDatabase::count):
+        (WebKit::LegacyUniqueIDBDatabase::deleteRange):
+        (WebKit::LegacyUniqueIDBDatabase::openBackingStoreTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::beginBackingStoreTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::commitBackingStoreTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::resetBackingStoreTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::createObjectStoreInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::createIndexInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::deleteIndexInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::putRecordInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didPutRecordInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::getRecordFromBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didGetRecordFromBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::openCursorInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didOpenCursorInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::advanceCursorInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::iterateCursorInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didIterateCursorInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::countInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didCountInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::deleteRangeInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore):
+        (WebKit::LegacyUniqueIDBDatabase::didEstablishTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::didResetTransaction):
+        (WebKit::LegacyUniqueIDBDatabase::resetAllTransactions):
+        (WebKit::LegacyUniqueIDBDatabase::finalizeRollback):
+        (WebKit::LegacyUniqueIDBDatabase::absoluteDatabaseDirectory):
+        (WebKit::LegacyUniqueIDBDatabase::postMainThreadTask):
+        (WebKit::LegacyUniqueIDBDatabase::performNextMainThreadTask):
+        (WebKit::LegacyUniqueIDBDatabase::postDatabaseTask):
+        (WebKit::LegacyUniqueIDBDatabase::performNextDatabaseTask):
+        * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabase.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.h.
+        (WebKit::LegacyUniqueIDBDatabase::create):
+        (WebKit::LegacyUniqueIDBDatabase::identifier):
+        * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.cpp: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.cpp.
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::isHashTableDeletedValue):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::hash):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::isNull):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::isolatedCopy):
+        (WebKit::operator==):
+        * DatabaseProcess/IndexedDB/LegacyUniqueIDBDatabaseIdentifier.h: Renamed from Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabaseIdentifier.h.
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::databaseName):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::openingOrigin):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifier::mainFrameOrigin):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifierHash::hash):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifierHash::equal):
+        (WebKit::LegacyUniqueIDBDatabaseIdentifierHashTraits::isEmptyValue):
+        * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.cpp:
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite):
+        (WebKit::UniqueIDBDatabaseBackingStoreSQLite::getOrEstablishMetadata):
+        * DatabaseProcess/IndexedDB/sqlite/UniqueIDBDatabaseBackingStoreSQLite.h:
+        * Shared/WebCrossThreadCopier.cpp:
+        (WebCore::LegacyUniqueIDBDatabaseIdentifier>::copy):
+        (WebCore::UniqueIDBDatabaseIdentifier>::copy): Deleted.
+        * Shared/WebCrossThreadCopier.h:
+        * WebKit2.xcodeproj/project.pbxproj:
+
 2016-02-17  Anders Carlsson  <andersca@apple.com>
 
         Remove WebContextSupplement::shouldTerminate, it's no longer used
index fa340b2..0c5d928 100644 (file)
@@ -32,7 +32,7 @@
 #include "DatabaseProcessMessages.h"
 #include "DatabaseProcessProxyMessages.h"
 #include "DatabaseToWebProcessConnection.h"
-#include "UniqueIDBDatabase.h"
+#include "LegacyUniqueIDBDatabase.h"
 #include "WebCrossThreadCopier.h"
 #include "WebsiteData.h"
 #include <WebCore/CrossThreadTask.h>
@@ -96,21 +96,21 @@ void DatabaseProcess::didReceiveInvalidMessage(IPC::Connection&, IPC::StringRefe
 }
 
 #if ENABLE(INDEXED_DATABASE)
-RefPtr<UniqueIDBDatabase> DatabaseProcess::getOrCreateUniqueIDBDatabase(const UniqueIDBDatabaseIdentifier& identifier)
+RefPtr<LegacyUniqueIDBDatabase> DatabaseProcess::getOrCreateLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier& identifier)
 {
     auto addResult = m_idbDatabases.add(identifier, nullptr);
 
     if (!addResult.isNewEntry)
         return addResult.iterator->value;
 
-    RefPtr<UniqueIDBDatabase> database = UniqueIDBDatabase::create(identifier);
+    RefPtr<LegacyUniqueIDBDatabase> database = LegacyUniqueIDBDatabase::create(identifier);
     addResult.iterator->value = database.get();
     return database;
 }
 
-void DatabaseProcess::removeUniqueIDBDatabase(const UniqueIDBDatabase& database)
+void DatabaseProcess::removeLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabase& database)
 {
-    const UniqueIDBDatabaseIdentifier& identifier = database.identifier();
+    const LegacyUniqueIDBDatabaseIdentifier& identifier = database.identifier();
     ASSERT(m_idbDatabases.contains(identifier));
 
     m_idbDatabases.remove(identifier);
index c2ff0e6..f7430d5 100644 (file)
@@ -29,7 +29,7 @@
 #if ENABLE(DATABASE_PROCESS)
 
 #include "ChildProcess.h"
-#include "UniqueIDBDatabaseIdentifier.h"
+#include "LegacyUniqueIDBDatabaseIdentifier.h"
 #include <wtf/NeverDestroyed.h>
 
 namespace WebCore {
@@ -41,7 +41,7 @@ struct SecurityOriginData;
 namespace WebKit {
 
 class DatabaseToWebProcessConnection;
-class UniqueIDBDatabase;
+class LegacyUniqueIDBDatabase;
 
 struct DatabaseProcessCreationParameters;
 
@@ -55,8 +55,8 @@ public:
 #if ENABLE(INDEXED_DATABASE)
     const String& indexedDatabaseDirectory() const { return m_indexedDatabaseDirectory; }
 
-    RefPtr<UniqueIDBDatabase> getOrCreateUniqueIDBDatabase(const UniqueIDBDatabaseIdentifier&);
-    void removeUniqueIDBDatabase(const UniqueIDBDatabase&);
+    RefPtr<LegacyUniqueIDBDatabase> getOrCreateLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier&);
+    void removeLegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabase&);
 
     void ensureIndexedDatabaseRelativePathExists(const String&);
     String absoluteIndexedDatabasePathFromDatabaseRelativePath(const String&);
@@ -109,7 +109,7 @@ private:
 #if ENABLE(INDEXED_DATABASE)
     String m_indexedDatabaseDirectory;
 
-    HashMap<UniqueIDBDatabaseIdentifier, RefPtr<UniqueIDBDatabase>> m_idbDatabases;
+    HashMap<LegacyUniqueIDBDatabaseIdentifier, RefPtr<LegacyUniqueIDBDatabase>> m_idbDatabases;
 #endif
 
     Deque<std::unique_ptr<WebCore::CrossThreadTask>> m_databaseTasks;
index 5532c3e..328ba91 100644 (file)
@@ -33,7 +33,7 @@
 #include "DatabaseToWebProcessConnection.h"
 #include "IDBIdentifier.h"
 #include "Logging.h"
-#include "UniqueIDBDatabase.h"
+#include "LegacyUniqueIDBDatabase.h"
 #include "WebCoreArgumentCoders.h"
 #include "WebIDBServerConnectionMessages.h"
 #include <WebCore/IDBDatabaseMetadata.h>
@@ -71,7 +71,7 @@ void DatabaseProcessIDBConnection::disconnectedFromWebProcess()
 
 void DatabaseProcessIDBConnection::establishConnection(const String& databaseName, const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin)
 {
-    m_uniqueIDBDatabase = DatabaseProcess::singleton().getOrCreateUniqueIDBDatabase(UniqueIDBDatabaseIdentifier(databaseName, openingOrigin, mainFrameOrigin));
+    m_uniqueIDBDatabase = DatabaseProcess::singleton().getOrCreateLegacyUniqueIDBDatabase(LegacyUniqueIDBDatabaseIdentifier(databaseName, openingOrigin, mainFrameOrigin));
     m_uniqueIDBDatabase->registerConnection(*this);
 }
 
index c51c809..55026e5 100644 (file)
@@ -31,7 +31,7 @@
 #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
 
 #include "DatabaseProcessIDBConnectionMessages.h"
-#include "UniqueIDBDatabaseIdentifier.h"
+#include "LegacyUniqueIDBDatabaseIdentifier.h"
 #include <WebCore/SecurityOriginData.h>
 #include <wtf/text/WTFString.h>
 
@@ -43,7 +43,7 @@ struct IDBKeyRangeData;
 namespace WebKit {
 
 class DatabaseToWebProcessConnection;
-class UniqueIDBDatabase;
+class LegacyUniqueIDBDatabase;
 
 class DatabaseProcessIDBConnection : public RefCounted<DatabaseProcessIDBConnection>, public IPC::MessageSender {
 public:
@@ -99,7 +99,7 @@ private:
     Ref<DatabaseToWebProcessConnection> m_connection;
     uint64_t m_serverConnectionIdentifier;
 
-    RefPtr<UniqueIDBDatabase> m_uniqueIDBDatabase;
+    RefPtr<LegacyUniqueIDBDatabase> m_uniqueIDBDatabase;
 };
 
 } // namespace WebKit
@@ -24,7 +24,7 @@
  */
 
 #include "config.h"
-#include "UniqueIDBDatabase.h"
+#include "LegacyUniqueIDBDatabase.h"
 
 #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
 
@@ -49,12 +49,12 @@ using namespace WebCore;
 
 namespace WebKit {
 
-String UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(const String& absoluteDatabaseDirectory)
+String LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename(const String& absoluteDatabaseDirectory)
 {
     return pathByAppendingComponent(absoluteDatabaseDirectory, "IndexedDB.sqlite3");
 }
 
-UniqueIDBDatabase::UniqueIDBDatabase(const UniqueIDBDatabaseIdentifier& identifier)
+LegacyUniqueIDBDatabase::LegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier& identifier)
     : m_identifier(identifier)
     , m_acceptingNewRequests(true)
     , m_didGetMetadataFromBackingStore(false)
@@ -73,13 +73,13 @@ UniqueIDBDatabase::UniqueIDBDatabase(const UniqueIDBDatabaseIdentifier& identifi
     DatabaseProcess::singleton().ensureIndexedDatabaseRelativePathExists(m_databaseRelativeDirectory);
 }
 
-UniqueIDBDatabase::~UniqueIDBDatabase()
+LegacyUniqueIDBDatabase::~LegacyUniqueIDBDatabase()
 {
     ASSERT(!m_acceptingNewRequests);
     ASSERT(m_pendingMetadataRequests.isEmpty());
 }
 
-String UniqueIDBDatabase::filenameForDatabaseName() const
+String LegacyUniqueIDBDatabase::filenameForDatabaseName() const
 {
     ASSERT(!m_identifier.databaseName().isNull());
 
@@ -92,38 +92,38 @@ String UniqueIDBDatabase::filenameForDatabaseName() const
     return filename;
 }
 
-String UniqueIDBDatabase::databaseFilenameIdentifier(const SecurityOriginData& originData) const
+String LegacyUniqueIDBDatabase::databaseFilenameIdentifier(const SecurityOriginData& originData) const
 {
     Ref<SecurityOrigin> securityOrigin(SecurityOrigin::create(originData.protocol, originData.host, originData.port));
     return securityOrigin.get().databaseIdentifier();
 }
 
-bool UniqueIDBDatabase::canShareDatabases(const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin) const
+bool LegacyUniqueIDBDatabase::canShareDatabases(const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin) const
 {
     // For now, an origin's database access is predicated on equality with the other origin.
     // We might need to make this more nuanced later.
     return openingOrigin == mainFrameOrigin;
 }
 
-void UniqueIDBDatabase::registerConnection(DatabaseProcessIDBConnection& connection)
+void LegacyUniqueIDBDatabase::registerConnection(DatabaseProcessIDBConnection& connection)
 {
     ASSERT(!m_connections.contains(&connection));
     m_connections.add(&connection);
 }
 
-void UniqueIDBDatabase::unregisterConnection(DatabaseProcessIDBConnection& connection)
+void LegacyUniqueIDBDatabase::unregisterConnection(DatabaseProcessIDBConnection& connection)
 {
     ASSERT(m_connections.contains(&connection));
     resetAllTransactions(connection);
     m_connections.remove(&connection);
 
     if (m_connections.isEmpty() && m_pendingTransactionRollbacks.isEmpty()) {
-        shutdown(UniqueIDBDatabaseShutdownType::NormalShutdown);
-        DatabaseProcess::singleton().removeUniqueIDBDatabase(*this);
+        shutdown(LegacyUniqueIDBDatabaseShutdownType::NormalShutdown);
+        DatabaseProcess::singleton().removeLegacyUniqueIDBDatabase(*this);
     }
 }
 
-void UniqueIDBDatabase::shutdown(UniqueIDBDatabaseShutdownType type)
+void LegacyUniqueIDBDatabase::shutdown(LegacyUniqueIDBDatabaseShutdownType type)
 {
     ASSERT(RunLoop::isMain());
 
@@ -140,31 +140,31 @@ void UniqueIDBDatabase::shutdown(UniqueIDBDatabaseShutdownType type)
         m_databaseTasks.clear();
     }
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::shutdownBackingStore, type, absoluteDatabaseDirectory()), DatabaseTaskType::Shutdown);
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::shutdownBackingStore, type, absoluteDatabaseDirectory()), DatabaseTaskType::Shutdown);
 }
 
-void UniqueIDBDatabase::shutdownBackingStore(UniqueIDBDatabaseShutdownType type, const String& databaseDirectory)
+void LegacyUniqueIDBDatabase::shutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType type, const String& databaseDirectory)
 {
     ASSERT(!RunLoop::isMain());
 
     m_backingStore = nullptr;
 
-    if (type == UniqueIDBDatabaseShutdownType::DeleteShutdown) {
-        String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(databaseDirectory);
-        LOG(IDB, "UniqueIDBDatabase::shutdownBackingStore deleting file '%s' on disk", dbFilename.utf8().data());
+    if (type == LegacyUniqueIDBDatabaseShutdownType::DeleteShutdown) {
+        String dbFilename = LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename(databaseDirectory);
+        LOG(IDB, "LegacyUniqueIDBDatabase::shutdownBackingStore deleting file '%s' on disk", dbFilename.utf8().data());
         deleteFile(dbFilename);
         deleteEmptyDirectory(databaseDirectory);
     }
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didShutdownBackingStore, type), DatabaseTaskType::Shutdown);
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didShutdownBackingStore, type), DatabaseTaskType::Shutdown);
 }
 
-void UniqueIDBDatabase::didShutdownBackingStore(UniqueIDBDatabaseShutdownType type)
+void LegacyUniqueIDBDatabase::didShutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType type)
 {
     ASSERT(RunLoop::isMain());
 
     // Balanced by a ref in ::shutdown()
-    RefPtr<UniqueIDBDatabase> protector(adoptRef(this));
+    RefPtr<LegacyUniqueIDBDatabase> protector(adoptRef(this));
 
     // Empty out remaining main thread tasks.
     while (performNextMainThreadTask()) {
@@ -188,7 +188,7 @@ void UniqueIDBDatabase::didShutdownBackingStore(UniqueIDBDatabaseShutdownType ty
     m_pendingShutdownTask = nullptr;
 }
 
-void UniqueIDBDatabase::deleteDatabase(std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::deleteDatabase(std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -200,19 +200,19 @@ void UniqueIDBDatabase::deleteDatabase(std::function<void (bool)> successCallbac
         return;
     }
 
-    RefPtr<UniqueIDBDatabase> protector(this);
-    m_pendingShutdownTask = AsyncRequestImpl<UniqueIDBDatabaseShutdownType>::create([this, protector, successCallback](UniqueIDBDatabaseShutdownType type) {
+    RefPtr<LegacyUniqueIDBDatabase> protector(this);
+    m_pendingShutdownTask = AsyncRequestImpl<LegacyUniqueIDBDatabaseShutdownType>::create([this, protector, successCallback](LegacyUniqueIDBDatabaseShutdownType type) {
         // If the shutdown just completed was a Delete shutdown then we succeeded.
         // If not report failure instead of trying again.
-        successCallback(type == UniqueIDBDatabaseShutdownType::DeleteShutdown);
+        successCallback(type == LegacyUniqueIDBDatabaseShutdownType::DeleteShutdown);
     }, [this, protector, successCallback] {
         successCallback(false);
     });
 
-    shutdown(UniqueIDBDatabaseShutdownType::DeleteShutdown);
+    shutdown(LegacyUniqueIDBDatabaseShutdownType::DeleteShutdown);
 }
 
-void UniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata(std::function<void (bool, const IDBDatabaseMetadata&)> completionCallback)
+void LegacyUniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata(std::function<void (bool, const IDBDatabaseMetadata&)> completionCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -248,10 +248,10 @@ void UniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata(std::function<void (bo
     m_pendingMetadataRequests.append(request.release());
 
     if (shouldOpenBackingStore)
-        postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::openBackingStoreAndReadMetadata, m_identifier, absoluteDatabaseDirectory()));
+        postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata, m_identifier, absoluteDatabaseDirectory()));
 }
 
-void UniqueIDBDatabase::openBackingStoreAndReadMetadata(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
+void LegacyUniqueIDBDatabase::openBackingStoreAndReadMetadata(const LegacyUniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(!m_backingStore);
@@ -264,10 +264,10 @@ void UniqueIDBDatabase::openBackingStoreAndReadMetadata(const UniqueIDBDatabaseI
     m_backingStore = UniqueIDBDatabaseBackingStoreSQLite::create(identifier, databaseDirectory);
     std::unique_ptr<IDBDatabaseMetadata> metadata = m_backingStore->getOrEstablishMetadata();
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata, metadata ? *metadata : IDBDatabaseMetadata(), !!metadata));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata, metadata ? *metadata : IDBDatabaseMetadata(), !!metadata));
 }
 
-void UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata(const IDBDatabaseMetadata& metadata, bool success)
+void LegacyUniqueIDBDatabase::didOpenBackingStoreAndReadMetadata(const IDBDatabaseMetadata& metadata, bool success)
 {
     ASSERT(RunLoop::isMain());
     ASSERT(!m_metadata);
@@ -283,32 +283,32 @@ void UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata(const IDBDatabaseMeta
     }
 }
 
-void UniqueIDBDatabase::openTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::openTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode, std::function<void (bool)> successCallback)
 {
-    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::openBackingStoreTransaction, transactionIdentifier, objectStoreIDs, mode), successCallback);
+    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::openBackingStoreTransaction, transactionIdentifier, objectStoreIDs, mode), successCallback);
 }
 
-void UniqueIDBDatabase::beginTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::beginTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
 {
-    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::beginBackingStoreTransaction, transactionIdentifier), successCallback);
+    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::beginBackingStoreTransaction, transactionIdentifier), successCallback);
 }
 
-void UniqueIDBDatabase::commitTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::commitTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
 {
-    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::commitBackingStoreTransaction, transactionIdentifier), successCallback);
+    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::commitBackingStoreTransaction, transactionIdentifier), successCallback);
 }
 
-void UniqueIDBDatabase::resetTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::resetTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
 {
-    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::resetBackingStoreTransaction, transactionIdentifier), successCallback);
+    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::resetBackingStoreTransaction, transactionIdentifier), successCallback);
 }
 
-void UniqueIDBDatabase::rollbackTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::rollbackTransaction(const IDBIdentifier& transactionIdentifier, std::function<void (bool)> successCallback)
 {
-    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &UniqueIDBDatabase::rollbackBackingStoreTransaction, transactionIdentifier), successCallback);
+    postTransactionOperation(transactionIdentifier, createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction, transactionIdentifier), successCallback);
 }
 
-void UniqueIDBDatabase::postTransactionOperation(const IDBIdentifier& transactionIdentifier, std::unique_ptr<CrossThreadTask> task, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::postTransactionOperation(const IDBIdentifier& transactionIdentifier, std::unique_ptr<CrossThreadTask> task, std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -334,7 +334,7 @@ void UniqueIDBDatabase::postTransactionOperation(const IDBIdentifier& transactio
     m_pendingTransactionRequests.add(transactionIdentifier, request.release());
 }
 
-void UniqueIDBDatabase::didCompleteTransactionOperation(const IDBIdentifier& transactionIdentifier, bool success)
+void LegacyUniqueIDBDatabase::didCompleteTransactionOperation(const IDBIdentifier& transactionIdentifier, bool success)
 {
     ASSERT(RunLoop::isMain());
 
@@ -347,7 +347,7 @@ void UniqueIDBDatabase::didCompleteTransactionOperation(const IDBIdentifier& tra
         finalizeRollback(transactionIdentifier);
 }
 
-void UniqueIDBDatabase::changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::changeDatabaseVersion(const IDBIdentifier& transactionIdentifier, uint64_t newVersion, std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -371,45 +371,45 @@ void UniqueIDBDatabase::changeDatabaseVersion(const IDBIdentifier& transactionId
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::changeDatabaseVersionInBackingStore, requestID, transactionIdentifier, newVersion));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore, requestID, transactionIdentifier, newVersion));
 }
 
-void UniqueIDBDatabase::didChangeDatabaseVersion(uint64_t requestID, bool success)
+void LegacyUniqueIDBDatabase::didChangeDatabaseVersion(uint64_t requestID, bool success)
 {
     didCompleteBoolRequest(requestID, success);
 }
 
-void UniqueIDBDatabase::didCreateObjectStore(uint64_t requestID, bool success)
+void LegacyUniqueIDBDatabase::didCreateObjectStore(uint64_t requestID, bool success)
 {
     didCompleteBoolRequest(requestID, success);
 }
 
-void UniqueIDBDatabase::didDeleteObjectStore(uint64_t requestID, bool success)
+void LegacyUniqueIDBDatabase::didDeleteObjectStore(uint64_t requestID, bool success)
 {
     didCompleteBoolRequest(requestID, success);
 }
 
-void UniqueIDBDatabase::didClearObjectStore(uint64_t requestID, bool success)
+void LegacyUniqueIDBDatabase::didClearObjectStore(uint64_t requestID, bool success)
 {
     didCompleteBoolRequest(requestID, success);
 }
 
-void UniqueIDBDatabase::didCreateIndex(uint64_t requestID, bool success)
+void LegacyUniqueIDBDatabase::didCreateIndex(uint64_t requestID, bool success)
 {
     didCompleteBoolRequest(requestID, success);
 }
 
-void UniqueIDBDatabase::didDeleteIndex(uint64_t requestID, bool success)
+void LegacyUniqueIDBDatabase::didDeleteIndex(uint64_t requestID, bool success)
 {
     didCompleteBoolRequest(requestID, success);
 }
 
-void UniqueIDBDatabase::didCompleteBoolRequest(uint64_t requestID, bool success)
+void LegacyUniqueIDBDatabase::didCompleteBoolRequest(uint64_t requestID, bool success)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(success);
 }
 
-void UniqueIDBDatabase::createObjectStore(const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::createObjectStore(const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata, std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -434,10 +434,10 @@ void UniqueIDBDatabase::createObjectStore(const IDBIdentifier& transactionIdenti
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::createObjectStoreInBackingStore, requestID, transactionIdentifier, metadata));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::createObjectStoreInBackingStore, requestID, transactionIdentifier, metadata));
 }
 
-void UniqueIDBDatabase::deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::deleteObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -461,10 +461,10 @@ void UniqueIDBDatabase::deleteObjectStore(const IDBIdentifier& transactionIdenti
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::deleteObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
 }
 
-void UniqueIDBDatabase::clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::clearObjectStore(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -484,10 +484,10 @@ void UniqueIDBDatabase::clearObjectStore(const IDBIdentifier& transactionIdentif
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::clearObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore, requestID, transactionIdentifier, objectStoreID));
 }
 
-void UniqueIDBDatabase::createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::createIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata, std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -518,10 +518,10 @@ void UniqueIDBDatabase::createIndex(const IDBIdentifier& transactionIdentifier,
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::createIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, metadata));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::createIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, metadata));
 }
 
-void UniqueIDBDatabase::deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, std::function<void (bool)> successCallback)
+void LegacyUniqueIDBDatabase::deleteIndex(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, std::function<void (bool)> successCallback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -552,10 +552,10 @@ void UniqueIDBDatabase::deleteIndex(const IDBIdentifier& transactionIdentifier,
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::deleteIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::deleteIndexInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID));
 }
 
-void UniqueIDBDatabase::putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyData& keyData, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys, std::function<void (const IDBKeyData&, uint32_t, const String&)> callback)
+void LegacyUniqueIDBDatabase::putRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyData& keyData, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys, std::function<void (const IDBKeyData&, uint32_t, const String&)> callback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -575,10 +575,10 @@ void UniqueIDBDatabase::putRecord(const IDBIdentifier& transactionIdentifier, in
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::putRecordInBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), keyData, value.vector(), putMode, indexIDs, indexKeys));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::putRecordInBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), keyData, value.vector(), putMode, indexIDs, indexKeys));
 }
 
-void UniqueIDBDatabase::getRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType, std::function<void (const IDBGetResult&, uint32_t, const String&)> callback)
+void LegacyUniqueIDBDatabase::getRecord(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType, std::function<void (const IDBGetResult&, uint32_t, const String&)> callback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -598,10 +598,10 @@ void UniqueIDBDatabase::getRecord(const IDBIdentifier& transactionIdentifier, in
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::getRecordFromBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), indexID, keyRangeData, cursorType));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::getRecordFromBackingStore, requestID, transactionIdentifier, m_metadata->objectStores.get(objectStoreID), indexID, keyRangeData, cursorType));
 }
 
-void UniqueIDBDatabase::openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
+void LegacyUniqueIDBDatabase::openCursor(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -621,10 +621,10 @@ void UniqueIDBDatabase::openCursor(const IDBIdentifier& transactionIdentifier, i
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::openCursorInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, cursorDirection, cursorType, taskType, keyRangeData));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::openCursorInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, cursorDirection, cursorType, taskType, keyRangeData));
 }
 
-void UniqueIDBDatabase::cursorAdvance(const IDBIdentifier& cursorIdentifier, uint64_t count, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
+void LegacyUniqueIDBDatabase::cursorAdvance(const IDBIdentifier& cursorIdentifier, uint64_t count, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -642,10 +642,10 @@ void UniqueIDBDatabase::cursorAdvance(const IDBIdentifier& cursorIdentifier, uin
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::advanceCursorInBackingStore, requestID, cursorIdentifier, count));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::advanceCursorInBackingStore, requestID, cursorIdentifier, count));
 }
 
-void UniqueIDBDatabase::cursorIterate(const IDBIdentifier& cursorIdentifier, const IDBKeyData& key, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
+void LegacyUniqueIDBDatabase::cursorIterate(const IDBIdentifier& cursorIdentifier, const IDBKeyData& key, std::function<void (const IDBKeyData&, const IDBKeyData&, PassRefPtr<SharedBuffer>, uint32_t, const String&)> callback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -663,10 +663,10 @@ void UniqueIDBDatabase::cursorIterate(const IDBIdentifier& cursorIdentifier, con
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::iterateCursorInBackingStore, requestID, cursorIdentifier, key));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::iterateCursorInBackingStore, requestID, cursorIdentifier, key));
 }
 
-void UniqueIDBDatabase::count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, uint32_t, const String&)> callback)
+void LegacyUniqueIDBDatabase::count(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData, std::function<void (int64_t, uint32_t, const String&)> callback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -684,10 +684,10 @@ void UniqueIDBDatabase::count(const IDBIdentifier& transactionIdentifier, int64_
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::countInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, keyRangeData));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::countInBackingStore, requestID, transactionIdentifier, objectStoreID, indexID, keyRangeData));
 }
 
-void UniqueIDBDatabase::deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData, std::function<void (uint32_t, const String&)> callback)
+void LegacyUniqueIDBDatabase::deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData, std::function<void (uint32_t, const String&)> callback)
 {
     ASSERT(RunLoop::isMain());
 
@@ -705,122 +705,122 @@ void UniqueIDBDatabase::deleteRange(const IDBIdentifier& transactionIdentifier,
     uint64_t requestID = request->requestID();
     m_pendingDatabaseTasks.add(requestID, request.release());
 
-    postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::deleteRangeInBackingStore, requestID, transactionIdentifier, objectStoreID, keyRangeData));
+    postDatabaseTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::deleteRangeInBackingStore, requestID, transactionIdentifier, objectStoreID, keyRangeData));
 }
 
-void UniqueIDBDatabase::openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode)
+void LegacyUniqueIDBDatabase::openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, IndexedDB::TransactionMode mode)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->establishTransaction(transactionIdentifier, objectStoreIDs, mode);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didEstablishTransaction, transactionIdentifier, success));
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didEstablishTransaction, transactionIdentifier, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
 }
 
-void UniqueIDBDatabase::beginBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+void LegacyUniqueIDBDatabase::beginBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->beginTransaction(transactionIdentifier);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
 }
 
-void UniqueIDBDatabase::commitBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+void LegacyUniqueIDBDatabase::commitBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->commitTransaction(transactionIdentifier);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
 }
 
-void UniqueIDBDatabase::resetBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+void LegacyUniqueIDBDatabase::resetBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->resetTransaction(transactionIdentifier);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didResetTransaction, transactionIdentifier, success));
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didResetTransaction, transactionIdentifier, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
 }
 
-void UniqueIDBDatabase::rollbackBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
+void LegacyUniqueIDBDatabase::rollbackBackingStoreTransaction(const IDBIdentifier& transactionIdentifier)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->rollbackTransaction(transactionIdentifier);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCompleteTransactionOperation, transactionIdentifier, success));
 }
 
-void UniqueIDBDatabase::changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, uint64_t newVersion)
+void LegacyUniqueIDBDatabase::changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, uint64_t newVersion)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->changeDatabaseVersion(transactionIdentifier, newVersion);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didChangeDatabaseVersion, requestID, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didChangeDatabaseVersion, requestID, success));
 }
 
-void UniqueIDBDatabase::createObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata)
+void LegacyUniqueIDBDatabase::createObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, const IDBObjectStoreMetadata& metadata)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->createObjectStore(transactionIdentifier, metadata);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCreateObjectStore, requestID, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCreateObjectStore, requestID, success));
 }
 
-void UniqueIDBDatabase::deleteObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
+void LegacyUniqueIDBDatabase::deleteObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->deleteObjectStore(transactionIdentifier, objectStoreID);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteObjectStore, requestID, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteObjectStore, requestID, success));
 }
 
-void UniqueIDBDatabase::clearObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
+void LegacyUniqueIDBDatabase::clearObjectStoreInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->clearObjectStore(transactionIdentifier, objectStoreID);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didClearObjectStore, requestID, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didClearObjectStore, requestID, success));
 }
 
-void UniqueIDBDatabase::createIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata)
+void LegacyUniqueIDBDatabase::createIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBIndexMetadata& metadata)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->createIndex(transactionIdentifier, objectStoreID, metadata);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCreateIndex, requestID, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCreateIndex, requestID, success));
 }
 
-void UniqueIDBDatabase::deleteIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID)
+void LegacyUniqueIDBDatabase::deleteIndexInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
 
     bool success = m_backingStore->deleteIndex(transactionIdentifier, objectStoreID, indexID);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteIndex, requestID, success));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteIndex, requestID, success));
 }
 
-void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, const IDBKeyData& inputKeyData, const Vector<uint8_t>& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys)
+void LegacyUniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, const IDBKeyData& inputKeyData, const Vector<uint8_t>& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<IDBKeyData>>& indexKeys)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
@@ -831,7 +831,7 @@ void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIde
 
     if (putMode != IDBDatabaseBackend::CursorUpdate && objectStoreMetadata.autoIncrement && inputKeyData.isNull()) {
         if (!m_backingStore->generateKeyNumber(transaction, objectStoreMetadata.id, keyNumber)) {
-            postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
+            postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
             return;
         }
         key.setNumberValue(keyNumber);
@@ -842,11 +842,11 @@ void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIde
     if (putMode == IDBDatabaseBackend::AddOnly) {
         bool keyExists;
         if (!m_backingStore->keyExistsInObjectStore(transaction, objectStoreMetadata.id, key, keyExists)) {
-            postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
+            postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error checking for key existence")));
             return;
         }
         if (keyExists) {
-            postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::ConstraintError, ASCIILiteral("Key already exists in the object store")));
+            postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::ConstraintError, ASCIILiteral("Key already exists in the object store")));
             return;
         }
     }
@@ -854,12 +854,12 @@ void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIde
     // The spec says that even if we're about to overwrite the record, perform the steps to delete it first.
     // This is important because formally deleting it from from the object store also removes it from the appropriate indexes.
     if (!m_backingStore->deleteRecord(transaction, objectStoreMetadata.id, key)) {
-        postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Replacing an existing key in backing store, unable to delete previous record.")));
+        postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Replacing an existing key in backing store, unable to delete previous record.")));
         return;
     }
 
     if (!m_backingStore->putRecord(transaction, objectStoreMetadata.id, key, value.data(), value.size())) {
-        postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error putting a record")));
+        postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error putting a record")));
         return;
     }
 
@@ -867,7 +867,7 @@ void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIde
     for (size_t i = 0; i < indexIDs.size(); ++i) {
         for (size_t j = 0; j < indexKeys[i].size(); ++j) {
             if (!m_backingStore->putIndexRecord(transaction, objectStoreMetadata.id, indexIDs[i], key, indexKeys[i][j])) {
-                postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error writing index key")));
+                postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error writing index key")));
                 return;
             }
         }
@@ -877,20 +877,20 @@ void UniqueIDBDatabase::putRecordInBackingStore(uint64_t requestID, const IDBIde
 
     if (putMode != IDBDatabaseBackend::CursorUpdate && objectStoreMetadata.autoIncrement && key.type() == KeyType::Number) {
         if (!m_backingStore->updateKeyGeneratorNumber(transaction, objectStoreMetadata.id, keyNumber, keyWasGenerated)) {
-            postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error updating key generator")));
+            postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, IDBKeyData(), IDBDatabaseException::UnknownError, ASCIILiteral("Internal backing store error updating key generator")));
             return;
         }
     }
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didPutRecordInBackingStore, requestID, key, 0, String(StringImpl::empty())));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didPutRecordInBackingStore, requestID, key, 0, String(StringImpl::empty())));
 }
 
-void UniqueIDBDatabase::didPutRecordInBackingStore(uint64_t requestID, const IDBKeyData& keyData, uint32_t errorCode, const String& errorMessage)
+void LegacyUniqueIDBDatabase::didPutRecordInBackingStore(uint64_t requestID, const IDBKeyData& keyData, uint32_t errorCode, const String& errorMessage)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(keyData, errorCode, errorMessage);
 }
 
-void UniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType)
+void LegacyUniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBIdentifier& transaction, const IDBObjectStoreMetadata& objectStoreMetadata, int64_t indexID, const IDBKeyRangeData& keyRangeData, IndexedDB::CursorType cursorType)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
@@ -898,7 +898,7 @@ void UniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBI
     RefPtr<IDBKeyRange> keyRange = keyRangeData.maybeCreateIDBKeyRange();
     ASSERT(keyRange);
     if (!keyRange) {
-        postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Invalid IDBKeyRange requested from backing store")));
+        postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Invalid IDBKeyRange requested from backing store")));
         return;
     }
 
@@ -908,10 +908,10 @@ void UniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBI
 
         if (keyRange->isOnlyKey()) {
             if (!m_backingStore->getKeyRecordFromObjectStore(transaction, objectStoreMetadata.id, *keyRange->lower(), result))
-                postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key record from object store in backing store")));
+                postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key record from object store in backing store")));
             else {
                 IDBGetResult getResult = result ? IDBGetResult(result.release(), keyRange->lower(), objectStoreMetadata.keyPath) : IDBGetResult();
-                postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
+                postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
             }
 
             return;
@@ -920,10 +920,10 @@ void UniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBI
         RefPtr<IDBKey> resultKey;
 
         if (!m_backingStore->getKeyRangeRecordFromObjectStore(transaction, objectStoreMetadata.id, *keyRange, result, resultKey))
-            postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key range record from object store in backing store")));
+            postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get key range record from object store in backing store")));
         else {
             IDBGetResult getResult = result ? IDBGetResult(result.release(), resultKey.release(), objectStoreMetadata.keyPath) : IDBGetResult();
-            postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
+            postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, getResult, 0, String(StringImpl::empty())));
         }
 
         return;
@@ -933,22 +933,22 @@ void UniqueIDBDatabase::getRecordFromBackingStore(uint64_t requestID, const IDBI
 
     IDBGetResult result;
     if (!m_backingStore->getIndexRecord(transaction, objectStoreMetadata.id, indexID, keyRangeData, cursorType, result)) {
-        postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get index record from backing store")));
+        postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, IDBGetResult(), IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get index record from backing store")));
         return;
     }
 
     // We must return a key path to know how to inject the result key into the result value object.
     result.setKeyPath(objectStoreMetadata.keyPath);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didGetRecordFromBackingStore, requestID, result, 0, String(StringImpl::empty())));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didGetRecordFromBackingStore, requestID, result, 0, String(StringImpl::empty())));
 }
 
-void UniqueIDBDatabase::didGetRecordFromBackingStore(uint64_t requestID, const IDBGetResult& result, uint32_t errorCode, const String& errorMessage)
+void LegacyUniqueIDBDatabase::didGetRecordFromBackingStore(uint64_t requestID, const IDBGetResult& result, uint32_t errorCode, const String& errorMessage)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(result, errorCode, errorMessage);
 }
 
-void UniqueIDBDatabase::openCursorInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRange)
+void LegacyUniqueIDBDatabase::openCursorInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, IndexedDB::CursorDirection cursorDirection, IndexedDB::CursorType cursorType, IDBDatabaseBackend::TaskType taskType, const IDBKeyRangeData& keyRange)
 {
     ASSERT(!RunLoop::isMain());
     ASSERT(m_backingStore);
@@ -966,15 +966,15 @@ void UniqueIDBDatabase::openCursorInBackingStore(uint64_t requestID, const IDBId
         errorMessage = ASCIILiteral("Unknown error opening cursor in backing store");
     }
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didOpenCursorInBackingStore, requestID, cursorID, key, primaryKey, valueBuffer, errorCode, errorMessage));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didOpenCursorInBackingStore, requestID, cursorID, key, primaryKey, valueBuffer, errorCode, errorMessage));
 }
 
-void UniqueIDBDatabase::didOpenCursorInBackingStore(uint64_t requestID, int64_t cursorID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
+void LegacyUniqueIDBDatabase::didOpenCursorInBackingStore(uint64_t requestID, int64_t cursorID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(cursorID, key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
 }
 
-void UniqueIDBDatabase::advanceCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, uint64_t count)
+void LegacyUniqueIDBDatabase::advanceCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, uint64_t count)
 {
     IDBKeyData key;
     IDBKeyData primaryKey;
@@ -988,15 +988,15 @@ void UniqueIDBDatabase::advanceCursorInBackingStore(uint64_t requestID, const ID
         errorMessage = ASCIILiteral("Unknown error advancing cursor in backing store");
     }
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didAdvanceCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
 }
 
-void UniqueIDBDatabase::didAdvanceCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
+void LegacyUniqueIDBDatabase::didAdvanceCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
 }
 
-void UniqueIDBDatabase::iterateCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, const IDBKeyData& iterateKey)
+void LegacyUniqueIDBDatabase::iterateCursorInBackingStore(uint64_t requestID, const IDBIdentifier& cursorIdentifier, const IDBKeyData& iterateKey)
 {
     IDBKeyData key;
     IDBKeyData primaryKey;
@@ -1010,53 +1010,53 @@ void UniqueIDBDatabase::iterateCursorInBackingStore(uint64_t requestID, const ID
         errorMessage = ASCIILiteral("Unknown error iterating cursor in backing store");
     }
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didIterateCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didIterateCursorInBackingStore, requestID, key, primaryKey, valueBuffer, errorCode, errorMessage));
 }
 
-void UniqueIDBDatabase::didIterateCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
+void LegacyUniqueIDBDatabase::didIterateCursorInBackingStore(uint64_t requestID, const IDBKeyData& key, const IDBKeyData& primaryKey, const Vector<uint8_t>& valueBuffer, uint32_t errorCode, const String& errorMessage)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(key, primaryKey, SharedBuffer::create(valueBuffer.data(), valueBuffer.size()), errorCode, errorMessage);
 }
 
-void UniqueIDBDatabase::countInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData)
+void LegacyUniqueIDBDatabase::countInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRangeData)
 {
     int64_t count;
 
     if (!m_backingStore->count(transactionIdentifier, objectStoreID, indexID, keyRangeData, count)) {
         LOG_ERROR("Failed to get count from backing store.");
-        postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCountInBackingStore, requestID, 0, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
+        postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCountInBackingStore, requestID, 0, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
 
         return;
     }
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didCountInBackingStore, requestID, count, 0, String(StringImpl::empty())));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didCountInBackingStore, requestID, count, 0, String(StringImpl::empty())));
 }
 
-void UniqueIDBDatabase::didCountInBackingStore(uint64_t requestID, int64_t count, uint32_t errorCode, const String& errorMessage)
+void LegacyUniqueIDBDatabase::didCountInBackingStore(uint64_t requestID, int64_t count, uint32_t errorCode, const String& errorMessage)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(count, errorCode, errorMessage);
 }
 
-void UniqueIDBDatabase::deleteRangeInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData)
+void LegacyUniqueIDBDatabase::deleteRangeInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const IDBKeyRangeData& keyRangeData)
 {
     if (!m_backingStore->deleteRange(transactionIdentifier, objectStoreID, keyRangeData)) {
         LOG_ERROR("Failed to delete range from backing store.");
-        postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
+        postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, IDBDatabaseException::UnknownError, ASCIILiteral("Failed to get count from backing store")));
 
         return;
     }
 
     m_backingStore->notifyCursorsOfChanges(transactionIdentifier, objectStoreID);
 
-    postMainThreadTask(createCrossThreadTask(*this, &UniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, 0, String(StringImpl::empty())));
+    postMainThreadTask(createCrossThreadTask(*this, &LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore, requestID, 0, String(StringImpl::empty())));
 }
 
-void UniqueIDBDatabase::didDeleteRangeInBackingStore(uint64_t requestID, uint32_t errorCode, const String& errorMessage)
+void LegacyUniqueIDBDatabase::didDeleteRangeInBackingStore(uint64_t requestID, uint32_t errorCode, const String& errorMessage)
 {
     m_pendingDatabaseTasks.take(requestID).get().completeRequest(errorCode, errorMessage);
 }
 
-void UniqueIDBDatabase::didEstablishTransaction(const IDBIdentifier& transactionIdentifier, bool success)
+void LegacyUniqueIDBDatabase::didEstablishTransaction(const IDBIdentifier& transactionIdentifier, bool success)
 {
     ASSERT(RunLoop::isMain());
     if (!success)
@@ -1066,7 +1066,7 @@ void UniqueIDBDatabase::didEstablishTransaction(const IDBIdentifier& transaction
     transactions.iterator->value.add(transactionIdentifier);
 }
 
-void UniqueIDBDatabase::didResetTransaction(const IDBIdentifier& transactionIdentifier, bool success)
+void LegacyUniqueIDBDatabase::didResetTransaction(const IDBIdentifier& transactionIdentifier, bool success)
 {
     ASSERT(RunLoop::isMain());
     if (!success)
@@ -1077,7 +1077,7 @@ void UniqueIDBDatabase::didResetTransaction(const IDBIdentifier& transactionIden
         transactions.get()->value.remove(transactionIdentifier);
 }
 
-void UniqueIDBDatabase::resetAllTransactions(const DatabaseProcessIDBConnection& connection)
+void LegacyUniqueIDBDatabase::resetAllTransactions(const DatabaseProcessIDBConnection& connection)
 {
     ASSERT(RunLoop::isMain());
     auto transactions = m_establishedTransactions.find(&connection);
@@ -1091,7 +1091,7 @@ void UniqueIDBDatabase::resetAllTransactions(const DatabaseProcessIDBConnection&
     }
 }
 
-void UniqueIDBDatabase::finalizeRollback(const WebKit::IDBIdentifier& transactionId)
+void LegacyUniqueIDBDatabase::finalizeRollback(const WebKit::IDBIdentifier& transactionId)
 {
     ASSERT(RunLoop::isMain());
     ASSERT(m_pendingTransactionRollbacks.contains(transactionId));
@@ -1105,20 +1105,20 @@ void UniqueIDBDatabase::finalizeRollback(const WebKit::IDBIdentifier& transactio
         m_pendingTransactionRollbacks.remove(transactionId);
         resetTransaction(transactionId, [this, transactionId](bool) {
             if (m_acceptingNewRequests && m_connections.isEmpty() && m_pendingTransactionRollbacks.isEmpty()) {
-                shutdown(UniqueIDBDatabaseShutdownType::NormalShutdown);
-                DatabaseProcess::singleton().removeUniqueIDBDatabase(*this);
+                shutdown(LegacyUniqueIDBDatabaseShutdownType::NormalShutdown);
+                DatabaseProcess::singleton().removeLegacyUniqueIDBDatabase(*this);
             }
         });
     });
 }
 
-String UniqueIDBDatabase::absoluteDatabaseDirectory() const
+String LegacyUniqueIDBDatabase::absoluteDatabaseDirectory() const
 {
     ASSERT(RunLoop::isMain());
     return DatabaseProcess::singleton().absoluteIndexedDatabasePathFromDatabaseRelativePath(m_databaseRelativeDirectory);
 }
 
-void UniqueIDBDatabase::postMainThreadTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
+void LegacyUniqueIDBDatabase::postMainThreadTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
 {
     ASSERT(!RunLoop::isMain());
 
@@ -1129,13 +1129,13 @@ void UniqueIDBDatabase::postMainThreadTask(std::unique_ptr<CrossThreadTask> task
 
     m_mainThreadTasks.append(WTFMove(task));
 
-    RefPtr<UniqueIDBDatabase> database(this);
+    RefPtr<LegacyUniqueIDBDatabase> database(this);
     RunLoop::main().dispatch([database] {
         database->performNextMainThreadTask();
     });
 }
 
-bool UniqueIDBDatabase::performNextMainThreadTask()
+bool LegacyUniqueIDBDatabase::performNextMainThreadTask()
 {
     ASSERT(RunLoop::isMain());
 
@@ -1158,7 +1158,7 @@ bool UniqueIDBDatabase::performNextMainThreadTask()
     return moreTasks;
 }
 
-void UniqueIDBDatabase::postDatabaseTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
+void LegacyUniqueIDBDatabase::postDatabaseTask(std::unique_ptr<CrossThreadTask> task, DatabaseTaskType taskType)
 {
     ASSERT(RunLoop::isMain());
 
@@ -1169,20 +1169,20 @@ void UniqueIDBDatabase::postDatabaseTask(std::unique_ptr<CrossThreadTask> task,
 
     m_databaseTasks.append(WTFMove(task));
 
-    RefPtr<UniqueIDBDatabase> database(this);
+    RefPtr<LegacyUniqueIDBDatabase> database(this);
     DatabaseProcess::singleton().queue().dispatch([database] {
         database->performNextDatabaseTask();
     });
 }
 
-void UniqueIDBDatabase::performNextDatabaseTask()
+void LegacyUniqueIDBDatabase::performNextDatabaseTask()
 {
     ASSERT(!RunLoop::isMain());
 
     // It is possible that this database might be shutting down on the main thread.
     // In this case, immediately after releasing m_databaseTaskMutex, this database might get deleted.
     // We take a ref() to make sure the database is still live while this last task is performed.
-    RefPtr<UniqueIDBDatabase> protector(this);
+    RefPtr<LegacyUniqueIDBDatabase> protector(this);
 
     std::unique_ptr<CrossThreadTask> task;
     {
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef UniqueIDBDatabase_h
-#define UniqueIDBDatabase_h
+#ifndef LegacyUniqueIDBDatabase_h
+#define LegacyUniqueIDBDatabase_h
 
 #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
 
 #include "AsyncRequest.h"
 #include "IDBIdentifier.h"
-#include "UniqueIDBDatabaseIdentifier.h"
+#include "LegacyUniqueIDBDatabaseIdentifier.h"
 #include <WebCore/IDBDatabaseBackend.h>
 #include <WebCore/IndexedDB.h>
 #include <functional>
@@ -60,23 +60,23 @@ namespace WebKit {
 class DatabaseProcessIDBConnection;
 class UniqueIDBDatabaseBackingStore;
 
-enum class UniqueIDBDatabaseShutdownType {
+enum class LegacyUniqueIDBDatabaseShutdownType {
     NormalShutdown,
     DeleteShutdown
 };
 
-class UniqueIDBDatabase : public ThreadSafeRefCounted<UniqueIDBDatabase> {
+class LegacyUniqueIDBDatabase : public ThreadSafeRefCounted<LegacyUniqueIDBDatabase> {
 public:
-    static Ref<UniqueIDBDatabase> create(const UniqueIDBDatabaseIdentifier& identifier)
+    static Ref<LegacyUniqueIDBDatabase> create(const LegacyUniqueIDBDatabaseIdentifier& identifier)
     {
-        return adoptRef(*new UniqueIDBDatabase(identifier));
+        return adoptRef(*new LegacyUniqueIDBDatabase(identifier));
     }
 
-    ~UniqueIDBDatabase();
+    ~LegacyUniqueIDBDatabase();
 
     static String calculateAbsoluteDatabaseFilename(const String& absoluteDatabaseDirectory);
 
-    const UniqueIDBDatabaseIdentifier& identifier() const { return m_identifier; }
+    const LegacyUniqueIDBDatabaseIdentifier& identifier() const { return m_identifier; }
 
     void registerConnection(DatabaseProcessIDBConnection&);
     void unregisterConnection(DatabaseProcessIDBConnection&);
@@ -109,9 +109,9 @@ public:
     void deleteRange(const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyRangeData&, std::function<void (uint32_t, const String&)> callback);
 
 private:
-    UniqueIDBDatabase(const UniqueIDBDatabaseIdentifier&);
+    LegacyUniqueIDBDatabase(const LegacyUniqueIDBDatabaseIdentifier&);
 
-    UniqueIDBDatabaseIdentifier m_identifier;
+    LegacyUniqueIDBDatabaseIdentifier m_identifier;
 
     bool m_inMemory;
     String m_databaseRelativeDirectory;
@@ -127,7 +127,7 @@ private:
     };
     void postDatabaseTask(std::unique_ptr<WebCore::CrossThreadTask>, DatabaseTaskType = DatabaseTaskType::Normal);
 
-    void shutdown(UniqueIDBDatabaseShutdownType);
+    void shutdown(LegacyUniqueIDBDatabaseShutdownType);
 
     // Method that attempts to make legal filenames from all legal database names
     String filenameForDatabaseName() const;
@@ -143,7 +143,7 @@ private:
     // To be called from the database workqueue thread only
     void performNextDatabaseTask();
     void postMainThreadTask(std::unique_ptr<WebCore::CrossThreadTask>, DatabaseTaskType = DatabaseTaskType::Normal);
-    void openBackingStoreAndReadMetadata(const UniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
+    void openBackingStoreAndReadMetadata(const LegacyUniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
     void openBackingStoreTransaction(const IDBIdentifier& transactionIdentifier, const Vector<int64_t>& objectStoreIDs, WebCore::IndexedDB::TransactionMode);
     void beginBackingStoreTransaction(const IDBIdentifier&);
     void commitBackingStoreTransaction(const IDBIdentifier&);
@@ -166,7 +166,7 @@ private:
     void countInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, int64_t indexID, const WebCore::IDBKeyRangeData&);
     void deleteRangeInBackingStore(uint64_t requestID, const IDBIdentifier& transactionIdentifier, int64_t objectStoreID, const WebCore::IDBKeyRangeData&);
 
-    void shutdownBackingStore(UniqueIDBDatabaseShutdownType, const String& databaseDirectory);
+    void shutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType, const String& databaseDirectory);
 
     // Callbacks from the database workqueue thread, to be performed on the main thread only
     bool performNextMainThreadTask();
@@ -186,7 +186,7 @@ private:
     void didCountInBackingStore(uint64_t requestID, int64_t count, uint32_t errorCode, const String& errorMessage);
     void didDeleteRangeInBackingStore(uint64_t requestID, uint32_t errorCode, const String& errorMessage);
 
-    void didShutdownBackingStore(UniqueIDBDatabaseShutdownType);
+    void didShutdownBackingStore(LegacyUniqueIDBDatabaseShutdownType);
     void didCompleteBoolRequest(uint64_t requestID, bool success);
 
     void didEstablishTransaction(const IDBIdentifier& transactionIdentifier, bool success);
@@ -218,4 +218,4 @@ private:
 } // namespace WebKit
 
 #endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-#endif // UniqueIDBDatabase_h
+#endif // LegacyUniqueIDBDatabase_h
@@ -24,7 +24,7 @@
  */
 
 #include "config.h"
-#include "UniqueIDBDatabaseIdentifier.h"
+#include "LegacyUniqueIDBDatabaseIdentifier.h"
 
 #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
 
 
 namespace WebKit {
 
-UniqueIDBDatabaseIdentifier::UniqueIDBDatabaseIdentifier()
+LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier()
 {
 }
 
-UniqueIDBDatabaseIdentifier::UniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin)
+LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin)
     : m_databaseName(databaseName)
     , m_openingOrigin(openingOrigin)
     , m_mainFrameOrigin(mainFrameOrigin)
@@ -45,17 +45,17 @@ UniqueIDBDatabaseIdentifier::UniqueIDBDatabaseIdentifier(const String& databaseN
     ASSERT(!m_databaseName.isNull());
 }
 
-UniqueIDBDatabaseIdentifier::UniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType)
+LegacyUniqueIDBDatabaseIdentifier::LegacyUniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType)
     : m_databaseName(WTF::HashTableDeletedValue)
 {
 }
 
-bool UniqueIDBDatabaseIdentifier::isHashTableDeletedValue() const
+bool LegacyUniqueIDBDatabaseIdentifier::isHashTableDeletedValue() const
 {
     return m_databaseName.isHashTableDeletedValue();
 }
 
-unsigned UniqueIDBDatabaseIdentifier::hash() const
+unsigned LegacyUniqueIDBDatabaseIdentifier::hash() const
 {
     unsigned hashCodes[7] = {
         m_databaseName.impl() ? m_databaseName.impl()->hash() : 0,
@@ -69,15 +69,15 @@ unsigned UniqueIDBDatabaseIdentifier::hash() const
     return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
 }
 
-bool UniqueIDBDatabaseIdentifier::isNull() const
+bool LegacyUniqueIDBDatabaseIdentifier::isNull() const
 {
-    // Only a default constructed UniqueIDBDatabaseIdentifier can have a null database name.
+    // Only a default constructed LegacyUniqueIDBDatabaseIdentifier can have a null database name.
     return m_databaseName.isNull();
 }
 
-UniqueIDBDatabaseIdentifier UniqueIDBDatabaseIdentifier::isolatedCopy() const
+LegacyUniqueIDBDatabaseIdentifier LegacyUniqueIDBDatabaseIdentifier::isolatedCopy() const
 {
-    UniqueIDBDatabaseIdentifier result;
+    LegacyUniqueIDBDatabaseIdentifier result;
 
     result.m_databaseName = m_databaseName.isolatedCopy();
     result.m_openingOrigin = m_openingOrigin.isolatedCopy();
@@ -86,7 +86,7 @@ UniqueIDBDatabaseIdentifier UniqueIDBDatabaseIdentifier::isolatedCopy() const
     return result;
 }
 
-bool operator==(const UniqueIDBDatabaseIdentifier& a, const UniqueIDBDatabaseIdentifier& b)
+bool operator==(const LegacyUniqueIDBDatabaseIdentifier& a, const LegacyUniqueIDBDatabaseIdentifier& b)
 {
     if (&a == &b)
         return true;
@@ -23,8 +23,8 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef UniqueIDBDatabaseIdentifier_h
-#define UniqueIDBDatabaseIdentifier_h
+#ifndef LegacyUniqueIDBDatabaseIdentifier_h
+#define LegacyUniqueIDBDatabaseIdentifier_h
 
 #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
 
 
 namespace WebKit {
 
-class UniqueIDBDatabaseIdentifier {
+class LegacyUniqueIDBDatabaseIdentifier {
 public:
-    UniqueIDBDatabaseIdentifier();
-    UniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin);
+    LegacyUniqueIDBDatabaseIdentifier();
+    LegacyUniqueIDBDatabaseIdentifier(const String& databaseName, const WebCore::SecurityOriginData& openingOrigin, const WebCore::SecurityOriginData& mainFrameOrigin);
 
     bool isNull() const;
 
@@ -46,11 +46,11 @@ public:
     const WebCore::SecurityOriginData& openingOrigin() const { return m_openingOrigin; }
     const WebCore::SecurityOriginData& mainFrameOrigin() const { return m_mainFrameOrigin; }
 
-    UniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType);
+    LegacyUniqueIDBDatabaseIdentifier(WTF::HashTableDeletedValueType);
     bool isHashTableDeletedValue() const;
     unsigned hash() const;
 
-    UniqueIDBDatabaseIdentifier isolatedCopy() const;
+    LegacyUniqueIDBDatabaseIdentifier isolatedCopy() const;
 
 private:
     String m_databaseName;
@@ -58,29 +58,29 @@ private:
     WebCore::SecurityOriginData m_mainFrameOrigin;
 };
 
-bool operator==(const UniqueIDBDatabaseIdentifier&, const UniqueIDBDatabaseIdentifier&);
+bool operator==(const LegacyUniqueIDBDatabaseIdentifier&, const LegacyUniqueIDBDatabaseIdentifier&);
 
-struct UniqueIDBDatabaseIdentifierHash {
-    static unsigned hash(const UniqueIDBDatabaseIdentifier& identifier) { return identifier.hash(); }
-    static bool equal(const UniqueIDBDatabaseIdentifier& a, const UniqueIDBDatabaseIdentifier& b) { return a == b; }
+struct LegacyUniqueIDBDatabaseIdentifierHash {
+    static unsigned hash(const LegacyUniqueIDBDatabaseIdentifier& identifier) { return identifier.hash(); }
+    static bool equal(const LegacyUniqueIDBDatabaseIdentifier& a, const LegacyUniqueIDBDatabaseIdentifier& b) { return a == b; }
     static const bool safeToCompareToEmptyOrDeleted = false;
 };
 
-struct UniqueIDBDatabaseIdentifierHashTraits : WTF::SimpleClassHashTraits<UniqueIDBDatabaseIdentifier> {
+struct LegacyUniqueIDBDatabaseIdentifierHashTraits : WTF::SimpleClassHashTraits<LegacyUniqueIDBDatabaseIdentifier> {
     static const bool hasIsEmptyValueFunction = true;
-    static bool isEmptyValue(const UniqueIDBDatabaseIdentifier& info) { return info.isNull(); }
+    static bool isEmptyValue(const LegacyUniqueIDBDatabaseIdentifier& info) { return info.isNull(); }
 };
 
 } // namespace WebKit
 
 namespace WTF {
 
-template<> struct HashTraits<WebKit::UniqueIDBDatabaseIdentifier> : WebKit::UniqueIDBDatabaseIdentifierHashTraits { };
-template<> struct DefaultHash<WebKit::UniqueIDBDatabaseIdentifier> {
-    typedef WebKit::UniqueIDBDatabaseIdentifierHash Hash;
+template<> struct HashTraits<WebKit::LegacyUniqueIDBDatabaseIdentifier> : WebKit::LegacyUniqueIDBDatabaseIdentifierHashTraits { };
+template<> struct DefaultHash<WebKit::LegacyUniqueIDBDatabaseIdentifier> {
+    typedef WebKit::LegacyUniqueIDBDatabaseIdentifierHash Hash;
 };
 
 } // namespaec WTF
 
 #endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
-#endif // UniqueIDBDatabaseIdentifier_h
+#endif // LegacyUniqueIDBDatabaseIdentifier_h
index edc8750..506c152 100644 (file)
@@ -96,7 +96,7 @@ static int64_t generateDatabaseId()
     return ++databaseID;
 }
 
-UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
+UniqueIDBDatabaseBackingStoreSQLite::UniqueIDBDatabaseBackingStoreSQLite(const LegacyUniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
     : m_identifier(identifier)
     , m_absoluteDatabaseDirectory(databaseDirectory)
 {
@@ -427,7 +427,7 @@ std::unique_ptr<IDBDatabaseMetadata> UniqueIDBDatabaseBackingStoreSQLite::getOrE
 {
     ASSERT(!RunLoop::isMain());
 
-    String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(m_absoluteDatabaseDirectory);
+    String dbFilename = LegacyUniqueIDBDatabase::calculateAbsoluteDatabaseFilename(m_absoluteDatabaseDirectory);
 
     m_sqliteDB = openSQLiteDatabaseAtPath(dbFilename);
     if (!m_sqliteDB)
index 10ec886..889d224 100644 (file)
@@ -28,7 +28,7 @@
 
 #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
 
-#include "UniqueIDBDatabase.h" 
+#include "LegacyUniqueIDBDatabase.h" 
 #include "UniqueIDBDatabaseBackingStore.h"
 #include <JavaScriptCore/Strong.h>
 #include <wtf/PassRefPtr.h>
@@ -51,7 +51,7 @@ class SQLiteIDBTransaction;
 
 class UniqueIDBDatabaseBackingStoreSQLite final : public UniqueIDBDatabaseBackingStore {
 public:
-    static Ref<UniqueIDBDatabaseBackingStore> create(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
+    static Ref<UniqueIDBDatabaseBackingStore> create(const LegacyUniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
     {
         return adoptRef(*new UniqueIDBDatabaseBackingStoreSQLite(identifier, databaseDirectory));
     }
@@ -95,7 +95,7 @@ public:
     void unregisterCursor(SQLiteIDBCursor*);
 
 private:
-    UniqueIDBDatabaseBackingStoreSQLite(const UniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
+    UniqueIDBDatabaseBackingStoreSQLite(const LegacyUniqueIDBDatabaseIdentifier&, const String& databaseDirectory);
 
     std::unique_ptr<WebCore::SQLiteDatabase> openSQLiteDatabaseAtPath(const String&);
     std::unique_ptr<WebCore::IDBDatabaseMetadata> extractExistingMetadata();
@@ -108,7 +108,7 @@ private:
 
     int idbKeyCollate(int aLength, const void* a, int bLength, const void* b);
 
-    UniqueIDBDatabaseIdentifier m_identifier;
+    LegacyUniqueIDBDatabaseIdentifier m_identifier;
     String m_absoluteDatabaseDirectory;
 
     std::unique_ptr<WebCore::SQLiteDatabase> m_sqliteDB;
index 8722468..0ca12ad 100644 (file)
@@ -28,7 +28,7 @@
 #if ENABLE(INDEXED_DATABASE)
 
 #include "IDBIdentifier.h"
-#include "UniqueIDBDatabaseIdentifier.h"
+#include "LegacyUniqueIDBDatabaseIdentifier.h"
 #include <WebCore/IDBKeyData.h>
 #include <WebCore/SecurityOriginData.h>
 
@@ -36,7 +36,7 @@ using namespace WebKit;
 
 namespace WebCore {
 
-UniqueIDBDatabaseIdentifier CrossThreadCopierBase<false, false, UniqueIDBDatabaseIdentifier>::copy(const UniqueIDBDatabaseIdentifier& identifier)
+LegacyUniqueIDBDatabaseIdentifier CrossThreadCopierBase<false, false, LegacyUniqueIDBDatabaseIdentifier>::copy(const LegacyUniqueIDBDatabaseIdentifier& identifier)
 {
     return identifier.isolatedCopy();
 }
index 0ef3dd9..ab624e6 100644 (file)
@@ -37,9 +37,9 @@ struct SecurityOriginData;
 
 namespace WebKit {
 class IDBIdentifier;
-class UniqueIDBDatabaseIdentifier;
+class LegacyUniqueIDBDatabaseIdentifier;
 
-enum class UniqueIDBDatabaseShutdownType;
+enum class LegacyUniqueIDBDatabaseShutdownType;
 }
 
 namespace WTF {
@@ -48,8 +48,8 @@ class ASCIILiteral;
 
 namespace WebCore {
 
-template<> struct CrossThreadCopierBase<false, false, WebKit::UniqueIDBDatabaseIdentifier> {
-    static WebKit::UniqueIDBDatabaseIdentifier copy(const WebKit::UniqueIDBDatabaseIdentifier&);
+template<> struct CrossThreadCopierBase<false, false, WebKit::LegacyUniqueIDBDatabaseIdentifier> {
+    static WebKit::LegacyUniqueIDBDatabaseIdentifier copy(const WebKit::LegacyUniqueIDBDatabaseIdentifier&);
 };
 
 template<> struct CrossThreadCopierBase<false, false, WebKit::IDBIdentifier> {
@@ -57,8 +57,8 @@ template<> struct CrossThreadCopierBase<false, false, WebKit::IDBIdentifier> {
 };
 
 
-template<> struct CrossThreadCopierBase<false, false, WebKit::UniqueIDBDatabaseShutdownType> {
-    static WebKit::UniqueIDBDatabaseShutdownType copy(const WebKit::UniqueIDBDatabaseShutdownType& type)
+template<> struct CrossThreadCopierBase<false, false, WebKit::LegacyUniqueIDBDatabaseShutdownType> {
+    static WebKit::LegacyUniqueIDBDatabaseShutdownType copy(const WebKit::LegacyUniqueIDBDatabaseShutdownType& type)
     {
         return type;
     }
index 4c6ec55..f659b71 100644 (file)
                510523751C73D38F007993CB /* WebIDBConnectionToServerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510523721C73D37B007993CB /* WebIDBConnectionToServerMessageReceiver.cpp */; };
                510523791C73DA77007993CB /* WebIDBConnectionToClientMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510523771C73DA70007993CB /* WebIDBConnectionToClientMessageReceiver.cpp */; };
                5105237A1C73DA77007993CB /* WebIDBConnectionToClientMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 510523781C73DA70007993CB /* WebIDBConnectionToClientMessages.h */; };
+               5105237F1C7541FF007993CB /* LegacyUniqueIDBDatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5105237B1C7541F3007993CB /* LegacyUniqueIDBDatabase.cpp */; };
+               510523801C7541FF007993CB /* LegacyUniqueIDBDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 5105237C1C7541F3007993CB /* LegacyUniqueIDBDatabase.h */; };
+               510523811C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5105237D1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp */; };
+               510523821C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 5105237E1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.h */; };
                51064D35189781C4004B2FEB /* SQLiteIDBCursor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51064D33189781C4004B2FEB /* SQLiteIDBCursor.cpp */; };
                51064D36189781C4004B2FEB /* SQLiteIDBCursor.h in Headers */ = {isa = PBXBuildFile; fileRef = 51064D34189781C4004B2FEB /* SQLiteIDBCursor.h */; };
                5106D7C218BDBE73000AB166 /* ContextMenuContextData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5106D7BF18BDBE73000AB166 /* ContextMenuContextData.cpp */; };
                515E7728183DD6F60007203F /* AsyncRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E7726183DD6F60007203F /* AsyncRequest.h */; };
                515E772B184008B90007203F /* DatabaseProcessCreationParameters.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 515E7729184008B90007203F /* DatabaseProcessCreationParameters.cpp */; };
                515E772C184008B90007203F /* DatabaseProcessCreationParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E772A184008B90007203F /* DatabaseProcessCreationParameters.h */; };
-               515E772F184015800007203F /* UniqueIDBDatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 515E772D184015800007203F /* UniqueIDBDatabase.cpp */; };
-               515E7730184015800007203F /* UniqueIDBDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E772E184015800007203F /* UniqueIDBDatabase.h */; };
-               515E773318402D510007203F /* UniqueIDBDatabaseIdentifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 515E773118402D510007203F /* UniqueIDBDatabaseIdentifier.cpp */; };
-               515E773418402D510007203F /* UniqueIDBDatabaseIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 515E773218402D510007203F /* UniqueIDBDatabaseIdentifier.h */; };
                5160BFE113381DF900918999 /* LoggingFoundation.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5160BFE013381DF900918999 /* LoggingFoundation.mm */; };
                516311871858446600534647 /* WebCrossThreadCopier.h in Headers */ = {isa = PBXBuildFile; fileRef = 516311861858446600534647 /* WebCrossThreadCopier.h */; };
                516319921628980A00E22F00 /* NetworkProcessProxyMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 516319911628980A00E22F00 /* NetworkProcessProxyMac.mm */; };
                510523761C73D9F6007993CB /* WebIDBConnectionToClient.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebIDBConnectionToClient.messages.in; sourceTree = "<group>"; };
                510523771C73DA70007993CB /* WebIDBConnectionToClientMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebIDBConnectionToClientMessageReceiver.cpp; sourceTree = "<group>"; };
                510523781C73DA70007993CB /* WebIDBConnectionToClientMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebIDBConnectionToClientMessages.h; sourceTree = "<group>"; };
+               5105237B1C7541F3007993CB /* LegacyUniqueIDBDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LegacyUniqueIDBDatabase.cpp; sourceTree = "<group>"; };
+               5105237C1C7541F3007993CB /* LegacyUniqueIDBDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyUniqueIDBDatabase.h; sourceTree = "<group>"; };
+               5105237D1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LegacyUniqueIDBDatabaseIdentifier.cpp; sourceTree = "<group>"; };
+               5105237E1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyUniqueIDBDatabaseIdentifier.h; sourceTree = "<group>"; };
                5105B0D4162F7A7A00E27709 /* NetworkProcessConnection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NetworkProcessConnection.cpp; path = Network/NetworkProcessConnection.cpp; sourceTree = "<group>"; };
                5105B0D5162F7A7A00E27709 /* NetworkProcessConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NetworkProcessConnection.h; path = Network/NetworkProcessConnection.h; sourceTree = "<group>"; };
                5105B0F31630872E00E27709 /* NetworkProcessProxy.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = NetworkProcessProxy.messages.in; sourceTree = "<group>"; };
                515E7726183DD6F60007203F /* AsyncRequest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AsyncRequest.h; sourceTree = "<group>"; };
                515E7729184008B90007203F /* DatabaseProcessCreationParameters.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DatabaseProcessCreationParameters.cpp; sourceTree = "<group>"; };
                515E772A184008B90007203F /* DatabaseProcessCreationParameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DatabaseProcessCreationParameters.h; sourceTree = "<group>"; };
-               515E772D184015800007203F /* UniqueIDBDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UniqueIDBDatabase.cpp; sourceTree = "<group>"; };
-               515E772E184015800007203F /* UniqueIDBDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueIDBDatabase.h; sourceTree = "<group>"; };
-               515E773118402D510007203F /* UniqueIDBDatabaseIdentifier.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UniqueIDBDatabaseIdentifier.cpp; sourceTree = "<group>"; };
-               515E773218402D510007203F /* UniqueIDBDatabaseIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueIDBDatabaseIdentifier.h; sourceTree = "<group>"; };
                5160BFE013381DF900918999 /* LoggingFoundation.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LoggingFoundation.mm; sourceTree = "<group>"; };
                516311861858446600534647 /* WebCrossThreadCopier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebCrossThreadCopier.h; sourceTree = "<group>"; };
                516319911628980A00E22F00 /* NetworkProcessProxyMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = NetworkProcessProxyMac.mm; path = mac/NetworkProcessProxyMac.mm; sourceTree = "<group>"; };
                                517509591897249700408FAC /* IDBIdentifier.h */,
                                518353D81885BF8C00D9FE44 /* IDBSerialization.cpp */,
                                518353D91885BF8C00D9FE44 /* IDBSerialization.h */,
-                               515E772D184015800007203F /* UniqueIDBDatabase.cpp */,
-                               515E772E184015800007203F /* UniqueIDBDatabase.h */,
+                               5105237B1C7541F3007993CB /* LegacyUniqueIDBDatabase.cpp */,
+                               5105237C1C7541F3007993CB /* LegacyUniqueIDBDatabase.h */,
+                               5105237D1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp */,
+                               5105237E1C7541F3007993CB /* LegacyUniqueIDBDatabaseIdentifier.h */,
                                51654EFF184EF34A007DC837 /* UniqueIDBDatabaseBackingStore.h */,
-                               515E773118402D510007203F /* UniqueIDBDatabaseIdentifier.cpp */,
-                               515E773218402D510007203F /* UniqueIDBDatabaseIdentifier.h */,
                                5105236D1C7393E9007993CB /* WebIDBConnectionToClient.cpp */,
                                5105236E1C7393E9007993CB /* WebIDBConnectionToClient.h */,
                                510523761C73D9F6007993CB /* WebIDBConnectionToClient.messages.in */,
                                512935E41288D97800A4B695 /* InjectedBundlePageContextMenuClient.h in Headers */,
                                E1EE53E311F8CFC000CCBEE4 /* InjectedBundlePageEditorClient.h in Headers */,
                                BC14E10A120B905E00826C0C /* InjectedBundlePageFormClient.h in Headers */,
+                               510523821C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.h in Headers */,
                                990D28C11C65626500986977 /* WebAutomationSession.h in Headers */,
                                CD5C66A1134B9D38004FE2A8 /* InjectedBundlePageFullScreenClient.h in Headers */,
                                BCA8C6A911E3BA5F00812FB7 /* InjectedBundlePageLoaderClient.h in Headers */,
+                               510523801C7541FF007993CB /* LegacyUniqueIDBDatabase.h in Headers */,
                                BC8147A912F64CDA007B2C32 /* InjectedBundlePagePolicyClient.h in Headers */,
                                BCA8C6B011E3C08700812FB7 /* InjectedBundlePageUIClient.h in Headers */,
                                BC33E0D112408E8600360F3F /* InjectedBundleRangeHandle.h in Headers */,
                                1AF05D8714688348008B1E81 /* TiledCoreAnimationDrawingAreaProxy.h in Headers */,
                                1AFE436618B6C081009C7A48 /* UIDelegate.h in Headers */,
                                CEE4AE2B1A5DCF430002F49B /* UIKitSPI.h in Headers */,
-                               515E7730184015800007203F /* UniqueIDBDatabase.h in Headers */,
                                51654F00184EF34A007DC837 /* UniqueIDBDatabaseBackingStore.h in Headers */,
                                51654EFE184EF33F007DC837 /* UniqueIDBDatabaseBackingStoreSQLite.h in Headers */,
-                               515E773418402D510007203F /* UniqueIDBDatabaseIdentifier.h in Headers */,
                                1A64245E12DE29A100CAAE2C /* UpdateInfo.h in Headers */,
                                1AC1336818565B5700F3EC05 /* UserData.h in Headers */,
                                4A3CC18B19B0640F00D14AEF /* UserMediaPermissionRequestManagerProxy.h in Headers */,
                                C0E3AA7B1209E83500A49D01 /* Module.cpp in Sources */,
                                C0E3AA7A1209E83000A49D01 /* ModuleCF.cpp in Sources */,
                                2D50365E1BCC793F00E20BB3 /* NativeWebGestureEventMac.mm in Sources */,
+                               510523811C7541FF007993CB /* LegacyUniqueIDBDatabaseIdentifier.cpp in Sources */,
                                2DA9449E1884E4F000ED86DB /* NativeWebKeyboardEventIOS.mm in Sources */,
                                C02BFF1E1251502E009CCBEA /* NativeWebKeyboardEventMac.mm in Sources */,
                                31EA25D2134F78C0005B1452 /* NativeWebMouseEventMac.mm in Sources */,
                                1ABC3DF51899E437004F0626 /* NavigationState.mm in Sources */,
                                1A6FBA2B11E6862700DB1371 /* NetscapeBrowserFuncs.cpp in Sources */,
                                1A6FBD2911E69BC200DB1371 /* NetscapePlugin.cpp in Sources */,
+                               5105237F1C7541FF007993CB /* LegacyUniqueIDBDatabase.cpp in Sources */,
                                1AE5B7FB11E7AED200BA6767 /* NetscapePluginMac.mm in Sources */,
                                1A4A9C5512B816CF008FE984 /* NetscapePluginModule.cpp in Sources */,
                                1A4A9C9A12B821CD008FE984 /* NetscapePluginModuleMac.mm in Sources */,
                                1AAF263814687C39004A1E8A /* TiledCoreAnimationDrawingArea.mm in Sources */,
                                1AF05D8614688348008B1E81 /* TiledCoreAnimationDrawingAreaProxy.mm in Sources */,
                                1AFE436518B6C081009C7A48 /* UIDelegate.mm in Sources */,
-                               515E772F184015800007203F /* UniqueIDBDatabase.cpp in Sources */,
                                51654EFD184EF33F007DC837 /* UniqueIDBDatabaseBackingStoreSQLite.cpp in Sources */,
-                               515E773318402D510007203F /* UniqueIDBDatabaseIdentifier.cpp in Sources */,
                                1A64245F12DE29A100CAAE2C /* UpdateInfo.cpp in Sources */,
                                1AC1336718565B5700F3EC05 /* UserData.cpp in Sources */,
                                15739BBC1B42040300D258C1 /* UserMediaPermissionRequestManager.cpp in Sources */,