Attachment 349160 Details for Bug 189415 – Patch

[patch] Patch

bug-189415-20180907105837.patch (text/plain), 162.26 KB, created by Sihui Liu on 2018-09-07 10:58:39 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Sihui Liu

Created: 2018-09-07 10:58:39 PDT

Size: 162.26 KB

patch

obsolete

>Subversion Revision: 235479
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index b2a2b6a7800e94c17e0b59a8c67c71a2fc741b91..f36434c589061915026065aca9079d4107499227 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,184 @@
>+2018-09-07  Sihui Liu  <sihui_liu@apple.com>
>+
>+        Move IndexedDB to Network Process
>+        https://bugs.webkit.org/show_bug.cgi?id=189415
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp: Renamed from Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.cpp.
>+        (WebKit::WebIDBConnectionToClient::create):
>+        (WebKit::WebIDBConnectionToClient::WebIDBConnectionToClient):
>+        (WebKit::WebIDBConnectionToClient::~WebIDBConnectionToClient):
>+        (WebKit::WebIDBConnectionToClient::disconnectedFromWebProcess):
>+        (WebKit::WebIDBConnectionToClient::messageSenderConnection):
>+        (WebKit::WebIDBConnectionToClient::connectionToClient):
>+        (WebKit::WebIDBConnectionToClient::didDeleteDatabase):
>+        (WebKit::WebIDBConnectionToClient::didOpenDatabase):
>+        (WebKit::WebIDBConnectionToClient::didAbortTransaction):
>+        (WebKit::WebIDBConnectionToClient::didCommitTransaction):
>+        (WebKit::WebIDBConnectionToClient::didCreateObjectStore):
>+        (WebKit::WebIDBConnectionToClient::didDeleteObjectStore):
>+        (WebKit::WebIDBConnectionToClient::didRenameObjectStore):
>+        (WebKit::WebIDBConnectionToClient::didClearObjectStore):
>+        (WebKit::WebIDBConnectionToClient::didCreateIndex):
>+        (WebKit::WebIDBConnectionToClient::didDeleteIndex):
>+        (WebKit::WebIDBConnectionToClient::didRenameIndex):
>+        (WebKit::WebIDBConnectionToClient::didPutOrAdd):
>+        (WebKit::WebIDBConnectionToClient::handleGetResult):
>+        (WebKit::WebIDBConnectionToClient::didGetRecord):
>+        (WebKit::WebIDBConnectionToClient::didGetAllRecords):
>+        (WebKit::WebIDBConnectionToClient::didGetCount):
>+        (WebKit::WebIDBConnectionToClient::didDeleteRecord):
>+        (WebKit::WebIDBConnectionToClient::didOpenCursor):
>+        (WebKit::WebIDBConnectionToClient::didIterateCursor):
>+        (WebKit::WebIDBConnectionToClient::fireVersionChangeEvent):
>+        (WebKit::WebIDBConnectionToClient::didStartTransaction):
>+        (WebKit::WebIDBConnectionToClient::didCloseFromServer):
>+        (WebKit::WebIDBConnectionToClient::notifyOpenDBRequestBlocked):
>+        (WebKit::WebIDBConnectionToClient::didGetAllDatabaseNames):
>+        (WebKit::WebIDBConnectionToClient::deleteDatabase):
>+        (WebKit::WebIDBConnectionToClient::openDatabase):
>+        (WebKit::WebIDBConnectionToClient::abortTransaction):
>+        (WebKit::WebIDBConnectionToClient::commitTransaction):
>+        (WebKit::WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction):
>+        (WebKit::WebIDBConnectionToClient::createObjectStore):
>+        (WebKit::WebIDBConnectionToClient::deleteObjectStore):
>+        (WebKit::WebIDBConnectionToClient::renameObjectStore):
>+        (WebKit::WebIDBConnectionToClient::clearObjectStore):
>+        (WebKit::WebIDBConnectionToClient::createIndex):
>+        (WebKit::WebIDBConnectionToClient::deleteIndex):
>+        (WebKit::WebIDBConnectionToClient::renameIndex):
>+        (WebKit::WebIDBConnectionToClient::putOrAdd):
>+        (WebKit::WebIDBConnectionToClient::getRecord):
>+        (WebKit::WebIDBConnectionToClient::getAllRecords):
>+        (WebKit::WebIDBConnectionToClient::getCount):
>+        (WebKit::WebIDBConnectionToClient::deleteRecord):
>+        (WebKit::WebIDBConnectionToClient::openCursor):
>+        (WebKit::WebIDBConnectionToClient::iterateCursor):
>+        (WebKit::WebIDBConnectionToClient::establishTransaction):
>+        (WebKit::WebIDBConnectionToClient::databaseConnectionPendingClose):
>+        (WebKit::WebIDBConnectionToClient::databaseConnectionClosed):
>+        (WebKit::WebIDBConnectionToClient::abortOpenAndUpgradeNeeded):
>+        (WebKit::WebIDBConnectionToClient::didFireVersionChangeEvent):
>+        (WebKit::WebIDBConnectionToClient::openDBRequestCancelled):
>+        (WebKit::WebIDBConnectionToClient::confirmDidCloseFromServer):
>+        (WebKit::WebIDBConnectionToClient::getAllDatabaseNames):
>+        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.h: Renamed from Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.h.
>+        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in: Renamed from Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.messages.in.
>+        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
>+        (WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
>+        (WebKit::NetworkConnectionToWebProcess::didClose):
>+        (WebKit::NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles):
>+        (WebKit::generateIDBConnectionToServerIdentifier):
>+        (WebKit::NetworkConnectionToWebProcess::establishIDBConnectionToServer):
>+        (WebKit::NetworkConnectionToWebProcess::removeIDBConnectionToServer):
>+        * NetworkProcess/NetworkConnectionToWebProcess.h:
>+        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
>+        * NetworkProcess/NetworkProcess.cpp:
>+        (WebKit::NetworkProcess::NetworkProcess):
>+        (WebKit::NetworkProcess::initializeNetworkProcess):
>+        (WebKit::NetworkProcess::addWebsiteDataStore):
>+        (WebKit::NetworkProcess::fetchWebsiteData):
>+        (WebKit::NetworkProcess::deleteWebsiteData):
>+        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
>+        (WebKit::NetworkProcess::idbServer):
>+        (WebKit::NetworkProcess::ensurePathExists):
>+        (WebKit::NetworkProcess::postStorageTask):
>+        (WebKit::NetworkProcess::performNextStorageTask):
>+        (WebKit::NetworkProcess::prepareForAccessToTemporaryFile):
>+        (WebKit::NetworkProcess::accessToTemporaryFileComplete):
>+        (WebKit::NetworkProcess::indexedDatabaseOrigins):
>+        (WebKit::NetworkProcess::addIndexedDatabaseSession):
>+        (WebKit::NetworkProcess::getSandboxExtensionsForBlobFiles):
>+        (WebKit::NetworkProcess::didGetSandboxExtensionsForBlobFiles):
>+        (WebKit::NetworkProcess::updateTemporaryFileSandboxExtensions):
>+        (WebKit::NetworkProcess::grantSandboxExtensionsToStorageProcessForBlobs): Deleted.
>+        (WebKit::NetworkProcess::didGrantSandboxExtensionsToStorageProcessForBlobs): Deleted.
>+        * NetworkProcess/NetworkProcess.h:
>+        (WebKit::NetworkProcess::queue):
>+        * NetworkProcess/NetworkProcess.messages.in:
>+        * NetworkProcess/NetworkProcessCreationParameters.cpp:
>+        (WebKit::NetworkProcessCreationParameters::encode const):
>+        (WebKit::NetworkProcessCreationParameters::decode):
>+        * NetworkProcess/NetworkProcessCreationParameters.h:
>+        * Shared/Storage/StorageProcessCreationParameters.cpp:
>+        (WebKit::StorageProcessCreationParameters::encode const):
>+        (WebKit::StorageProcessCreationParameters::decode):
>+        * Shared/Storage/StorageProcessCreationParameters.h:
>+        * Shared/WebsiteDataStoreParameters.cpp:
>+        (WebKit::WebsiteDataStoreParameters::encode const):
>+        (WebKit::WebsiteDataStoreParameters::decode):
>+        (WebKit::WebsiteDataStoreParameters::privateSessionParameters):
>+        * Shared/WebsiteDataStoreParameters.h:
>+        * Sources.txt:
>+        * StorageProcess/StorageProcess.cpp:
>+        (WebKit::StorageProcess::initializeWebsiteDataStore):
>+        (WebKit::StorageProcess::fetchWebsiteData):
>+        (WebKit::StorageProcess::deleteWebsiteData):
>+        (WebKit::StorageProcess::deleteWebsiteDataForOrigins):
>+        (WebKit::StorageProcess::idbServer): Deleted.
>+        (WebKit::StorageProcess::grantSandboxExtensionsForBlobs): Deleted.
>+        (WebKit::StorageProcess::prepareForAccessToTemporaryFile): Deleted.
>+        (WebKit::StorageProcess::accessToTemporaryFileComplete): Deleted.
>+        (WebKit::StorageProcess::indexedDatabaseOrigins): Deleted.
>+        (WebKit::StorageProcess::getSandboxExtensionsForBlobFiles): Deleted.
>+        (WebKit::StorageProcess::didGetSandboxExtensionsForBlobFiles): Deleted.
>+        * StorageProcess/StorageProcess.h:
>+        (WebKit::StorageProcess::queue): Deleted.
>+        * StorageProcess/StorageProcess.messages.in:
>+        * StorageProcess/StorageToWebProcessConnection.cpp:
>+        (WebKit::StorageToWebProcessConnection::didReceiveMessage):
>+        (WebKit::StorageToWebProcessConnection::didClose):
>+        (WebKit::generateIDBConnectionToServerIdentifier): Deleted.
>+        (WebKit::StorageToWebProcessConnection::establishIDBConnectionToServer): Deleted.
>+        (WebKit::StorageToWebProcessConnection::removeIDBConnectionToServer): Deleted.
>+        * StorageProcess/StorageToWebProcessConnection.h:
>+        * StorageProcess/StorageToWebProcessConnection.messages.in:
>+        * UIProcess/Network/NetworkProcessProxy.cpp:
>+        (WebKit::NetworkProcessProxy::getSandboxExtensionsForBlobFiles):
>+        (WebKit::NetworkProcessProxy::grantSandboxExtensionsToStorageProcessForBlobs): Deleted.
>+        * UIProcess/Network/NetworkProcessProxy.h:
>+        * UIProcess/Network/NetworkProcessProxy.messages.in:
>+        * UIProcess/Storage/StorageProcessProxy.cpp:
>+        (WebKit::StorageProcessProxy::getSandboxExtensionsForBlobFiles): Deleted.
>+        * UIProcess/Storage/StorageProcessProxy.h:
>+        * UIProcess/Storage/StorageProcessProxy.messages.in:
>+        * UIProcess/WebProcessPool.cpp:
>+        (WebKit::WebProcessPool::ensureNetworkProcess):
>+        (WebKit::WebProcessPool::ensureStorageProcessAndWebsiteDataStore):
>+        (WebKit::WebProcessPool::pageBeginUsingWebsiteDataStore):
>+        * UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm:
>+        (WebKit::WebsiteDataStore::parameters):
>+        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
>+        (WebKit::computeNetworkProcessAccessTypeForDataFetch):
>+        (WebKit::WebsiteDataStore::fetchDataAndApply):
>+        (WebKit::computeNetworkProcessAccessTypeForDataRemoval):
>+        (WebKit::WebsiteDataStore::removeData):
>+        (WebKit::WebsiteDataStore::storageProcessParameters):
>+        (WebKit::WebsiteDataStore::parameters):
>+        * WebKit.xcodeproj/project.pbxproj:
>+        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
>+        (WebKit::WebIDBConnectionToServer::WebIDBConnectionToServer):
>+        (WebKit::WebIDBConnectionToServer::~WebIDBConnectionToServer):
>+        (WebKit::WebIDBConnectionToServer::messageSenderConnection):
>+        * WebProcess/Databases/WebDatabaseProvider.cpp:
>+        (WebKit::WebDatabaseProvider::idbConnectionToServerForSession):
>+        * WebProcess/Network/NetworkProcessConnection.cpp:
>+        (WebKit::NetworkProcessConnection::didReceiveMessage):
>+        (WebKit::NetworkProcessConnection::didClose):
>+        (WebKit::NetworkProcessConnection::idbConnectionToServerForSession):
>+        * WebProcess/Network/NetworkProcessConnection.h:
>+        (WebKit::NetworkProcessConnection::existingIDBConnectionToServerForIdentifier):
>+        * WebProcess/Storage/WebToStorageProcessConnection.cpp:
>+        (WebKit::WebToStorageProcessConnection::didReceiveMessage):
>+        (WebKit::WebToStorageProcessConnection::didClose):
>+        (WebKit::WebToStorageProcessConnection::idbConnectionToServerForSession): Deleted.
>+        * WebProcess/Storage/WebToStorageProcessConnection.h:
>+        (WebKit::WebToStorageProcessConnection::existingIDBConnectionToServerForIdentifier): Deleted.
>+        * WebProcess/WebProcess.cpp:
>+        (WebKit::WebProcess::networkProcessConnectionClosed):
>+        (WebKit::WebProcess::webToStorageProcessConnectionClosed):
>+
> 2018-08-29  Aditya Keerthi  <akeerthi@apple.com>
> 
>         Followup (r235427): Use the null string instead of std::nullopt when no suggestion is selected
>diff --git a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..beff2f7438ed5a1617e0f72133b6427b192fa20b
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
>@@ -0,0 +1,371 @@
>+/*
>+ * Copyright (C) 2016 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "WebIDBConnectionToClient.h"
>+
>+#if ENABLE(INDEXED_DATABASE)
>+
>+#include "DataReference.h"
>+#include "NetworkProcess.h"
>+#include "WebCoreArgumentCoders.h"
>+#include "WebIDBConnectionToServerMessages.h"
>+#include "WebIDBResult.h"
>+#include <WebCore/IDBError.h>
>+#include <WebCore/IDBGetAllRecordsData.h>
>+#include <WebCore/IDBGetRecordData.h>
>+#include <WebCore/IDBResultData.h>
>+#include <WebCore/IDBValue.h>
>+#include <WebCore/ThreadSafeDataBuffer.h>
>+#include <WebCore/UniqueIDBDatabaseConnection.h>
>+
>+using namespace WebCore;
>+
>+namespace WebKit {
>+
>+Ref<WebIDBConnectionToClient> WebIDBConnectionToClient::create(NetworkConnectionToWebProcess& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
>+{
>+    return adoptRef(*new WebIDBConnectionToClient(connection, serverConnectionIdentifier, sessionID));
>+}
>+
>+WebIDBConnectionToClient::WebIDBConnectionToClient(NetworkConnectionToWebProcess& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
>+    : m_connection(connection)
>+    , m_identifier(serverConnectionIdentifier)
>+    , m_sessionID(sessionID)
>+{
>+    relaxAdoptionRequirement();
>+    m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
>+    NetworkProcess::singleton().idbServer(m_sessionID).registerConnection(*m_connectionToClient);
>+}
>+
>+WebIDBConnectionToClient::~WebIDBConnectionToClient()
>+{
>+}
>+
>+void WebIDBConnectionToClient::disconnectedFromWebProcess()
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).unregisterConnection(*m_connectionToClient);
>+}
>+
>+IPC::Connection* WebIDBConnectionToClient::messageSenderConnection()
>+{
>+    return &m_connection->connection();
>+}
>+
>+WebCore::IDBServer::IDBConnectionToClient& WebIDBConnectionToClient::connectionToClient()
>+{
>+    return *m_connectionToClient;
>+}
>+
>+void WebIDBConnectionToClient::didDeleteDatabase(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidDeleteDatabase(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didOpenDatabase(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidOpenDatabase(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidAbortTransaction(transactionIdentifier, error));
>+}
>+
>+void WebIDBConnectionToClient::didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidCommitTransaction(transactionIdentifier, error));
>+}
>+
>+void WebIDBConnectionToClient::didCreateObjectStore(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidCreateObjectStore(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didDeleteObjectStore(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidDeleteObjectStore(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didRenameObjectStore(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidRenameObjectStore(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didClearObjectStore(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidClearObjectStore(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didCreateIndex(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidCreateIndex(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didDeleteIndex(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidDeleteIndex(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didRenameIndex(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidRenameIndex(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didPutOrAdd(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidPutOrAdd(resultData));
>+}
>+
>+template<class MessageType> void WebIDBConnectionToClient::handleGetResult(const WebCore::IDBResultData& resultData)
>+{
>+    if (resultData.type() == IDBResultType::Error) {
>+        send(MessageType(resultData));
>+        return;
>+    }
>+
>+    if (resultData.type() == IDBResultType::GetAllRecordsSuccess && resultData.getAllResult().type() == IndexedDB::GetAllType::Keys) {
>+        send(MessageType(resultData));
>+        return;
>+    }
>+
>+    auto blobFilePaths = resultData.type() == IDBResultType::GetAllRecordsSuccess ? resultData.getAllResult().allBlobFilePaths() : resultData.getResult().value().blobFilePaths();
>+    if (blobFilePaths.isEmpty()) {
>+        send(MessageType(resultData));
>+        return;
>+    }
>+
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+    NetworkProcess::singleton().getSandboxExtensionsForBlobFiles(blobFilePaths, [protectedThis = makeRef(*this), this, resultData](SandboxExtension::HandleArray&& handles) {
>+        send(MessageType({ resultData, WTFMove(handles) }));
>+    });
>+#else
>+    send(MessageType(resultData));
>+#endif
>+}
>+
>+void WebIDBConnectionToClient::didGetRecord(const WebCore::IDBResultData& resultData)
>+{
>+    handleGetResult<Messages::WebIDBConnectionToServer::DidGetRecord>(resultData);
>+}
>+
>+void WebIDBConnectionToClient::didGetAllRecords(const WebCore::IDBResultData& resultData)
>+{
>+    handleGetResult<Messages::WebIDBConnectionToServer::DidGetAllRecords>(resultData);
>+}
>+
>+void WebIDBConnectionToClient::didGetCount(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidGetCount(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didDeleteRecord(const WebCore::IDBResultData& resultData)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidDeleteRecord(resultData));
>+}
>+
>+void WebIDBConnectionToClient::didOpenCursor(const WebCore::IDBResultData& resultData)
>+{
>+    handleGetResult<Messages::WebIDBConnectionToServer::DidOpenCursor>(resultData);
>+}
>+
>+void WebIDBConnectionToClient::didIterateCursor(const WebCore::IDBResultData& resultData)
>+{
>+    handleGetResult<Messages::WebIDBConnectionToServer::DidIterateCursor>(resultData);
>+}
>+
>+void WebIDBConnectionToClient::fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
>+{
>+    send(Messages::WebIDBConnectionToServer::FireVersionChangeEvent(connection.identifier(), requestIdentifier, requestedVersion));
>+}
>+
>+void WebIDBConnectionToClient::didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidStartTransaction(transactionIdentifier, error));
>+}
>+
>+void WebIDBConnectionToClient::didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBError& error)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidCloseFromServer(connection.identifier(), error));
>+}
>+
>+void WebIDBConnectionToClient::notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
>+{
>+    send(Messages::WebIDBConnectionToServer::NotifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion));
>+}
>+
>+void WebIDBConnectionToClient::didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames)
>+{
>+    send(Messages::WebIDBConnectionToServer::DidGetAllDatabaseNames(callbackID, databaseNames));
>+}
>+
>+void WebIDBConnectionToClient::deleteDatabase(const IDBRequestData& request)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).deleteDatabase(request);
>+}
>+
>+void WebIDBConnectionToClient::openDatabase(const IDBRequestData& request)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).openDatabase(request);
>+}
>+
>+void WebIDBConnectionToClient::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).abortTransaction(transactionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::commitTransaction(const IDBResourceIdentifier& transactionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).commitTransaction(transactionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::createObjectStore(const IDBRequestData& request, const IDBObjectStoreInfo& info)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).createObjectStore(request, info);
>+}
>+
>+void WebIDBConnectionToClient::deleteObjectStore(const IDBRequestData& request, const String& name)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).deleteObjectStore(request, name);
>+}
>+
>+void WebIDBConnectionToClient::renameObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& newName)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).renameObjectStore(request, objectStoreIdentifier, newName);
>+}
>+
>+void WebIDBConnectionToClient::clearObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).clearObjectStore(request, objectStoreIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::createIndex(const IDBRequestData& request, const IDBIndexInfo& info)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).createIndex(request, info);
>+}
>+
>+void WebIDBConnectionToClient::deleteIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& name)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).deleteIndex(request, objectStoreIdentifier, name);
>+}
>+
>+void WebIDBConnectionToClient::renameIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).renameIndex(request, objectStoreIdentifier, indexIdentifier, newName);
>+}
>+
>+void WebIDBConnectionToClient::putOrAdd(const IDBRequestData& request, const IDBKeyData& key, const IDBValue& value, unsigned overwriteMode)
>+{
>+    if (overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::NoOverwrite)
>+        && overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::Overwrite)
>+        && overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::OverwriteForCursor)) {
>+        // FIXME: This message from the WebProcess is corrupt.
>+        // The StorageProcess should return early at this point, but can we also kill the bad WebProcess?
>+        return;
>+    }
>+
>+    IndexedDB::ObjectStoreOverwriteMode mode = static_cast<IndexedDB::ObjectStoreOverwriteMode>(overwriteMode);
>+
>+    NetworkProcess::singleton().idbServer(m_sessionID).putOrAdd(request, key, value, mode);
>+}
>+
>+void WebIDBConnectionToClient::getRecord(const IDBRequestData& request, const IDBGetRecordData& getRecordData)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).getRecord(request, getRecordData);
>+}
>+
>+void WebIDBConnectionToClient::getAllRecords(const IDBRequestData& request, const IDBGetAllRecordsData& getAllRecordsData)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).getAllRecords(request, getAllRecordsData);
>+}
>+
>+void WebIDBConnectionToClient::getCount(const IDBRequestData& request, const IDBKeyRangeData& range)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).getCount(request, range);
>+}
>+
>+void WebIDBConnectionToClient::deleteRecord(const IDBRequestData& request, const IDBKeyRangeData& range)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).deleteRecord(request, range);
>+}
>+
>+void WebIDBConnectionToClient::openCursor(const IDBRequestData& request, const IDBCursorInfo& info)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).openCursor(request, info);
>+}
>+
>+void WebIDBConnectionToClient::iterateCursor(const IDBRequestData& request, const IDBIterateCursorData& data)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).iterateCursor(request, data);
>+}
>+
>+void WebIDBConnectionToClient::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).establishTransaction(databaseConnectionIdentifier, info);
>+}
>+
>+void WebIDBConnectionToClient::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).databaseConnectionPendingClose(databaseConnectionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).databaseConnectionClosed(databaseConnectionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).didFireVersionChangeEvent(databaseConnectionIdentifier, transactionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::openDBRequestCancelled(const IDBRequestData& requestData)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).openDBRequestCancelled(requestData);
>+}
>+
>+void WebIDBConnectionToClient::confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).confirmDidCloseFromServer(databaseConnectionIdentifier);
>+}
>+
>+void WebIDBConnectionToClient::getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID)
>+{
>+    NetworkProcess::singleton().idbServer(m_sessionID).getAllDatabaseNames(serverConnectionIdentifier, topOrigin, openingOrigin, callbackID);
>+}
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..5926b00213a72b3073f2c047c60b1ec4449c7f80
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h
>@@ -0,0 +1,144 @@
>+/*
>+ * Copyright (C) 2016 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#if ENABLE(INDEXED_DATABASE)
>+
>+#include "MessageSender.h"
>+#include "NetworkConnectionToWebProcess.h"
>+#include <WebCore/IDBConnectionToClient.h>
>+#include <pal/SessionID.h>
>+
>+namespace WebCore {
>+class IDBCursorInfo;
>+class IDBIndexInfo;
>+class IDBKeyData;
>+class IDBObjectStoreInfo;
>+class IDBRequestData;
>+class IDBTransactionInfo;
>+class IDBValue;
>+class SerializedScriptValue;
>+struct IDBGetAllRecordsData;
>+struct IDBGetRecordData;
>+struct IDBIterateCursorData;
>+struct IDBKeyRangeData;
>+struct SecurityOriginData;
>+}
>+
>+namespace WebKit {
>+
>+class WebIDBConnectionToClient final : public WebCore::IDBServer::IDBConnectionToClientDelegate, public IPC::MessageSender, public RefCounted<WebIDBConnectionToClient> {
>+public:
>+    static Ref<WebIDBConnectionToClient> create(NetworkConnectionToWebProcess&, uint64_t serverConnectionIdentifier, PAL::SessionID);
>+
>+    virtual ~WebIDBConnectionToClient();
>+
>+    WebCore::IDBServer::IDBConnectionToClient& connectionToClient();
>+    uint64_t identifier() const final { return m_identifier; }
>+    uint64_t messageSenderDestinationID() final { return m_identifier; }
>+
>+    // IDBConnectionToClientDelegate
>+    void didDeleteDatabase(const WebCore::IDBResultData&) final;
>+    void didOpenDatabase(const WebCore::IDBResultData&) final;
>+    void didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
>+    void didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
>+    void didCreateObjectStore(const WebCore::IDBResultData&) final;
>+    void didDeleteObjectStore(const WebCore::IDBResultData&) final;
>+    void didRenameObjectStore(const WebCore::IDBResultData&) final;
>+    void didClearObjectStore(const WebCore::IDBResultData&) final;
>+    void didCreateIndex(const WebCore::IDBResultData&) final;
>+    void didDeleteIndex(const WebCore::IDBResultData&) final;
>+    void didRenameIndex(const WebCore::IDBResultData&) final;
>+    void didPutOrAdd(const WebCore::IDBResultData&) final;
>+    void didGetRecord(const WebCore::IDBResultData&) final;
>+    void didGetAllRecords(const WebCore::IDBResultData&) final;
>+    void didGetCount(const WebCore::IDBResultData&) final;
>+    void didDeleteRecord(const WebCore::IDBResultData&) final;
>+    void didOpenCursor(const WebCore::IDBResultData&) final;
>+    void didIterateCursor(const WebCore::IDBResultData&) final;
>+
>+    void fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion) final;
>+    void didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
>+    void didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBError&) final;
>+    void notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion) final;
>+
>+    void didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames) final;
>+
>+    void ref() override { RefCounted<WebIDBConnectionToClient>::ref(); }
>+    void deref() override { RefCounted<WebIDBConnectionToClient>::deref(); }
>+
>+    // Messages received from WebProcess
>+    void deleteDatabase(const WebCore::IDBRequestData&);
>+    void openDatabase(const WebCore::IDBRequestData&);
>+    void abortTransaction(const WebCore::IDBResourceIdentifier&);
>+    void commitTransaction(const WebCore::IDBResourceIdentifier&);
>+    void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier&);
>+    void createObjectStore(const WebCore::IDBRequestData&, const WebCore::IDBObjectStoreInfo&);
>+    void deleteObjectStore(const WebCore::IDBRequestData&, const String& objectStoreName);
>+    void renameObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);
>+    void clearObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier);
>+    void createIndex(const WebCore::IDBRequestData&, const WebCore::IDBIndexInfo&);
>+    void deleteIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);
>+    void renameIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);
>+    void putOrAdd(const WebCore::IDBRequestData&, const WebCore::IDBKeyData&, const WebCore::IDBValue&, unsigned overwriteMode);
>+    void getRecord(const WebCore::IDBRequestData&, const WebCore::IDBGetRecordData&);
>+    void getAllRecords(const WebCore::IDBRequestData&, const WebCore::IDBGetAllRecordsData&);
>+    void getCount(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&);
>+    void deleteRecord(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&);
>+    void openCursor(const WebCore::IDBRequestData&, const WebCore::IDBCursorInfo&);
>+    void iterateCursor(const WebCore::IDBRequestData&, const WebCore::IDBIterateCursorData&);
>+
>+    void establishTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBTransactionInfo&);
>+    void databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier);
>+    void databaseConnectionClosed(uint64_t databaseConnectionIdentifier);
>+    void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier);
>+    void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier);
>+    void openDBRequestCancelled(const WebCore::IDBRequestData&);
>+    void confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier);
>+
>+    void getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID);
>+
>+    void disconnectedFromWebProcess();
>+
>+    void didReceiveMessage(IPC::Connection&, IPC::Decoder&);
>+
>+private:
>+    WebIDBConnectionToClient(NetworkConnectionToWebProcess&, uint64_t serverConnectionIdentifier, PAL::SessionID);
>+
>+    IPC::Connection* messageSenderConnection() final;
>+
>+    template<class MessageType> void handleGetResult(const WebCore::IDBResultData&);
>+
>+    Ref<NetworkConnectionToWebProcess> m_connection;
>+
>+    uint64_t m_identifier;
>+    PAL::SessionID m_sessionID;
>+    RefPtr<WebCore::IDBServer::IDBConnectionToClient> m_connectionToClient;
>+};
>+
>+} // namespace WebKit
>+
>+#endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in
>new file mode 100644
>index 0000000000000000000000000000000000000000..4aab0267d7b354326c57749e070082eeb83770f1
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in
>@@ -0,0 +1,56 @@
>+# Copyright (C) 2016 Apple Inc. All rights reserved.
>+#
>+# Redistribution and use in source and binary forms, with or without
>+# modification, are permitted provided that the following conditions
>+# are met:
>+# 1.  Redistributions of source code must retain the above copyright
>+#     notice, this list of conditions and the following disclaimer.
>+# 2.  Redistributions in binary form must reproduce the above copyright
>+#     notice, this list of conditions and the following disclaimer in the
>+#     documentation and/or other materials provided with the distribution.
>+#
>+# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
>+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
>+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
>+# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
>+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
>+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
>+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
>+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+
>+#if ENABLE(INDEXED_DATABASE)
>+
>+messages -> WebIDBConnectionToClient {
>+    DeleteDatabase(WebCore::IDBRequestData requestData)
>+    OpenDatabase(WebCore::IDBRequestData requestData);
>+    AbortTransaction(WebCore::IDBResourceIdentifier transactionIdentifier);
>+    CommitTransaction(WebCore::IDBResourceIdentifier transactionIdentifier);
>+    DidFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier);
>+    CreateObjectStore(WebCore::IDBRequestData requestData, WebCore::IDBObjectStoreInfo info);
>+    DeleteObjectStore(WebCore::IDBRequestData requestData, String objectStoreName);
>+    RenameObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String newName);
>+    ClearObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier);
>+    CreateIndex(WebCore::IDBRequestData requestData, WebCore::IDBIndexInfo info);
>+    DeleteIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String indexName);
>+    RenameIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, String newName);
>+    PutOrAdd(WebCore::IDBRequestData requestData, WebCore::IDBKeyData key, WebCore::IDBValue value, unsigned overwriteMode);
>+    GetRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBGetRecordData getRecordData);
>+    GetAllRecords(WebCore::IDBRequestData requestData, struct WebCore::IDBGetAllRecordsData getAllRecordsData);
>+    GetCount(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range);
>+    DeleteRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range);
>+    OpenCursor(WebCore::IDBRequestData requestData, WebCore::IDBCursorInfo info);
>+    IterateCursor(WebCore::IDBRequestData requestData, struct WebCore::IDBIterateCursorData data);
>+
>+    EstablishTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBTransactionInfo info);
>+    DatabaseConnectionPendingClose(uint64_t databaseConnectionIdentifier);
>+    DatabaseConnectionClosed(uint64_t databaseConnectionIdentifier);
>+    AbortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier);
>+    DidFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier requestIdentifier);
>+    OpenDBRequestCancelled(WebCore::IDBRequestData requestData);
>+    ConfirmDidCloseFromServer(uint64_t databaseConnectionIdentifier);
>+
>+    GetAllDatabaseNames(uint64_t serverConnectionIdentifier, struct WebCore::SecurityOriginData topOrigin, struct WebCore::SecurityOriginData openingOrigin, uint64_t callbackID);
>+}
>+#endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>index 309e990f55b83f164de9e5140680a85d43a9d3b0..b9a1f6906afdb7ccf65201850b91e6bf8299835d 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>@@ -49,6 +49,8 @@
> #include "SessionTracker.h"
> #include "WebCoreArgumentCoders.h"
> #include "WebErrors.h"
>+#include "WebIDBConnectionToClient.h"
>+#include "WebIDBConnectionToClientMessages.h"
> #include "WebsiteDataStore.h"
> #include "WebsiteDataStoreParameters.h"
> #include <WebCore/NetworkStorageSession.h>
>@@ -56,7 +58,6 @@
> #include <WebCore/ResourceRequest.h>
> #include <WebCore/SameSiteInfo.h>
> #include <WebCore/SecurityPolicy.h>
>-#include <pal/SessionID.h>
> 
> namespace WebKit {
> using namespace WebCore;
>@@ -146,6 +147,15 @@ void NetworkConnectionToWebProcess::didReceiveMessage(IPC::Connection& connectio
>         return;
>     }
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    if (decoder.messageReceiverName() == Messages::WebIDBConnectionToClient::messageReceiverName()) {
>+        auto iterator = m_webIDBConnections.find(decoder.destinationID());
>+        if (iterator != m_webIDBConnections.end())
>+            iterator->value->didReceiveMessage(connection, decoder);
>+        return;
>+    }
>+#endif
>+
>     ASSERT_NOT_REACHED();
> }
> 
>@@ -196,6 +206,15 @@ void NetworkConnectionToWebProcess::didClose(IPC::Connection&)
>         m_rtcProvider = nullptr;
>     }
> #endif
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    auto idbConnections = m_webIDBConnections;
>+    for (auto& connection : idbConnections.values())
>+        connection->disconnectedFromWebProcess();
>+    
>+    m_webIDBConnections.clear();
>+#endif
>+
> }
> 
> void NetworkConnectionToWebProcess::didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference, IPC::StringReference)
>@@ -483,12 +502,16 @@ void NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles(const Vector<Stri
>         for (auto& file : fileReferences)
>             file->revokeFileAccess();
> 
>-        NetworkProcess::singleton().grantSandboxExtensionsToStorageProcessForBlobs(fileNames, [this, protectedThis = WTFMove(protectedThis), requestIdentifier, fileNames]() {
>-            if (!m_connection->isValid())
>-                return;
>-
>-            m_connection->send(Messages::NetworkProcessConnection::DidWriteBlobsToTemporaryFiles(requestIdentifier, fileNames), 0);
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+        NetworkProcess::singleton().getSandboxExtensionsForBlobFiles(fileNames, [protectedThis = WTFMove(protectedThis), fileNames](SandboxExtension::HandleArray&& handles) {
>+            ASSERT(fileNames.size() == handles.size());
>+            NetworkProcess::singleton().updateTemporaryFileSandboxExtensions(fileNames, handles);
>         });
>+#endif
>+
>+        if (!m_connection->isValid())
>+            return;
>+        m_connection->send(Messages::NetworkProcessConnection::DidWriteBlobsToTemporaryFiles(requestIdentifier, fileNames), 0);
>     });
> }
> 
>@@ -643,4 +666,32 @@ size_t NetworkConnectionToWebProcess::findNetworkActivityTracker(ResourceLoadIde
>     });
> }
> 
>+/* From Storage Process */
>+#if ENABLE(INDEXED_DATABASE)
>+static uint64_t generateIDBConnectionToServerIdentifier()
>+{
>+    ASSERT(RunLoop::isMain());
>+    static uint64_t identifier = 0;
>+    return ++identifier;
>+}
>+
>+void NetworkConnectionToWebProcess::establishIDBConnectionToServer(PAL::SessionID sessionID, uint64_t& serverConnectionIdentifier)
>+{
>+    serverConnectionIdentifier = generateIDBConnectionToServerIdentifier();
>+    LOG(IndexedDB, "StorageToWebProcessConnection::establishIDBConnectionToServer - %" PRIu64, serverConnectionIdentifier);
>+    ASSERT(!m_webIDBConnections.contains(serverConnectionIdentifier));
>+    
>+    m_webIDBConnections.set(serverConnectionIdentifier, WebIDBConnectionToClient::create(*this, serverConnectionIdentifier, sessionID));
>+}
>+
>+void NetworkConnectionToWebProcess::removeIDBConnectionToServer(uint64_t serverConnectionIdentifier)
>+{
>+    ASSERT(m_webIDBConnections.contains(serverConnectionIdentifier));
>+    
>+    auto connection = m_webIDBConnections.take(serverConnectionIdentifier);
>+    connection->disconnectedFromWebProcess();
>+}
>+#endif
>+/* End From Storage Process */
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>index 1f5e2368ce939b33808448c79e6a4110e0be8112..8abd8cc57ccb314b6513f7214d606e745a357dd9 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>@@ -35,6 +35,7 @@
> #include "NetworkRTCProvider.h"
> #include <WebCore/NetworkLoadInformation.h>
> #include <WebCore/ResourceLoadPriority.h>
>+#include <pal/SessionID.h>
> #include <wtf/RefCounted.h>
> 
> namespace WebCore {
>@@ -54,6 +55,7 @@ class NetworkLoadParameters;
> class NetworkResourceLoader;
> class NetworkSocketStream;
> class SyncNetworkResourceLoader;
>+class WebIDBConnectionToClient;
> typedef uint64_t ResourceLoadIdentifier;
> 
> namespace NetworkCache {
>@@ -238,6 +240,15 @@ private:
>     bool m_captureExtraNetworkLoadMetricsEnabled { false };
> 
>     RefPtr<CacheStorageEngineConnection> m_cacheStorageConnection;
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    // Messages handlers (Modern IDB)
>+    void establishIDBConnectionToServer(PAL::SessionID, uint64_t& serverConnectionIdentifier);
>+    void removeIDBConnectionToServer(uint64_t serverConnectionIdentifier);
>+    
>+    HashMap<uint64_t, RefPtr<WebIDBConnectionToClient>> m_webIDBConnections;
>+#endif
>+
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>index cac8a2fba47caa2f9c4e3b32c2d0a3a2032f4995..ccbd9e9d13f04cf9f569c6585efd773f9f11d7bf 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>@@ -70,4 +70,10 @@ messages -> NetworkConnectionToWebProcess LegacyReceiver {
>     GetNetworkLoadInformationResponse(uint64_t resourceLoadIdentifier) -> (WebCore::ResourceResponse response);
>     GetNetworkLoadIntermediateInformation(uint64_t resourceLoadIdentifier) -> (Vector<WebCore::NetworkTransactionInformation> transactions);
>     TakeNetworkLoadInformationMetrics(uint64_t resourceLoadIdentifier) -> (WebCore::NetworkLoadMetrics networkMetrics);
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    EstablishIDBConnectionToServer(PAL::SessionID sessionID) -> (uint64_t serverConnectionIdentifier)
>+    RemoveIDBConnectionToServer(uint64_t serverConnectionIdentifier)
>+#endif
>+
> }
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.cpp b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>index d58367077f96005f39289e59e351edb27507de8f..f8c4743c8a988675f0790727cd85a90194228e9b 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>@@ -113,6 +113,7 @@ NetworkProcess::NetworkProcess()
>     , m_canHandleHTTPSServerTrustEvaluation(true)
> #if PLATFORM(COCOA)
>     , m_clearCacheDispatchGroup(0)
>+    , m_queue(WorkQueue::create("com.apple.WebKit.NetworkProcess"))
> #endif
> {
>     NetworkProcessPlatformStrategies::initialize();
>@@ -289,6 +290,10 @@ void NetworkProcess::initializeNetworkProcess(NetworkProcessCreationParameters&&
> 
>     SessionTracker::setSession(PAL::SessionID::defaultSessionID(), NetworkSession::create(NetworkSessionCreationParameters()));
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    addIndexedDatabaseSession(PAL::SessionID::defaultSessionID(), parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
>+#endif
>+
>     auto* defaultSession = SessionTracker::networkSession(PAL::SessionID::defaultSessionID());
>     for (const auto& cookie : parameters.defaultSessionPendingCookies)
>         defaultSession->networkStorageSession().setCookie(cookie);
>@@ -388,6 +393,10 @@ void NetworkProcess::clearCachedCredentials()
> 
> void NetworkProcess::addWebsiteDataStore(WebsiteDataStoreParameters&& parameters)
> {
>+#if ENABLE(INDEXED_DATABASE)
>+    addIndexedDatabaseSession(parameters.networkSessionParameters.sessionID, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
>+#endif
>+
>     RemoteNetworkingContext::ensureWebsiteDataStoreSession(WTFMove(parameters));
> }
> 
>@@ -398,21 +407,6 @@ void NetworkProcess::destroySession(PAL::SessionID sessionID)
>     CacheStorage::Engine::destroyEngine(sessionID);
> }
> 
>-void NetworkProcess::grantSandboxExtensionsToStorageProcessForBlobs(const Vector<String>& filenames, Function<void ()>&& completionHandler)
>-{
>-    static uint64_t lastRequestID;
>-
>-    uint64_t requestID = ++lastRequestID;
>-    m_sandboxExtensionForBlobsCompletionHandlers.set(requestID, WTFMove(completionHandler));
>-    parentProcessConnection()->send(Messages::NetworkProcessProxy::GrantSandboxExtensionsToStorageProcessForBlobs(requestID, filenames), 0);
>-}
>-
>-void NetworkProcess::didGrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID)
>-{
>-    if (auto handler = m_sandboxExtensionForBlobsCompletionHandlers.take(requestID))
>-        handler();
>-}
>-
> void NetworkProcess::writeBlobToFilePath(const WebCore::URL& url, const String& path, SandboxExtension::Handle&& handleForWriting, uint64_t requestID)
> {
>     auto extension = SandboxExtension::create(WTFMove(handleForWriting));
>@@ -575,6 +569,19 @@ void NetworkProcess::fetchWebsiteData(PAL::SessionID sessionID, OptionSet<Websit
>     }
> #endif
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    auto path = m_idbDatabasePaths.get(sessionID);
>+    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
>+        // FIXME: Pick the right database store based on the session ID.
>+        postStorageTask(CrossThreadTask([this, callbackAggregator = callbackAggregator.copyRef(), path = WTFMove(path)]() mutable {
>+            RunLoop::main().dispatch([callbackAggregator = WTFMove(callbackAggregator), securityOrigins = indexedDatabaseOrigins(path)] {
>+                for (const auto& securityOrigin : securityOrigins)
>+                    callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
>+            });
>+        }));
>+    }
>+#endif
>+
>     if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
>         fetchDiskCacheEntries(sessionID, fetchOptions, [callbackAggregator = WTFMove(callbackAggregator)](auto entries) mutable {
>             callbackAggregator->m_websiteData.entries.appendVector(entries);
>@@ -608,6 +615,11 @@ void NetworkProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<Websi
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache))
>         CacheStorage::Engine::clearAllCaches(sessionID, [clearTasksHandler = clearTasksHandler.copyRef()] { });
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
>+        idbServer(sessionID).closeAndDeleteDatabasesModifiedSince(modifiedSince, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+#endif
>+
>     if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
>         clearDiskCache(modifiedSince, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
> }
>@@ -660,6 +672,11 @@ void NetworkProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, Optio
>             CacheStorage::Engine::clearCachesForOrigin(sessionID, SecurityOriginData { originData }, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>     }
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
>+        idbServer(sessionID).closeAndDeleteDatabasesForOrigins(originDatas, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+#endif
>+
>     if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
>         clearDiskCacheEntries(originDatas, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
> }
>@@ -948,6 +965,140 @@ void NetworkProcess::didSyncAllCookies()
>     parentProcessConnection()->send(Messages::NetworkProcessProxy::DidSyncAllCookies(), 0);
> }
> 
>+#if ENABLE(INDEXED_DATABASE)
>+IDBServer::IDBServer& NetworkProcess::idbServer(PAL::SessionID sessionID)
>+{
>+    auto addResult = m_idbServers.add(sessionID, nullptr);
>+    if (!addResult.isNewEntry) {
>+        ASSERT(addResult.iterator->value);
>+        return *addResult.iterator->value;
>+    }
>+    
>+    auto path = m_idbDatabasePaths.get(sessionID);
>+    // There should already be a registered path for this PAL::SessionID.
>+    // If there's not, then where did this PAL::SessionID come from?
>+    ASSERT(!path.isEmpty());
>+    
>+    addResult.iterator->value = IDBServer::IDBServer::create(path, NetworkProcess::singleton());
>+    return *addResult.iterator->value;
>+}
>+
>+void NetworkProcess::ensurePathExists(const String& path)
>+{
>+    ASSERT(!RunLoop::isMain());
>+    
>+    if (!FileSystem::makeAllDirectories(path))
>+        LOG_ERROR("Failed to make all directories for path '%s'", path.utf8().data());
>+}
>+
>+void NetworkProcess::postStorageTask(CrossThreadTask&& task)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    LockHolder locker(m_storageTaskMutex);
>+    
>+    m_storageTasks.append(WTFMove(task));
>+    
>+    m_queue->dispatch([this] {
>+        performNextStorageTask();
>+    });
>+}
>+
>+void NetworkProcess::performNextStorageTask()
>+{
>+    ASSERT(!RunLoop::isMain());
>+    
>+    CrossThreadTask task;
>+    {
>+        LockHolder locker(m_storageTaskMutex);
>+        ASSERT(!m_storageTasks.isEmpty());
>+        task = m_storageTasks.takeFirst();
>+    }
>+    
>+    task.performTask();
>+}
>+
>+void NetworkProcess::prepareForAccessToTemporaryFile(const String& path)
>+{
>+    if (auto extension = m_blobTemporaryFileSandboxExtensions.get(path))
>+        extension->consume();
>+}
>+
>+void NetworkProcess::accessToTemporaryFileComplete(const String& path)
>+{
>+    // We've either hard linked the temporary blob file to the database directory, copied it there,
>+    // or the transaction is being aborted.
>+    // In any of those cases, we can delete the temporary blob file now.
>+    FileSystem::deleteFile(path);
>+    
>+    if (auto extension = m_blobTemporaryFileSandboxExtensions.take(path))
>+        extension->revoke();
>+}
>+
>+HashSet<WebCore::SecurityOriginData> NetworkProcess::indexedDatabaseOrigins(const String& path)
>+{
>+    if (path.isEmpty())
>+        return { };
>+    
>+    HashSet<WebCore::SecurityOriginData> securityOrigins;
>+    for (auto& topOriginPath : FileSystem::listDirectory(path, "*")) {
>+        auto databaseIdentifier = FileSystem::pathGetFileName(topOriginPath);
>+        if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
>+            securityOrigins.add(WTFMove(*securityOrigin));
>+        
>+        for (auto& originPath : FileSystem::listDirectory(topOriginPath, "*")) {
>+            databaseIdentifier = FileSystem::pathGetFileName(originPath);
>+            if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
>+                securityOrigins.add(WTFMove(*securityOrigin));
>+        }
>+    }
>+
>+    return securityOrigins;
>+}
>+
>+void NetworkProcess::addIndexedDatabaseSession(PAL::SessionID sessionID, String& indexedDatabaseDirectory, SandboxExtension::Handle& handle)
>+{
>+    // *********
>+    // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
>+    // *********
>+    auto addResult = m_idbDatabasePaths.ensure(sessionID, [path = indexedDatabaseDirectory] {
>+        return path;
>+    });
>+    if (addResult.isNewEntry) {
>+        SandboxExtension::consumePermanently(handle);
>+        if (!indexedDatabaseDirectory.isEmpty())
>+            postStorageTask(createCrossThreadTask(*this, &NetworkProcess::ensurePathExists, indexedDatabaseDirectory));
>+    }
>+}
>+
>+#endif // ENABLE(INDEXED_DATABASE)
>+
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+void NetworkProcess::getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void(SandboxExtension::HandleArray&&)>&& completionHandler)
>+{
>+
>+    static uint64_t lastRequestID;
>+    
>+    uint64_t requestID = ++lastRequestID;
>+    m_sandboxExtensionForBlobsCompletionHandlersStorageForNetworkProcess.set(requestID, WTFMove(completionHandler));
>+    parentProcessConnection()->send(Messages::NetworkProcessProxy::GetSandboxExtensionsForBlobFiles(requestID, filenames), 0);
>+}
>+
>+void NetworkProcess::didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&& handles)
>+{
>+    if (auto handler = m_sandboxExtensionForBlobsCompletionHandlersStorageForNetworkProcess.take(requestID))
>+        handler(WTFMove(handles));
>+}
>+    
>+void NetworkProcess::updateTemporaryFileSandboxExtensions(const Vector<String>& paths, SandboxExtension::HandleArray& handles)
>+{
>+    for (size_t i = 0; i < handles.size(); ++i) {
>+        auto result = m_blobTemporaryFileSandboxExtensions.add(paths[i], SandboxExtension::create(WTFMove(handles[i])));
>+        ASSERT_UNUSED(result, result.isNewEntry);
>+    }
>+}
>+#endif // ENABLE(SANDBOX_EXTENSIONS)
>+
> #if !PLATFORM(COCOA)
> void NetworkProcess::initializeProcess(const ChildProcessInitializationParameters&)
> {
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.h b/Source/WebKit/NetworkProcess/NetworkProcess.h
>index caec53c3c5fa3ad5aded23f69d2e9405c72e0230..15c27e631243cedeeeb4aaa7a93f48a44766d671 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.h
>@@ -30,10 +30,14 @@
> #include "DownloadManager.h"
> #include "MessageReceiverMap.h"
> #include "NetworkContentRuleListManager.h"
>+#include "SandboxExtension.h"
> #include <WebCore/DiagnosticLoggingClient.h>
>+#include <WebCore/IDBBackingStore.h>
>+#include <WebCore/IDBServer.h>
>+#include <WebCore/UniqueIDBDatabase.h>
> #include <memory>
> #include <pal/SessionID.h>
>-#include <wtf/Forward.h>
>+#include <wtf/CrossThreadTask.h>
> #include <wtf/Function.h>
> #include <wtf/HashSet.h>
> #include <wtf/MemoryPressureHandler.h>
>@@ -74,7 +78,11 @@ namespace NetworkCache {
> class Cache;
> }
> 
>-class NetworkProcess : public ChildProcess, private DownloadManager::Client {
>+class NetworkProcess : public ChildProcess, private DownloadManager::Client
>+#if ENABLE(INDEXED_DATABASE)
>+    , public WebCore::IDBServer::IDBBackingStoreTemporaryFileHandler
>+#endif
>+{
>     WTF_MAKE_NONCOPYABLE(NetworkProcess);
>     friend NeverDestroyed<NetworkProcess>;
>     friend NeverDestroyed<DownloadManager>;
>@@ -130,8 +138,6 @@ public:
> 
>     void addWebsiteDataStore(WebsiteDataStoreParameters&&);
> 
>-    void grantSandboxExtensionsToStorageProcessForBlobs(const Vector<String>& filenames, Function<void ()>&& completionHandler);
>-
> #if HAVE(CFNETWORK_STORAGE_PARTITIONING)
>     void updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID, const Vector<String>& domainsToBlock, bool shouldClearFirst, uint64_t contextId);
>     void hasStorageAccessForFrame(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, uint64_t contextId);
>@@ -159,6 +165,22 @@ public:
>     NetworkContentRuleListManager& networkContentRuleListManager() { return m_NetworkContentRuleListManager; }
> #endif
> 
>+    WorkQueue& queue() { return m_queue.get(); }
>+    void postStorageTask(CrossThreadTask&&);
>+#if ENABLE(INDEXED_DATABASE)
>+
>+    WebCore::IDBServer::IDBServer& idbServer(PAL::SessionID);
>+    
>+    // WebCore::IDBServer::IDBBackingStoreFileHandler
>+    void prepareForAccessToTemporaryFile(const String& path) final;
>+    void accessToTemporaryFileComplete(const String& path) final;
>+#endif
>+
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+    void getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void(SandboxExtension::HandleArray&&)>&& completionHandler);
>+    void updateTemporaryFileSandboxExtensions(const Vector<String>& paths, SandboxExtension::HandleArray&);
>+#endif
>+
> private:
>     NetworkProcess();
>     ~NetworkProcess();
>@@ -211,6 +233,10 @@ private:
>     void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, WallTime modifiedSince, uint64_t callbackID);
>     void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>& origins, const Vector<String>& cookieHostNames, const Vector<String>& HSTSCacheHostnames, uint64_t callbackID);
> 
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+    void didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&&);
>+#endif
>+
>     void clearCachedCredentials();
> 
>     void setCacheStorageParameters(PAL::SessionID, uint64_t quota, String&& cacheStorageDirectory, SandboxExtension::Handle&&);
>@@ -234,8 +260,6 @@ private:
>     void syncAllCookies();
>     void didSyncAllCookies();
> 
>-    void didGrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID);
>-
>     void writeBlobToFilePath(const WebCore::URL&, const String& path, SandboxExtension::Handle&&, uint64_t requestID);
> 
> #if USE(SOUP)
>@@ -258,6 +282,15 @@ private:
>     void registerURLSchemeAsCORSEnabled(const String&) const;
>     void registerURLSchemeAsCanDisplayOnlyIfCanRequest(const String&) const;
> 
>+    // For execution on work queue thread only
>+    void performNextStorageTask();
>+    void ensurePathExists(const String& path);
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    void addIndexedDatabaseSession(PAL::SessionID, String&, SandboxExtension::Handle&);
>+    HashSet<WebCore::SecurityOriginData> indexedDatabaseOrigins(const String& path);
>+#endif
>+
>     // Connections to WebProcesses.
>     Vector<RefPtr<NetworkConnectionToWebProcess>> m_webProcessConnections;
> 
>@@ -278,7 +311,6 @@ private:
>     typedef HashMap<const char*, std::unique_ptr<NetworkProcessSupplement>, PtrHash<const char*>> NetworkProcessSupplementMap;
>     NetworkProcessSupplementMap m_supplements;
> 
>-    HashMap<uint64_t, Function<void()>> m_sandboxExtensionForBlobsCompletionHandlers;
>     HashSet<PAL::SessionID> m_sessionsControlledByAutomation;
> 
>     HashMap<PAL::SessionID, Vector<CacheStorageParametersCallback>> m_cacheStorageParametersCallbacks;
>@@ -298,6 +330,20 @@ private:
> #if ENABLE(CONTENT_EXTENSIONS)
>     NetworkContentRuleListManager m_NetworkContentRuleListManager;
> #endif
>+
>+    Ref<WorkQueue> m_queue;
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    HashMap<PAL::SessionID, String> m_idbDatabasePaths;
>+    HashMap<PAL::SessionID, RefPtr<WebCore::IDBServer::IDBServer>> m_idbServers;
>+#endif
>+
>+    HashMap<String, RefPtr<SandboxExtension>> m_blobTemporaryFileSandboxExtensions;
>+    HashMap<uint64_t, WTF::Function<void(SandboxExtension::HandleArray&&)>> m_sandboxExtensionForBlobsCompletionHandlersStorageForNetworkProcess;
>+    
>+    Deque<CrossThreadTask> m_storageTasks;
>+    Lock m_storageTaskMutex;
>+
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>index baa34d09ff6015f9a45d31fb8c1de6d2d463c237..b96976602ab8d94e670796de3e5b8b078a46b322 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>@@ -73,7 +73,9 @@ messages -> NetworkProcess LegacyReceiver {
>     CancelPrepareToSuspend()
>     ProcessDidResume()
> 
>-    DidGrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID)
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+    DidGetSandboxExtensionsForBlobFiles(uint64_t requestID, WebKit::SandboxExtension::HandleArray extensions)
>+#endif
> 
>     WriteBlobToFilePath(WebCore::URL blobURL, String path, WebKit::SandboxExtension::Handle handle, uint64_t callbackID)
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp
>index cd7dba8e9a358c378fa955ecdfc3233f5a99304a..5dc199cd25ac590a23635991a5a0fd272d933022 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp
>@@ -108,6 +108,11 @@ void NetworkProcessCreationParameters::encode(IPC::Encoder& encoder) const
> #if ENABLE(PROXIMITY_NETWORKING)
>     encoder << wirelessContextIdentifier;
> #endif
>+/* From Storage Process */
>+#if ENABLE(INDEXED_DATABASE)
>+    encoder << indexedDatabaseDirectory << indexedDatabaseDirectoryExtensionHandle;
>+#endif
>+/* End From Storage Process*/
> }
> 
> bool NetworkProcessCreationParameters::decode(IPC::Decoder& decoder, NetworkProcessCreationParameters& result)
>@@ -246,6 +251,17 @@ bool NetworkProcessCreationParameters::decode(IPC::Decoder& decoder, NetworkProc
>         return false;
> #endif
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    if (!decoder.decode(result.indexedDatabaseDirectory))
>+        return false;
>+    
>+    std::optional<SandboxExtension::Handle> indexedDatabaseDirectoryExtensionHandle;
>+    decoder >> indexedDatabaseDirectoryExtensionHandle;
>+    if (!indexedDatabaseDirectoryExtensionHandle)
>+        return false;
>+    result.indexedDatabaseDirectoryExtensionHandle = WTFMove(*indexedDatabaseDirectoryExtensionHandle);
>+#endif
>+
>     return true;
> }
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h
>index 54e6ab04c643e2ade0d44b5dea4fdf91feece7ed..714a721f64d5902ef8132e93c809bd88f317f745 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h
>@@ -124,6 +124,12 @@ struct NetworkProcessCreationParameters {
> #if ENABLE(PROXIMITY_NETWORKING)
>     unsigned wirelessContextIdentifier { 0 };
> #endif
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    String indexedDatabaseDirectory;
>+    SandboxExtension::Handle indexedDatabaseDirectoryExtensionHandle;
>+#endif
>+
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.cpp b/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.cpp
>index 6f55c121f1f0dcc02189ab6e17fcbfe2f0fc8ef8..9590a58c057273d9f727f223ec205a98a047993c 100644
>--- a/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.cpp
>+++ b/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.cpp
>@@ -37,9 +37,6 @@ StorageProcessCreationParameters::StorageProcessCreationParameters()
> void StorageProcessCreationParameters::encode(IPC::Encoder& encoder) const
> {
>     encoder << sessionID;
>-#if ENABLE(INDEXED_DATABASE)
>-    encoder << indexedDatabaseDirectory << indexedDatabaseDirectoryExtensionHandle;
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     encoder << serviceWorkerRegistrationDirectory << serviceWorkerRegistrationDirectoryExtensionHandle << urlSchemesServiceWorkersCanHandle << shouldDisableServiceWorkerProcessTerminationDelay;
> #endif
>@@ -49,16 +46,7 @@ bool StorageProcessCreationParameters::decode(IPC::Decoder& decoder, StorageProc
> {
>     if (!decoder.decode(result.sessionID))
>         return false;
>-#if ENABLE(INDEXED_DATABASE)
>-    if (!decoder.decode(result.indexedDatabaseDirectory))
>-        return false;
> 
>-    std::optional<SandboxExtension::Handle> indexedDatabaseDirectoryExtensionHandle;
>-    decoder >> indexedDatabaseDirectoryExtensionHandle;
>-    if (!indexedDatabaseDirectoryExtensionHandle)
>-        return false;
>-    result.indexedDatabaseDirectoryExtensionHandle = WTFMove(*indexedDatabaseDirectoryExtensionHandle);
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     if (!decoder.decode(result.serviceWorkerRegistrationDirectory))
>         return false;
>diff --git a/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.h b/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.h
>index fd97074f82166bc924b719e284d63a92785cab1e..986abeaab397d6b71758a8e3e847a7171a85117f 100644
>--- a/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.h
>+++ b/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.h
>@@ -44,11 +44,6 @@ struct StorageProcessCreationParameters {
>     static bool decode(IPC::Decoder&, StorageProcessCreationParameters&);
> 
>     PAL::SessionID sessionID;
>-    
>-#if ENABLE(INDEXED_DATABASE)
>-    String indexedDatabaseDirectory;
>-    SandboxExtension::Handle indexedDatabaseDirectoryExtensionHandle;
>-#endif
> 
> #if ENABLE(SERVICE_WORKER)
>     String serviceWorkerRegistrationDirectory;
>diff --git a/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp b/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp
>index 4bad5cda99841b5c9659c3df9c273cfdf257c175..1dfab647b6663d7d047ceb0a134327f8dcfb623f 100644
>--- a/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp
>+++ b/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp
>@@ -41,30 +41,55 @@ void WebsiteDataStoreParameters::encode(IPC::Encoder& encoder) const
>     encoder << uiProcessCookieStorageIdentifier;
>     encoder << cookieStoragePathExtensionHandle;
>     encoder << pendingCookies;
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    encoder << indexedDatabaseDirectory << indexedDatabaseDirectoryExtensionHandle;
>+#endif
> }
> 
> std::optional<WebsiteDataStoreParameters> WebsiteDataStoreParameters::decode(IPC::Decoder& decoder)
> {
>+    WebsiteDataStoreParameters parameters;
>+
>     std::optional<NetworkSessionCreationParameters> networkSessionParameters;
>     decoder >> networkSessionParameters;
>     if (!networkSessionParameters)
>         return std::nullopt;
>+    parameters.networkSessionParameters = WTFMove(*networkSessionParameters);
> 
>     std::optional<Vector<uint8_t>> uiProcessCookieStorageIdentifier;
>     decoder >> uiProcessCookieStorageIdentifier;
>     if (!uiProcessCookieStorageIdentifier)
>         return std::nullopt;
>+    parameters.uiProcessCookieStorageIdentifier = WTFMove(*uiProcessCookieStorageIdentifier);
> 
>     std::optional<SandboxExtension::Handle> cookieStoragePathExtensionHandle;
>     decoder >> cookieStoragePathExtensionHandle;
>     if (!cookieStoragePathExtensionHandle)
>         return std::nullopt;
>+    parameters.cookieStoragePathExtensionHandle = WTFMove(*cookieStoragePathExtensionHandle);
> 
>     std::optional<Vector<WebCore::Cookie>> pendingCookies;
>     decoder >> pendingCookies;
>     if (!pendingCookies)
>         return std::nullopt;
>-    return {{ WTFMove(*uiProcessCookieStorageIdentifier), WTFMove(*cookieStoragePathExtensionHandle), WTFMove(*pendingCookies), WTFMove(*networkSessionParameters)}};
>+    parameters.pendingCookies = WTFMove(*pendingCookies);
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    std::optional<String> indexedDatabaseDirectory;
>+    decoder >> indexedDatabaseDirectory;
>+    if (!indexedDatabaseDirectory)
>+        return std::nullopt;
>+    parameters.indexedDatabaseDirectory = WTFMove(*indexedDatabaseDirectory);
>+    
>+    std::optional<SandboxExtension::Handle> indexedDatabaseDirectoryExtensionHandle;
>+    decoder >> indexedDatabaseDirectoryExtensionHandle;
>+    if (!indexedDatabaseDirectoryExtensionHandle)
>+        return std::nullopt;
>+    parameters.indexedDatabaseDirectoryExtensionHandle = WTFMove(*indexedDatabaseDirectoryExtensionHandle);
>+#endif
>+
>+    return parameters;
> }
> 
> WebsiteDataStoreParameters WebsiteDataStoreParameters::privateSessionParameters(PAL::SessionID sessionID)
>@@ -74,7 +99,11 @@ WebsiteDataStoreParameters WebsiteDataStoreParameters::privateSessionParameters(
> #if PLATFORM(COCOA)
>         , nullptr , { } , { }
> #endif
>-    }};
>+        }
>+#if ENABLE(INDEXED_DATABASE)
>+        , { }, { }
>+#endif
>+    };
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/Shared/WebsiteDataStoreParameters.h b/Source/WebKit/Shared/WebsiteDataStoreParameters.h
>index abff503bf67854996291a7cc2c57e318e90346ad..f3d04037102ea08197b8a8d0b7db7896fe7db471 100644
>--- a/Source/WebKit/Shared/WebsiteDataStoreParameters.h
>+++ b/Source/WebKit/Shared/WebsiteDataStoreParameters.h
>@@ -55,6 +55,11 @@ struct WebsiteDataStoreParameters {
>     SandboxExtension::Handle cookieStoragePathExtensionHandle;
>     Vector<WebCore::Cookie> pendingCookies;
>     NetworkSessionCreationParameters networkSessionParameters;
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    String indexedDatabaseDirectory;
>+    SandboxExtension::Handle indexedDatabaseDirectoryExtensionHandle;
>+#endif
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/Sources.txt b/Source/WebKit/Sources.txt
>index 56a5c2bbbe9c6b560061b3a83439450d6861973d..d83245b958b68f99b68b96eac7d795176d4ca037 100644
>--- a/Source/WebKit/Sources.txt
>+++ b/Source/WebKit/Sources.txt
>@@ -47,6 +47,8 @@ NetworkProcess/Downloads/PendingDownload.cpp
> 
> NetworkProcess/FileAPI/NetworkBlobRegistry.cpp
> 
>+NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
>+
> NetworkProcess/cache/CacheStorageEngine.cpp
> NetworkProcess/cache/CacheStorageEngineCache.cpp
> NetworkProcess/cache/CacheStorageEngineCaches.cpp
>@@ -220,8 +222,6 @@ Shared/WebsiteData/WebsiteData.cpp
> StorageProcess/StorageProcess.cpp @no-unify
> StorageProcess/StorageToWebProcessConnection.cpp @no-unify
> 
>-StorageProcess/IndexedDB/WebIDBConnectionToClient.cpp @no-unify
>-
> StorageProcess/ServiceWorker/WebSWOriginStore.cpp @no-unify
> StorageProcess/ServiceWorker/WebSWServerConnection.cpp @no-unify
> StorageProcess/ServiceWorker/WebSWServerToContextConnection.cpp @no-unify
>diff --git a/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.cpp b/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.cpp
>deleted file mode 100644
>index bd0450105c0b876941259cfb5a227e9b011a59f1..0000000000000000000000000000000000000000
>--- a/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.cpp
>+++ /dev/null
>@@ -1,371 +0,0 @@
>-/*
>- * Copyright (C) 2016 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#include "config.h"
>-#include "WebIDBConnectionToClient.h"
>-
>-#if ENABLE(INDEXED_DATABASE)
>-
>-#include "DataReference.h"
>-#include "StorageProcess.h"
>-#include "WebCoreArgumentCoders.h"
>-#include "WebIDBConnectionToServerMessages.h"
>-#include "WebIDBResult.h"
>-#include <WebCore/IDBError.h>
>-#include <WebCore/IDBGetAllRecordsData.h>
>-#include <WebCore/IDBGetRecordData.h>
>-#include <WebCore/IDBResultData.h>
>-#include <WebCore/IDBValue.h>
>-#include <WebCore/ThreadSafeDataBuffer.h>
>-#include <WebCore/UniqueIDBDatabaseConnection.h>
>-
>-using namespace WebCore;
>-
>-namespace WebKit {
>-
>-Ref<WebIDBConnectionToClient> WebIDBConnectionToClient::create(StorageToWebProcessConnection& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
>-{
>-    return adoptRef(*new WebIDBConnectionToClient(connection, serverConnectionIdentifier, sessionID));
>-}
>-
>-WebIDBConnectionToClient::WebIDBConnectionToClient(StorageToWebProcessConnection& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
>-    : m_connection(connection)
>-    , m_identifier(serverConnectionIdentifier)
>-    , m_sessionID(sessionID)
>-{
>-    relaxAdoptionRequirement();
>-    m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
>-    StorageProcess::singleton().idbServer(m_sessionID).registerConnection(*m_connectionToClient);
>-}
>-
>-WebIDBConnectionToClient::~WebIDBConnectionToClient()
>-{
>-}
>-
>-void WebIDBConnectionToClient::disconnectedFromWebProcess()
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).unregisterConnection(*m_connectionToClient);
>-}
>-
>-IPC::Connection* WebIDBConnectionToClient::messageSenderConnection()
>-{
>-    return &m_connection->connection();
>-}
>-
>-WebCore::IDBServer::IDBConnectionToClient& WebIDBConnectionToClient::connectionToClient()
>-{
>-    return *m_connectionToClient;
>-}
>-
>-void WebIDBConnectionToClient::didDeleteDatabase(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidDeleteDatabase(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didOpenDatabase(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidOpenDatabase(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidAbortTransaction(transactionIdentifier, error));
>-}
>-
>-void WebIDBConnectionToClient::didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidCommitTransaction(transactionIdentifier, error));
>-}
>-
>-void WebIDBConnectionToClient::didCreateObjectStore(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidCreateObjectStore(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didDeleteObjectStore(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidDeleteObjectStore(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didRenameObjectStore(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidRenameObjectStore(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didClearObjectStore(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidClearObjectStore(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didCreateIndex(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidCreateIndex(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didDeleteIndex(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidDeleteIndex(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didRenameIndex(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidRenameIndex(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didPutOrAdd(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidPutOrAdd(resultData));
>-}
>-
>-template<class MessageType> void WebIDBConnectionToClient::handleGetResult(const WebCore::IDBResultData& resultData)
>-{
>-    if (resultData.type() == IDBResultType::Error) {
>-        send(MessageType(resultData));
>-        return;
>-    }
>-
>-    if (resultData.type() == IDBResultType::GetAllRecordsSuccess && resultData.getAllResult().type() == IndexedDB::GetAllType::Keys) {
>-        send(MessageType(resultData));
>-        return;
>-    }
>-
>-    auto blobFilePaths = resultData.type() == IDBResultType::GetAllRecordsSuccess ? resultData.getAllResult().allBlobFilePaths() : resultData.getResult().value().blobFilePaths();
>-    if (blobFilePaths.isEmpty()) {
>-        send(MessageType(resultData));
>-        return;
>-    }
>-
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-    StorageProcess::singleton().getSandboxExtensionsForBlobFiles(blobFilePaths, [protectedThis = makeRef(*this), this, resultData](SandboxExtension::HandleArray&& handles) {
>-        send(MessageType({ resultData, WTFMove(handles) }));
>-    });
>-#else
>-    send(MessageType(resultData));
>-#endif
>-}
>-
>-void WebIDBConnectionToClient::didGetRecord(const WebCore::IDBResultData& resultData)
>-{
>-    handleGetResult<Messages::WebIDBConnectionToServer::DidGetRecord>(resultData);
>-}
>-
>-void WebIDBConnectionToClient::didGetAllRecords(const WebCore::IDBResultData& resultData)
>-{
>-    handleGetResult<Messages::WebIDBConnectionToServer::DidGetAllRecords>(resultData);
>-}
>-
>-void WebIDBConnectionToClient::didGetCount(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidGetCount(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didDeleteRecord(const WebCore::IDBResultData& resultData)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidDeleteRecord(resultData));
>-}
>-
>-void WebIDBConnectionToClient::didOpenCursor(const WebCore::IDBResultData& resultData)
>-{
>-    handleGetResult<Messages::WebIDBConnectionToServer::DidOpenCursor>(resultData);
>-}
>-
>-void WebIDBConnectionToClient::didIterateCursor(const WebCore::IDBResultData& resultData)
>-{
>-    handleGetResult<Messages::WebIDBConnectionToServer::DidIterateCursor>(resultData);
>-}
>-
>-void WebIDBConnectionToClient::fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
>-{
>-    send(Messages::WebIDBConnectionToServer::FireVersionChangeEvent(connection.identifier(), requestIdentifier, requestedVersion));
>-}
>-
>-void WebIDBConnectionToClient::didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidStartTransaction(transactionIdentifier, error));
>-}
>-
>-void WebIDBConnectionToClient::didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBError& error)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidCloseFromServer(connection.identifier(), error));
>-}
>-
>-void WebIDBConnectionToClient::notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
>-{
>-    send(Messages::WebIDBConnectionToServer::NotifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion));
>-}
>-
>-void WebIDBConnectionToClient::didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames)
>-{
>-    send(Messages::WebIDBConnectionToServer::DidGetAllDatabaseNames(callbackID, databaseNames));
>-}
>-
>-void WebIDBConnectionToClient::deleteDatabase(const IDBRequestData& request)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).deleteDatabase(request);
>-}
>-
>-void WebIDBConnectionToClient::openDatabase(const IDBRequestData& request)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).openDatabase(request);
>-}
>-
>-void WebIDBConnectionToClient::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).abortTransaction(transactionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::commitTransaction(const IDBResourceIdentifier& transactionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).commitTransaction(transactionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::createObjectStore(const IDBRequestData& request, const IDBObjectStoreInfo& info)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).createObjectStore(request, info);
>-}
>-
>-void WebIDBConnectionToClient::deleteObjectStore(const IDBRequestData& request, const String& name)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).deleteObjectStore(request, name);
>-}
>-
>-void WebIDBConnectionToClient::renameObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& newName)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).renameObjectStore(request, objectStoreIdentifier, newName);
>-}
>-
>-void WebIDBConnectionToClient::clearObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).clearObjectStore(request, objectStoreIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::createIndex(const IDBRequestData& request, const IDBIndexInfo& info)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).createIndex(request, info);
>-}
>-
>-void WebIDBConnectionToClient::deleteIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& name)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).deleteIndex(request, objectStoreIdentifier, name);
>-}
>-
>-void WebIDBConnectionToClient::renameIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).renameIndex(request, objectStoreIdentifier, indexIdentifier, newName);
>-}
>-
>-void WebIDBConnectionToClient::putOrAdd(const IDBRequestData& request, const IDBKeyData& key, const IDBValue& value, unsigned overwriteMode)
>-{
>-    if (overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::NoOverwrite)
>-        && overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::Overwrite)
>-        && overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::OverwriteForCursor)) {
>-        // FIXME: This message from the WebProcess is corrupt.
>-        // The StorageProcess should return early at this point, but can we also kill the bad WebProcess?
>-        return;
>-    }
>-
>-    IndexedDB::ObjectStoreOverwriteMode mode = static_cast<IndexedDB::ObjectStoreOverwriteMode>(overwriteMode);
>-
>-    StorageProcess::singleton().idbServer(m_sessionID).putOrAdd(request, key, value, mode);
>-}
>-
>-void WebIDBConnectionToClient::getRecord(const IDBRequestData& request, const IDBGetRecordData& getRecordData)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).getRecord(request, getRecordData);
>-}
>-
>-void WebIDBConnectionToClient::getAllRecords(const IDBRequestData& request, const IDBGetAllRecordsData& getAllRecordsData)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).getAllRecords(request, getAllRecordsData);
>-}
>-
>-void WebIDBConnectionToClient::getCount(const IDBRequestData& request, const IDBKeyRangeData& range)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).getCount(request, range);
>-}
>-
>-void WebIDBConnectionToClient::deleteRecord(const IDBRequestData& request, const IDBKeyRangeData& range)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).deleteRecord(request, range);
>-}
>-
>-void WebIDBConnectionToClient::openCursor(const IDBRequestData& request, const IDBCursorInfo& info)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).openCursor(request, info);
>-}
>-
>-void WebIDBConnectionToClient::iterateCursor(const IDBRequestData& request, const IDBIterateCursorData& data)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).iterateCursor(request, data);
>-}
>-
>-void WebIDBConnectionToClient::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).establishTransaction(databaseConnectionIdentifier, info);
>-}
>-
>-void WebIDBConnectionToClient::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).databaseConnectionPendingClose(databaseConnectionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).databaseConnectionClosed(databaseConnectionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).didFireVersionChangeEvent(databaseConnectionIdentifier, transactionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::openDBRequestCancelled(const IDBRequestData& requestData)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).openDBRequestCancelled(requestData);
>-}
>-
>-void WebIDBConnectionToClient::confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).confirmDidCloseFromServer(databaseConnectionIdentifier);
>-}
>-
>-void WebIDBConnectionToClient::getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID)
>-{
>-    StorageProcess::singleton().idbServer(m_sessionID).getAllDatabaseNames(serverConnectionIdentifier, topOrigin, openingOrigin, callbackID);
>-}
>-
>-} // namespace WebKit
>-
>-#endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.h b/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.h
>deleted file mode 100644
>index 0087e8aa87c1625e3b98e9260713d72b39bec35e..0000000000000000000000000000000000000000
>--- a/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.h
>+++ /dev/null
>@@ -1,144 +0,0 @@
>-/*
>- * Copyright (C) 2016 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#pragma once
>-
>-#if ENABLE(INDEXED_DATABASE)
>-
>-#include "MessageSender.h"
>-#include "StorageToWebProcessConnection.h"
>-#include <WebCore/IDBConnectionToClient.h>
>-#include <pal/SessionID.h>
>-
>-namespace WebCore {
>-class IDBCursorInfo;
>-class IDBIndexInfo;
>-class IDBKeyData;
>-class IDBObjectStoreInfo;
>-class IDBRequestData;
>-class IDBTransactionInfo;
>-class IDBValue;
>-class SerializedScriptValue;
>-struct IDBGetAllRecordsData;
>-struct IDBGetRecordData;
>-struct IDBIterateCursorData;
>-struct IDBKeyRangeData;
>-struct SecurityOriginData;
>-}
>-
>-namespace WebKit {
>-
>-class WebIDBConnectionToClient final : public WebCore::IDBServer::IDBConnectionToClientDelegate, public IPC::MessageSender, public RefCounted<WebIDBConnectionToClient> {
>-public:
>-    static Ref<WebIDBConnectionToClient> create(StorageToWebProcessConnection&, uint64_t serverConnectionIdentifier, PAL::SessionID);
>-
>-    virtual ~WebIDBConnectionToClient();
>-
>-    WebCore::IDBServer::IDBConnectionToClient& connectionToClient();
>-    uint64_t identifier() const final { return m_identifier; }
>-    uint64_t messageSenderDestinationID() final { return m_identifier; }
>-
>-    // IDBConnectionToClientDelegate
>-    void didDeleteDatabase(const WebCore::IDBResultData&) final;
>-    void didOpenDatabase(const WebCore::IDBResultData&) final;
>-    void didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
>-    void didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
>-    void didCreateObjectStore(const WebCore::IDBResultData&) final;
>-    void didDeleteObjectStore(const WebCore::IDBResultData&) final;
>-    void didRenameObjectStore(const WebCore::IDBResultData&) final;
>-    void didClearObjectStore(const WebCore::IDBResultData&) final;
>-    void didCreateIndex(const WebCore::IDBResultData&) final;
>-    void didDeleteIndex(const WebCore::IDBResultData&) final;
>-    void didRenameIndex(const WebCore::IDBResultData&) final;
>-    void didPutOrAdd(const WebCore::IDBResultData&) final;
>-    void didGetRecord(const WebCore::IDBResultData&) final;
>-    void didGetAllRecords(const WebCore::IDBResultData&) final;
>-    void didGetCount(const WebCore::IDBResultData&) final;
>-    void didDeleteRecord(const WebCore::IDBResultData&) final;
>-    void didOpenCursor(const WebCore::IDBResultData&) final;
>-    void didIterateCursor(const WebCore::IDBResultData&) final;
>-
>-    void fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion) final;
>-    void didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final;
>-    void didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBError&) final;
>-    void notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion) final;
>-
>-    void didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames) final;
>-
>-    void ref() override { RefCounted<WebIDBConnectionToClient>::ref(); }
>-    void deref() override { RefCounted<WebIDBConnectionToClient>::deref(); }
>-
>-    // Messages received from WebProcess
>-    void deleteDatabase(const WebCore::IDBRequestData&);
>-    void openDatabase(const WebCore::IDBRequestData&);
>-    void abortTransaction(const WebCore::IDBResourceIdentifier&);
>-    void commitTransaction(const WebCore::IDBResourceIdentifier&);
>-    void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier&);
>-    void createObjectStore(const WebCore::IDBRequestData&, const WebCore::IDBObjectStoreInfo&);
>-    void deleteObjectStore(const WebCore::IDBRequestData&, const String& objectStoreName);
>-    void renameObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName);
>-    void clearObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier);
>-    void createIndex(const WebCore::IDBRequestData&, const WebCore::IDBIndexInfo&);
>-    void deleteIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName);
>-    void renameIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName);
>-    void putOrAdd(const WebCore::IDBRequestData&, const WebCore::IDBKeyData&, const WebCore::IDBValue&, unsigned overwriteMode);
>-    void getRecord(const WebCore::IDBRequestData&, const WebCore::IDBGetRecordData&);
>-    void getAllRecords(const WebCore::IDBRequestData&, const WebCore::IDBGetAllRecordsData&);
>-    void getCount(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&);
>-    void deleteRecord(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&);
>-    void openCursor(const WebCore::IDBRequestData&, const WebCore::IDBCursorInfo&);
>-    void iterateCursor(const WebCore::IDBRequestData&, const WebCore::IDBIterateCursorData&);
>-
>-    void establishTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBTransactionInfo&);
>-    void databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier);
>-    void databaseConnectionClosed(uint64_t databaseConnectionIdentifier);
>-    void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier);
>-    void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier);
>-    void openDBRequestCancelled(const WebCore::IDBRequestData&);
>-    void confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier);
>-
>-    void getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID);
>-
>-    void disconnectedFromWebProcess();
>-
>-    void didReceiveMessage(IPC::Connection&, IPC::Decoder&);
>-
>-private:
>-    WebIDBConnectionToClient(StorageToWebProcessConnection&, uint64_t serverConnectionIdentifier, PAL::SessionID);
>-
>-    IPC::Connection* messageSenderConnection() final;
>-
>-    template<class MessageType> void handleGetResult(const WebCore::IDBResultData&);
>-
>-    Ref<StorageToWebProcessConnection> m_connection;
>-
>-    uint64_t m_identifier;
>-    PAL::SessionID m_sessionID;
>-    RefPtr<WebCore::IDBServer::IDBConnectionToClient> m_connectionToClient;
>-};
>-
>-} // namespace WebKit
>-
>-#endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.messages.in b/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.messages.in
>deleted file mode 100644
>index 4aab0267d7b354326c57749e070082eeb83770f1..0000000000000000000000000000000000000000
>--- a/Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.messages.in
>+++ /dev/null
>@@ -1,56 +0,0 @@
>-# Copyright (C) 2016 Apple Inc. All rights reserved.
>-#
>-# Redistribution and use in source and binary forms, with or without
>-# modification, are permitted provided that the following conditions
>-# are met:
>-# 1.  Redistributions of source code must retain the above copyright
>-#     notice, this list of conditions and the following disclaimer.
>-# 2.  Redistributions in binary form must reproduce the above copyright
>-#     notice, this list of conditions and the following disclaimer in the
>-#     documentation and/or other materials provided with the distribution.
>-#
>-# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
>-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
>-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
>-# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
>-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
>-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
>-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
>-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>-
>-#if ENABLE(INDEXED_DATABASE)
>-
>-messages -> WebIDBConnectionToClient {
>-    DeleteDatabase(WebCore::IDBRequestData requestData)
>-    OpenDatabase(WebCore::IDBRequestData requestData);
>-    AbortTransaction(WebCore::IDBResourceIdentifier transactionIdentifier);
>-    CommitTransaction(WebCore::IDBResourceIdentifier transactionIdentifier);
>-    DidFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier);
>-    CreateObjectStore(WebCore::IDBRequestData requestData, WebCore::IDBObjectStoreInfo info);
>-    DeleteObjectStore(WebCore::IDBRequestData requestData, String objectStoreName);
>-    RenameObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String newName);
>-    ClearObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier);
>-    CreateIndex(WebCore::IDBRequestData requestData, WebCore::IDBIndexInfo info);
>-    DeleteIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String indexName);
>-    RenameIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, String newName);
>-    PutOrAdd(WebCore::IDBRequestData requestData, WebCore::IDBKeyData key, WebCore::IDBValue value, unsigned overwriteMode);
>-    GetRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBGetRecordData getRecordData);
>-    GetAllRecords(WebCore::IDBRequestData requestData, struct WebCore::IDBGetAllRecordsData getAllRecordsData);
>-    GetCount(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range);
>-    DeleteRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range);
>-    OpenCursor(WebCore::IDBRequestData requestData, WebCore::IDBCursorInfo info);
>-    IterateCursor(WebCore::IDBRequestData requestData, struct WebCore::IDBIterateCursorData data);
>-
>-    EstablishTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBTransactionInfo info);
>-    DatabaseConnectionPendingClose(uint64_t databaseConnectionIdentifier);
>-    DatabaseConnectionClosed(uint64_t databaseConnectionIdentifier);
>-    AbortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier);
>-    DidFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier requestIdentifier);
>-    OpenDBRequestCancelled(WebCore::IDBRequestData requestData);
>-    ConfirmDidCloseFromServer(uint64_t databaseConnectionIdentifier);
>-
>-    GetAllDatabaseNames(uint64_t serverConnectionIdentifier, struct WebCore::SecurityOriginData topOrigin, struct WebCore::SecurityOriginData openingOrigin, uint64_t callbackID);
>-}
>-#endif // ENABLE(INDEXED_DATABASE)
>diff --git a/Source/WebKit/StorageProcess/StorageProcess.cpp b/Source/WebKit/StorageProcess/StorageProcess.cpp
>index 77e3cc176c1cfe235efc1a1e16d7ccb56b88217e..791dbb1000646fb1c1ae1c36729d7d189ec3f8f4 100644
>--- a/Source/WebKit/StorageProcess/StorageProcess.cpp
>+++ b/Source/WebKit/StorageProcess/StorageProcess.cpp
>@@ -38,7 +38,6 @@
> #include "WebSWServerToContextConnection.h"
> #include "WebsiteData.h"
> #include <WebCore/FileSystem.h>
>-#include <WebCore/IDBKeyData.h>
> #include <WebCore/NotImplemented.h>
> #include <WebCore/SWServerWorker.h>
> #include <WebCore/SecurityOrigin.h>
>@@ -152,46 +151,13 @@ void StorageProcess::didReceiveMessage(IPC::Connection& connection, IPC::Decoder
> #endif
> }
> 
>-#if ENABLE(INDEXED_DATABASE)
>-IDBServer::IDBServer& StorageProcess::idbServer(PAL::SessionID sessionID)
>-{
>-    auto addResult = m_idbServers.add(sessionID, nullptr);
>-    if (!addResult.isNewEntry) {
>-        ASSERT(addResult.iterator->value);
>-        return *addResult.iterator->value;
>-    }
>-
>-    auto path = m_idbDatabasePaths.get(sessionID);
>-    // There should already be a registered path for this PAL::SessionID.
>-    // If there's not, then where did this PAL::SessionID come from?
>-    ASSERT(!path.isEmpty());
>-
>-    addResult.iterator->value = IDBServer::IDBServer::create(path, StorageProcess::singleton());
>-    return *addResult.iterator->value;
>-}
>-#endif
>-
> void StorageProcess::initializeWebsiteDataStore(const StorageProcessCreationParameters& parameters)
> {
>-#if ENABLE(INDEXED_DATABASE)
>-    // *********
>-    // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
>-    // *********
>-
>-    auto addResult = m_idbDatabasePaths.ensure(parameters.sessionID, [path = parameters.indexedDatabaseDirectory] {
>-        return path;
>-    });
>-    if (addResult.isNewEntry) {
>-        SandboxExtension::consumePermanently(parameters.indexedDatabaseDirectoryExtensionHandle);
>-        if (!parameters.indexedDatabaseDirectory.isEmpty())
>-            postStorageTask(createCrossThreadTask(*this, &StorageProcess::ensurePathExists, parameters.indexedDatabaseDirectory));
>-    }
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     if (!parentProcessHasServiceWorkerEntitlement())
>         return;
> 
>-    addResult = m_swDatabasePaths.ensure(parameters.sessionID, [path = parameters.serviceWorkerRegistrationDirectory] {
>+    auto addResult = m_swDatabasePaths.ensure(parameters.sessionID, [path = parameters.serviceWorkerRegistrationDirectory] {
>         return path;
>     });
>     if (addResult.isNewEntry) {
>@@ -324,19 +290,6 @@ void StorageProcess::fetchWebsiteData(PAL::SessionID sessionID, OptionSet<Websit
>         });
>     }
> #endif
>-
>-#if ENABLE(INDEXED_DATABASE)
>-    path = m_idbDatabasePaths.get(sessionID);
>-    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
>-        // FIXME: Pick the right database store based on the session ID.
>-        postStorageTask(CrossThreadTask([this, callbackAggregator = callbackAggregator.copyRef(), path = WTFMove(path), rawWebsiteData]() mutable {
>-            RunLoop::main().dispatch([callbackAggregator = WTFMove(callbackAggregator), rawWebsiteData, securityOrigins = indexedDatabaseOrigins(path)] {
>-                for (const auto& securityOrigin : securityOrigins)
>-                    rawWebsiteData->entries.append({ securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
>-            });
>-        }));
>-    }
>-#endif
> }
> 
> void StorageProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, WallTime modifiedSince, uint64_t callbackID)
>@@ -349,11 +302,6 @@ void StorageProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<Websi
>     if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations))
>         swServerForSession(sessionID).clearAll([callbackAggregator = callbackAggregator.copyRef()] { });
> #endif
>-
>-#if ENABLE(INDEXED_DATABASE)
>-    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
>-        idbServer(sessionID).closeAndDeleteDatabasesModifiedSince(modifiedSince, [callbackAggregator = WTFMove(callbackAggregator)] { });
>-#endif
> }
> 
> void StorageProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<SecurityOriginData>& securityOrigins, uint64_t callbackID)
>@@ -369,82 +317,7 @@ void StorageProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, Optio
>             server.clear(securityOrigin, [callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> #endif
>-
>-#if ENABLE(INDEXED_DATABASE)
>-    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
>-        idbServer(sessionID).closeAndDeleteDatabasesForOrigins(securityOrigins, [callbackAggregator = WTFMove(callbackAggregator)] { });
>-#endif
>-}
>-
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-void StorageProcess::grantSandboxExtensionsForBlobs(const Vector<String>& paths, SandboxExtension::HandleArray&& handles)
>-{
>-    ASSERT(paths.size() == handles.size());
>-
>-    for (size_t i = 0; i < paths.size(); ++i) {
>-        auto result = m_blobTemporaryFileSandboxExtensions.add(paths[i], SandboxExtension::create(WTFMove(handles[i])));
>-        ASSERT_UNUSED(result, result.isNewEntry);
>-    }
>-}
>-#endif
>-
>-#if ENABLE(INDEXED_DATABASE)
>-void StorageProcess::prepareForAccessToTemporaryFile(const String& path)
>-{
>-    if (auto extension = m_blobTemporaryFileSandboxExtensions.get(path))
>-        extension->consume();
>-}
>-
>-void StorageProcess::accessToTemporaryFileComplete(const String& path)
>-{
>-    // We've either hard linked the temporary blob file to the database directory, copied it there,
>-    // or the transaction is being aborted.
>-    // In any of those cases, we can delete the temporary blob file now.
>-    FileSystem::deleteFile(path);
>-
>-    if (auto extension = m_blobTemporaryFileSandboxExtensions.take(path))
>-        extension->revoke();
>-}
>-
>-HashSet<WebCore::SecurityOriginData> StorageProcess::indexedDatabaseOrigins(const String& path)
>-{
>-    if (path.isEmpty())
>-        return { };
>-
>-    HashSet<WebCore::SecurityOriginData> securityOrigins;
>-    for (auto& topOriginPath : FileSystem::listDirectory(path, "*")) {
>-        auto databaseIdentifier = FileSystem::pathGetFileName(topOriginPath);
>-        if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
>-            securityOrigins.add(WTFMove(*securityOrigin));
>-        
>-        for (auto& originPath : FileSystem::listDirectory(topOriginPath, "*")) {
>-            databaseIdentifier = FileSystem::pathGetFileName(originPath);
>-            if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
>-                securityOrigins.add(WTFMove(*securityOrigin));
>-        }
>-    }
>-
>-    return securityOrigins;
>-}
>-
>-#endif
>-
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-void StorageProcess::getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void (SandboxExtension::HandleArray&&)>&& completionHandler)
>-{
>-    static uint64_t lastRequestID;
>-
>-    uint64_t requestID = ++lastRequestID;
>-    m_sandboxExtensionForBlobsCompletionHandlers.set(requestID, WTFMove(completionHandler));
>-    parentProcessConnection()->send(Messages::StorageProcessProxy::GetSandboxExtensionsForBlobFiles(requestID, filenames), 0);
>-}
>-
>-void StorageProcess::didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&& handles)
>-{
>-    if (auto handler = m_sandboxExtensionForBlobsCompletionHandlers.take(requestID))
>-        handler(WTFMove(handles));
> }
>-#endif
> 
> #if ENABLE(SERVICE_WORKER)
> SWServer& StorageProcess::swServerForSession(PAL::SessionID sessionID)
>diff --git a/Source/WebKit/StorageProcess/StorageProcess.h b/Source/WebKit/StorageProcess/StorageProcess.h
>index d86614fbfa2002e14e30c7ed9c64ddfd887ff0fb..e0d5da1d38fc51de0563a13902d33cd10ef9139c 100644
>--- a/Source/WebKit/StorageProcess/StorageProcess.h
>+++ b/Source/WebKit/StorageProcess/StorageProcess.h
>@@ -26,14 +26,10 @@
> #pragma once
> 
> #include "ChildProcess.h"
>-#include "SandboxExtension.h"
> #include <WebCore/FetchIdentifier.h>
>-#include <WebCore/IDBBackingStore.h>
>-#include <WebCore/IDBServer.h>
> #include <WebCore/SecurityOriginData.h>
> #include <WebCore/ServiceWorkerIdentifier.h>
> #include <WebCore/ServiceWorkerTypes.h>
>-#include <WebCore/UniqueIDBDatabase.h>
> #include <pal/SessionID.h>
> #include <wtf/CrossThreadTask.h>
> #include <wtf/Function.h>
>@@ -63,9 +59,6 @@ class WebSWOriginStore;
> #endif
> 
> class StorageProcess : public ChildProcess
>-#if ENABLE(INDEXED_DATABASE)
>-    , public WebCore::IDBServer::IDBBackingStoreTemporaryFileHandler
>-#endif
> {
>     WTF_MAKE_NONCOPYABLE(StorageProcess);
>     friend NeverDestroyed<StorageProcess>;
>@@ -75,21 +68,8 @@ public:
> 
>     ~StorageProcess();
> 
>-    WorkQueue& queue() { return m_queue.get(); }
>     void postStorageTask(CrossThreadTask&&);
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    WebCore::IDBServer::IDBServer& idbServer(PAL::SessionID);
>-
>-    // WebCore::IDBServer::IDBBackingStoreFileHandler
>-    void prepareForAccessToTemporaryFile(const String& path) final;
>-    void accessToTemporaryFileComplete(const String& path) final;
>-#endif
>-
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-    void getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void (SandboxExtension::HandleArray&&)>&& completionHandler);
>-#endif
>-
> #if PLATFORM(IOS)
>     bool parentProcessHasServiceWorkerEntitlement() const;
> #else
>@@ -135,10 +115,7 @@ private:
>     void fetchWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, uint64_t callbackID);
>     void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, WallTime modifiedSince, uint64_t callbackID);
>     void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<WebCore::SecurityOriginData>& origins, uint64_t callbackID);
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-    void grantSandboxExtensionsForBlobs(const Vector<String>& paths, SandboxExtension::HandleArray&&);
>-    void didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&&);
>-#endif
>+
> #if ENABLE(SERVICE_WORKER)
>     void didReceiveFetchResponse(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const WebCore::ResourceResponse&);
>     void didReceiveFetchData(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const IPC::DataReference&, int64_t encodedDataLength);
>@@ -156,9 +133,6 @@ private:
>     WebSWOriginStore* existingSWOriginStoreForSession(PAL::SessionID) const;
>     bool needsServerToContextConnectionForOrigin(const WebCore::SecurityOriginData&) const;
> #endif
>-#if ENABLE(INDEXED_DATABASE)
>-    HashSet<WebCore::SecurityOriginData> indexedDatabaseOrigins(const String& path);
>-#endif
> 
>     // For execution on work queue thread only
>     void performNextStorageTask();
>@@ -168,13 +142,6 @@ private:
> 
>     Ref<WorkQueue> m_queue;
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    HashMap<PAL::SessionID, String> m_idbDatabasePaths;
>-    HashMap<PAL::SessionID, RefPtr<WebCore::IDBServer::IDBServer>> m_idbServers;
>-#endif
>-    HashMap<String, RefPtr<SandboxExtension>> m_blobTemporaryFileSandboxExtensions;
>-    HashMap<uint64_t, WTF::Function<void (SandboxExtension::HandleArray&&)>> m_sandboxExtensionForBlobsCompletionHandlers;
>-
>     Deque<CrossThreadTask> m_storageTasks;
>     Lock m_storageTaskMutex;
>     
>diff --git a/Source/WebKit/StorageProcess/StorageProcess.messages.in b/Source/WebKit/StorageProcess/StorageProcess.messages.in
>index 8190be31371faa7fe64f182f3e3d8611025098fc..ac939bbfd899737db5bec36dd399fcb7ada4a3d0 100644
>--- a/Source/WebKit/StorageProcess/StorageProcess.messages.in
>+++ b/Source/WebKit/StorageProcess/StorageProcess.messages.in
>@@ -30,10 +30,6 @@ messages -> StorageProcess LegacyReceiver {
>     FetchWebsiteData(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes, uint64_t callbackID)
>     DeleteWebsiteData(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes, WallTime modifiedSince, uint64_t callbackID)
>     DeleteWebsiteDataForOrigins(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes, Vector<WebCore::SecurityOriginData> origins, uint64_t callbackID)
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-    GrantSandboxExtensionsForBlobs(Vector<String> paths, WebKit::SandboxExtension::HandleArray extensions)
>-    DidGetSandboxExtensionsForBlobFiles(uint64_t requestID, WebKit::SandboxExtension::HandleArray extensions)
>-#endif
> 
>     DestroySession(PAL::SessionID sessionID)
> 
>diff --git a/Source/WebKit/StorageProcess/StorageToWebProcessConnection.cpp b/Source/WebKit/StorageProcess/StorageToWebProcessConnection.cpp
>index 240df703e743f3f9c4bb5b8d7cbeb7999ea77d6d..2c53711b617825ae2a2917a772ec44ae8ac459de 100644
>--- a/Source/WebKit/StorageProcess/StorageToWebProcessConnection.cpp
>+++ b/Source/WebKit/StorageProcess/StorageToWebProcessConnection.cpp
>@@ -30,8 +30,6 @@
> #include "StorageProcess.h"
> #include "StorageProcessMessages.h"
> #include "StorageToWebProcessConnectionMessages.h"
>-#include "WebIDBConnectionToClient.h"
>-#include "WebIDBConnectionToClientMessages.h"
> #include "WebSWServerConnection.h"
> #include "WebSWServerConnectionMessages.h"
> #include <wtf/RunLoop.h>
>@@ -69,25 +67,11 @@ StorageToWebProcessConnection::~StorageToWebProcessConnection()
> 
> void StorageToWebProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
> {
>-    if (decoder.messageReceiverName() == Messages::StorageToWebProcessConnection::messageReceiverName()) {
>-        didReceiveStorageToWebProcessConnectionMessage(connection, decoder);
>-        return;
>-    }
>-
>     if (decoder.messageReceiverName() == Messages::StorageProcess::messageReceiverName()) {
>         StorageProcess::singleton().didReceiveStorageProcessMessage(connection, decoder);
>         return;
>     }
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    if (decoder.messageReceiverName() == Messages::WebIDBConnectionToClient::messageReceiverName()) {
>-        auto iterator = m_webIDBConnections.find(decoder.destinationID());
>-        if (iterator != m_webIDBConnections.end())
>-            iterator->value->didReceiveMessage(connection, decoder);
>-        return;
>-    }
>-#endif
>-
> #if ENABLE(SERVICE_WORKER)
>     if (decoder.messageReceiverName() == Messages::WebSWServerConnection::messageReceiverName()) {
>         if (auto swConnection = m_swConnections.get(makeObjectIdentifier<SWServerConnectionIdentifierType>(decoder.destinationID())))
>@@ -136,14 +120,6 @@ void StorageToWebProcessConnection::didClose(IPC::Connection& connection)
>     }
> #endif
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    auto idbConnections = m_webIDBConnections;
>-    for (auto& connection : idbConnections.values())
>-        connection->disconnectedFromWebProcess();
>-
>-    m_webIDBConnections.clear();
>-#endif
>-
> #if ENABLE(SERVICE_WORKER)
>     unregisterSWConnections();
> #endif
>@@ -180,30 +156,4 @@ void StorageToWebProcessConnection::establishSWServerConnection(SessionID sessio
> 
> #endif
> 
>-#if ENABLE(INDEXED_DATABASE)
>-static uint64_t generateIDBConnectionToServerIdentifier()
>-{
>-    ASSERT(RunLoop::isMain());
>-    static uint64_t identifier = 0;
>-    return ++identifier;
>-}
>-
>-void StorageToWebProcessConnection::establishIDBConnectionToServer(SessionID sessionID, uint64_t& serverConnectionIdentifier)
>-{
>-    serverConnectionIdentifier = generateIDBConnectionToServerIdentifier();
>-    LOG(IndexedDB, "StorageToWebProcessConnection::establishIDBConnectionToServer - %" PRIu64, serverConnectionIdentifier);
>-    ASSERT(!m_webIDBConnections.contains(serverConnectionIdentifier));
>-
>-    m_webIDBConnections.set(serverConnectionIdentifier, WebIDBConnectionToClient::create(*this, serverConnectionIdentifier, sessionID));
>-}
>-
>-void StorageToWebProcessConnection::removeIDBConnectionToServer(uint64_t serverConnectionIdentifier)
>-{
>-    ASSERT(m_webIDBConnections.contains(serverConnectionIdentifier));
>-
>-    auto connection = m_webIDBConnections.take(serverConnectionIdentifier);
>-    connection->disconnectedFromWebProcess();
>-}
>-#endif
>-
> } // namespace WebKit
>diff --git a/Source/WebKit/StorageProcess/StorageToWebProcessConnection.h b/Source/WebKit/StorageProcess/StorageToWebProcessConnection.h
>index b90767b769c596f816585d25d5dde7b68322a98d..7687e06d6ab02b5414a21ef8c64bb1aa6e8be758 100644
>--- a/Source/WebKit/StorageProcess/StorageToWebProcessConnection.h
>+++ b/Source/WebKit/StorageProcess/StorageToWebProcessConnection.h
>@@ -34,7 +34,6 @@
> 
> namespace WebKit {
> 
>-class WebIDBConnectionToClient;
> class WebSWServerConnection;
> class WebSWServerToContextConnection;
> 
>@@ -60,14 +59,6 @@ private:
>     IPC::Connection* messageSenderConnection() override { return m_connection.ptr(); }
>     uint64_t messageSenderDestinationID() override { return 0; }
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    // Messages handlers (Modern IDB)
>-    void establishIDBConnectionToServer(PAL::SessionID, uint64_t& serverConnectionIdentifier);
>-    void removeIDBConnectionToServer(uint64_t serverConnectionIdentifier);
>-
>-    HashMap<uint64_t, RefPtr<WebIDBConnectionToClient>> m_webIDBConnections;
>-#endif // ENABLE(INDEXED_DATABASE)
>-
> #if ENABLE(SERVICE_WORKER)
>     void establishSWServerConnection(PAL::SessionID, WebCore::SWServerConnectionIdentifier&);
>     void unregisterSWConnections();
>diff --git a/Source/WebKit/StorageProcess/StorageToWebProcessConnection.messages.in b/Source/WebKit/StorageProcess/StorageToWebProcessConnection.messages.in
>index 1536b6d8cd1b9702c6d2525249440aee53dbdb81..0d4f9b154375e1c5c1c5f72eeacdc6c6a8b7be7e 100644
>--- a/Source/WebKit/StorageProcess/StorageToWebProcessConnection.messages.in
>+++ b/Source/WebKit/StorageProcess/StorageToWebProcessConnection.messages.in
>@@ -21,10 +21,6 @@
> # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
> messages -> StorageToWebProcessConnection LegacyReceiver {
>-#if ENABLE(INDEXED_DATABASE)
>-    EstablishIDBConnectionToServer(PAL::SessionID sessionID) -> (uint64_t serverConnectionIdentifier)
>-    RemoveIDBConnectionToServer(uint64_t serverConnectionIdentifier)
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     EstablishSWServerConnection(PAL::SessionID sessionID) -> (WebCore::SWServerConnectionIdentifier serverConnectionIdentifier)
> #endif
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>index 61b604d9deac13ed6dee8fee366d42977531986b..56bfcac38d1d842c78d2968a70f9f321f2eb0582 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>@@ -325,21 +325,6 @@ void NetworkProcessProxy::didDeleteWebsiteDataForOrigins(uint64_t callbackID)
>     callback();
> }
> 
>-void NetworkProcessProxy::grantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID, const Vector<String>& paths)
>-{
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-    SandboxExtension::HandleArray extensions;
>-    extensions.allocate(paths.size());
>-    for (size_t i = 0; i < paths.size(); ++i) {
>-        // ReadWrite is required for creating hard links as well as deleting the temporary file, which the StorageProcess will do.
>-        SandboxExtension::createHandle(paths[i], SandboxExtension::Type::ReadWrite, extensions[i]);
>-    }
>-
>-    m_processPool.sendToStorageProcessRelaunchingIfNecessary(Messages::StorageProcess::GrantSandboxExtensionsForBlobs(paths, extensions));
>-#endif
>-    connection()->send(Messages::NetworkProcess::DidGrantSandboxExtensionsToStorageProcessForBlobs(requestID), 0);
>-}
>-
> void NetworkProcessProxy::didFinishLaunching(ProcessLauncher* launcher, IPC::Connection::Identifier connectionIdentifier)
> {
>     ChildProcessProxy::didFinishLaunching(launcher, connectionIdentifier);
>@@ -645,6 +630,20 @@ void NetworkProcessProxy::sendProcessDidTransitionToBackground()
>     send(Messages::NetworkProcess::ProcessDidTransitionToBackground(), 0);
> }
> 
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+void NetworkProcessProxy::getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths)
>+{
>+    SandboxExtension::HandleArray extensions;
>+    extensions.allocate(paths.size());
>+    for (size_t i = 0; i < paths.size(); ++i) {
>+        // ReadWrite is required for creating hard links, which is something that might be done with these extensions.
>+        SandboxExtension::createHandle(paths[i], SandboxExtension::Type::ReadWrite, extensions[i]);
>+    }
>+    
>+    send(Messages::NetworkProcess::DidGetSandboxExtensionsForBlobFiles(requestID, extensions), 0);
>+}
>+#endif
>+
> } // namespace WebKit
> 
> #undef MESSAGE_CHECK
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>index b7a3f0218b07b40c6d705f273fd21a3b03501889..8354026d520600ff1d36dee4a3fc1f22891e4d1a 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>@@ -139,7 +139,6 @@ private:
>     void didDeleteWebsiteData(uint64_t callbackID);
>     void didDeleteWebsiteDataForOrigins(uint64_t callbackID);
>     void didWriteBlobToFilePath(bool success, uint64_t callbackID);
>-    void grantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID, const Vector<String>& paths);
>     void logDiagnosticMessage(uint64_t pageID, const String& message, const String& description, WebCore::ShouldSample);
>     void logDiagnosticMessageWithResult(uint64_t pageID, const String& message, const String& description, uint32_t result, WebCore::ShouldSample);
>     void logDiagnosticMessageWithValue(uint64_t pageID, const String& message, const String& description, double value, unsigned significantFigures, WebCore::ShouldSample);
>@@ -155,6 +154,10 @@ private:
>     void contentExtensionRules(UserContentControllerIdentifier);
> #endif
> 
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+    void getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths);
>+#endif
>+
>     // ProcessLauncher::Client
>     void didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier) override;
> 
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>index b786a4f295260165ca269b4c2859fc6c1363b10b..512dff20da3732f1b9bea711d73a347405abffbd 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>@@ -33,8 +33,6 @@ messages -> NetworkProcessProxy LegacyReceiver {
> 
>     DidWriteBlobToFilePath(bool success, uint64_t callbackID)
> 
>-    GrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID, Vector<String> paths)
>-
>     ProcessReadyToSuspend()
>     SetIsHoldingLockedFiles(bool isHoldingLockedFiles)
> 
>@@ -54,4 +52,8 @@ messages -> NetworkProcessProxy LegacyReceiver {
> #endif
> 
>     RetrieveCacheStorageParameters(PAL::SessionID sessionID)
>+
>+#if ENABLE(SANDBOX_EXTENSIONS)
>+    GetSandboxExtensionsForBlobFiles(uint64_t requestID, Vector<String> paths)
>+#endif
> }
>diff --git a/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp b/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp
>index efa8d13cbbd5ffa808b5f0edbf4a51dc9df857e7..33c3fb7ee724bb0da8b1444881d8d1b097ceaffe 100644
>--- a/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp
>@@ -221,20 +221,6 @@ void StorageProcessProxy::didDeleteWebsiteDataForOrigins(uint64_t callbackID)
>     callback();
> }
> 
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-void StorageProcessProxy::getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths)
>-{
>-    SandboxExtension::HandleArray extensions;
>-    extensions.allocate(paths.size());
>-    for (size_t i = 0; i < paths.size(); ++i) {
>-        // ReadWrite is required for creating hard links, which is something that might be done with these extensions.
>-        SandboxExtension::createHandle(paths[i], SandboxExtension::Type::ReadWrite, extensions[i]);
>-    }
>-
>-    send(Messages::StorageProcess::DidGetSandboxExtensionsForBlobFiles(requestID, extensions), 0);
>-}
>-#endif
>-
> void StorageProcessProxy::didFinishLaunching(ProcessLauncher* launcher, IPC::Connection::Identifier connectionIdentifier)
> {
>     ChildProcessProxy::didFinishLaunching(launcher, connectionIdentifier);
>diff --git a/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h b/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h
>index afc38446c91a2978d194bc3fb45df47ba7de0425..a266c77eec83f76465d19e1506282c79910a9d67 100644
>--- a/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h
>+++ b/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h
>@@ -79,9 +79,6 @@ private:
>     void didFetchWebsiteData(uint64_t callbackID, const WebsiteData&);
>     void didDeleteWebsiteData(uint64_t callbackID);
>     void didDeleteWebsiteDataForOrigins(uint64_t callbackID);
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-    void getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths);
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     void establishWorkerContextConnectionToStorageProcess(WebCore::SecurityOriginData&&);
>     void establishWorkerContextConnectionToStorageProcessForExplicitSession(WebCore::SecurityOriginData&&, PAL::SessionID);
>diff --git a/Source/WebKit/UIProcess/Storage/StorageProcessProxy.messages.in b/Source/WebKit/UIProcess/Storage/StorageProcessProxy.messages.in
>index 22e839d6cb8237379083312a78220fc5d417226b..6d4ea7c8db1e63d993c16f8b5d8d6d31f0790359 100644
>--- a/Source/WebKit/UIProcess/Storage/StorageProcessProxy.messages.in
>+++ b/Source/WebKit/UIProcess/Storage/StorageProcessProxy.messages.in
>@@ -27,10 +27,6 @@ messages -> StorageProcessProxy LegacyReceiver {
>     DidDeleteWebsiteData(uint64_t callbackID)
>     DidDeleteWebsiteDataForOrigins(uint64_t callbackID)
> 
>-#if ENABLE(SANDBOX_EXTENSIONS)
>-    GetSandboxExtensionsForBlobFiles(uint64_t requestID, Vector<String> paths)
>-#endif
>-
> #if ENABLE(SERVICE_WORKER)
>     EstablishWorkerContextConnectionToStorageProcess(struct WebCore::SecurityOriginData origin)
>     EstablishWorkerContextConnectionToStorageProcessForExplicitSession(struct WebCore::SecurityOriginData origin, PAL::SessionID explicitSession)
>diff --git a/Source/WebKit/UIProcess/WebProcessPool.cpp b/Source/WebKit/UIProcess/WebProcessPool.cpp
>index 46b7680e064224fac84c91afaf5b7a237de02ef0..eb862eb247b59bdcb3355ac4e87b0f1b1e38a24b 100644
>--- a/Source/WebKit/UIProcess/WebProcessPool.cpp
>+++ b/Source/WebKit/UIProcess/WebProcessPool.cpp
>@@ -537,6 +537,17 @@ NetworkProcessProxy& WebProcessPool::ensureNetworkProcess(WebsiteDataStore* with
>     parameters.urlSchemesRegisteredAsCORSEnabled = copyToVector(m_schemesToRegisterAsCORSEnabled);
>     parameters.urlSchemesRegisteredAsCanDisplayOnlyIfCanRequest = copyToVector(m_schemesToRegisterAsCanDisplayOnlyIfCanRequest);
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    // *********
>+    // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
>+    // *********
>+    parameters.indexedDatabaseDirectory = m_configuration->indexedDBDatabaseDirectory();
>+    if (parameters.indexedDatabaseDirectory.isEmpty())
>+        parameters.indexedDatabaseDirectory = API::WebsiteDataStore::defaultDataStore()->websiteDataStore().parameters().indexedDatabaseDirectory;
>+    
>+    SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
>+#endif
>+
>     // Add any platform specific parameters
>     platformInitializeNetworkProcess(parameters);
> 
>@@ -597,21 +608,11 @@ void WebProcessPool::getNetworkProcessConnection(Messages::WebProcessProxy::GetN
> 
> void WebProcessPool::ensureStorageProcessAndWebsiteDataStore(WebsiteDataStore* relevantDataStore)
> {
>-    // *********
>-    // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
>-    // *********
>-
>     if (!m_storageProcess) {
>         auto parameters = m_websiteDataStore ? m_websiteDataStore->websiteDataStore().storageProcessParameters() : (relevantDataStore ? relevantDataStore->storageProcessParameters() : API::WebsiteDataStore::defaultDataStore()->websiteDataStore().storageProcessParameters());
> 
>         ASSERT(parameters.sessionID.isValid());
> 
>-#if ENABLE(INDEXED_DATABASE)
>-        if (parameters.indexedDatabaseDirectory.isEmpty()) {
>-            parameters.indexedDatabaseDirectory = m_configuration->indexedDBDatabaseDirectory();
>-            SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
>-        }
>-#endif
> #if ENABLE(SERVICE_WORKER)
>         if (parameters.serviceWorkerRegistrationDirectory.isEmpty()) {
>             parameters.serviceWorkerRegistrationDirectory = API::WebsiteDataStore::defaultServiceWorkerRegistrationDirectory();
>@@ -1230,9 +1231,8 @@ void WebProcessPool::pageBeginUsingWebsiteDataStore(WebPageProxy& page)
>         page.process().send(Messages::WebProcess::AddWebsiteDataStore(page.websiteDataStore().parameters()), 0);
>         page.websiteDataStore().clearPendingCookies();
> 
>-#if ENABLE(INDEXED_DATABASE)
>-        if (!page.websiteDataStore().resolvedIndexedDatabaseDirectory().isEmpty())
>-            ensureStorageProcessAndWebsiteDataStore(&page.websiteDataStore());
>+#if ENABLE(SERVICE_WORKER)
>+        ensureStorageProcessAndWebsiteDataStore(&page.websiteDataStore());
> #endif
>     }
> 
>diff --git a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>index 978be62bb9470852bd3dc50a1ca826390f758e1d..5b1536d2e3000a84f06edc75201cc4a13dd0b930 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>+++ b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>@@ -85,6 +85,12 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
>     if (!cookieFile.isEmpty())
>         SandboxExtension::createHandleForReadWriteDirectory(WebCore::FileSystem::directoryName(cookieFile), parameters.cookieStoragePathExtensionHandle);
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    parameters.indexedDatabaseDirectory = resolvedIndexedDatabaseDirectory();
>+    if (!parameters.indexedDatabaseDirectory.isEmpty())
>+        SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
>+#endif
>+
>     return parameters;
> }
> 
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>index a1372b1d7dd8be1b6dffc8be1a959707f70dff97..df21776daaf588072e75f511c671b94f9df70c8c 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>@@ -223,6 +223,9 @@ static ProcessAccessType computeNetworkProcessAccessTypeForDataFetch(OptionSet<W
> 
>     if (dataTypes.contains(WebsiteDataType::DOMCache))
>         processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
>+    
>+    if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !isNonPersistentStore)
>+        processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
> 
>     return processAccessType;
> }
>@@ -510,11 +513,8 @@ void WebsiteDataStore::fetchDataAndApply(OptionSet<WebsiteDataType> dataTypes, O
>         });
>     }
> 
>-    if ((dataTypes.contains(WebsiteDataType::IndexedDBDatabases)
> #if ENABLE(SERVICE_WORKER)
>-        || dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)
>-#endif
>-        ) && isPersistent()) {
>+    if (dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && isPersistent()) {
>         for (auto& processPool : processPools()) {
>             processPool->ensureStorageProcessAndWebsiteDataStore(this);
> 
>@@ -524,6 +524,7 @@ void WebsiteDataStore::fetchDataAndApply(OptionSet<WebsiteDataType> dataTypes, O
>             });
>         }
>     }
>+#endif
> 
>     if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
>         callbackAggregator->addPendingCallback();
>@@ -656,6 +657,9 @@ static ProcessAccessType computeNetworkProcessAccessTypeForDataRemoval(OptionSet
>     if (dataTypes.contains(WebsiteDataType::DOMCache))
>         processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
> 
>+    if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !isNonPersistentStore)
>+        processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
>+
>     return processAccessType;
> }
> 
>@@ -820,11 +824,8 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, WallTime
>         });
>     }
> 
>-    if ((dataTypes.contains(WebsiteDataType::IndexedDBDatabases)
> #if ENABLE(SERVICE_WORKER)
>-        || dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)
>-#endif
>-        ) && isPersistent()) {
>+    if (dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && isPersistent()) {
>         for (auto& processPool : processPools()) {
>             processPool->ensureStorageProcessAndWebsiteDataStore(this);
> 
>@@ -834,6 +835,7 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, WallTime
>             });
>         }
>     }
>+#endif
> 
>     if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
>         callbackAggregator->addPendingCallback();
>@@ -1121,11 +1123,8 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, const Ve
>         });
>     }
> 
>-    if ((dataTypes.contains(WebsiteDataType::IndexedDBDatabases)
> #if ENABLE(SERVICE_WORKER)
>-        || dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)
>-#endif
>-        ) && isPersistent()) {
>+    if (dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && isPersistent()) {
>         for (auto& processPool : processPools()) {
>             processPool->ensureStorageProcessAndWebsiteDataStore(this);
> 
>@@ -1135,6 +1134,7 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, const Ve
>             });
>         }
>     }
>+#endif
> 
>     if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
>         HashSet<WebCore::SecurityOriginData> origins;
>@@ -1596,11 +1596,6 @@ StorageProcessCreationParameters WebsiteDataStore::storageProcessParameters()
> 
>     parameters.sessionID = m_sessionID;
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    parameters.indexedDatabaseDirectory = resolvedIndexedDatabaseDirectory();
>-    if (!parameters.indexedDatabaseDirectory.isEmpty())
>-        SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     parameters.serviceWorkerRegistrationDirectory = resolvedServiceWorkerRegistrationDirectory();
>     if (!parameters.serviceWorkerRegistrationDirectory.isEmpty())
>@@ -1636,6 +1631,15 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
>     // FIXME: Implement cookies.
>     WebsiteDataStoreParameters parameters;
>     parameters.networkSessionParameters.sessionID = m_sessionID;
>+
>+    resolveDirectoriesIfNecessary();
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    parameters.indexedDatabaseDirectory = resolvedIndexedDatabaseDirectory();
>+    if (!parameters.indexedDatabaseDirectory.isEmpty())
>+        SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
>+#endif
>+
>     return parameters;
> }
> #endif
>diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>index 2f3dca8911616907f48e96e3038b04fa174e4795..ce92b3516747a156367a46f06ff89adc961b99c7 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -976,8 +976,6 @@
> 		4A3CC18E19B07B8500D14AEF /* WKUserMediaPermissionRequest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4A410F3519AF7AC3002EBAB5 /* WKUserMediaPermissionRequest.cpp */; };
> 		4A3CC18F19B07B8A00D14AEF /* WKUserMediaPermissionRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 4A410F3619AF7AC3002EBAB5 /* WKUserMediaPermissionRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		4F601432155C5AA2001FBDE0 /* BlockingResponseMap.h in Headers */ = {isa = PBXBuildFile; fileRef = 4F601430155C5A32001FBDE0 /* BlockingResponseMap.h */; };
>-		5105236F1C739D42007993CB /* WebIDBConnectionToClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5105236D1C7393E9007993CB /* WebIDBConnectionToClient.cpp */; };
>-		510523701C739D42007993CB /* WebIDBConnectionToClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 5105236E1C7393E9007993CB /* WebIDBConnectionToClient.h */; };
> 		510523741C73D38B007993CB /* WebIDBConnectionToServerMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 510523731C73D37B007993CB /* WebIDBConnectionToServerMessages.h */; };
> 		510523751C73D38F007993CB /* WebIDBConnectionToServerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510523721C73D37B007993CB /* WebIDBConnectionToServerMessageReceiver.cpp */; };
> 		510523791C73DA77007993CB /* WebIDBConnectionToClientMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510523771C73DA70007993CB /* WebIDBConnectionToClientMessageReceiver.cpp */; };
>@@ -1340,6 +1338,7 @@
> 		9321D5861A38EE3C008052BE /* WKImmediateActionController.h in Headers */ = {isa = PBXBuildFile; fileRef = 9321D5851A38EE3C008052BE /* WKImmediateActionController.h */; };
> 		9321D58A1A38F196008052BE /* WKImmediateActionTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 9321D5891A38F196008052BE /* WKImmediateActionTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		9323611E1B015DA800FA9232 /* _WKOverlayScrollbarStyle.h in Headers */ = {isa = PBXBuildFile; fileRef = 9323611D1B015DA800FA9232 /* _WKOverlayScrollbarStyle.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		93261161214054F4000806E7 /* WebIDBConnectionToClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 939288DD21404D6C00EBBA33 /* WebIDBConnectionToClient.h */; };
> 		933DF82E1B3BC09000AEA9E3 /* WKImagePreviewViewController.h in Headers */ = {isa = PBXBuildFile; fileRef = 933DF82D1B3BC09000AEA9E3 /* WKImagePreviewViewController.h */; };
> 		934B724419F5B9BE00AE96D6 /* WKActionMenuItemTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 934B724319F5B9BE00AE96D6 /* WKActionMenuItemTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		935EEB9B1277617C003322B8 /* WKBundleBackForwardListItem.h in Headers */ = {isa = PBXBuildFile; fileRef = 935EEB981277616D003322B8 /* WKBundleBackForwardListItem.h */; settings = {ATTRIBUTES = (Private, ); }; };
>@@ -3926,6 +3925,9 @@
> 		9391074E1BF6BC65008C17AD /* WKPreviewElementInfoInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKPreviewElementInfoInternal.h; sourceTree = "<group>"; };
> 		9391F283121B38F500EBF7E8 /* WebFrameNetworkingContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFrameNetworkingContext.h; sourceTree = "<group>"; };
> 		9391F284121B38F500EBF7E8 /* WebFrameNetworkingContext.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebFrameNetworkingContext.mm; sourceTree = "<group>"; };
>+		939288DD21404D6C00EBBA33 /* WebIDBConnectionToClient.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebIDBConnectionToClient.h; sourceTree = "<group>"; };
>+		939288E121404E1000EBBA33 /* WebIDBConnectionToClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebIDBConnectionToClient.cpp; sourceTree = "<group>"; };
>+		939288E221404E1000EBBA33 /* WebIDBConnectionToClient.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebIDBConnectionToClient.messages.in; sourceTree = "<group>"; };
> 		9395E6891BF2C33200F49BCE /* WKPreviewElementInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKPreviewElementInfo.h; sourceTree = "<group>"; };
> 		9395E68B1BF2C35200F49BCE /* WKPreviewElementInfo.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKPreviewElementInfo.mm; sourceTree = "<group>"; };
> 		939AE7651316E99C00AE06A6 /* WebCoreArgumentCoders.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebCoreArgumentCoders.cpp; sourceTree = "<group>"; };
>@@ -6543,6 +6545,7 @@
> 				5C1426F11C23F81700D41183 /* Downloads */,
> 				BC82837C16B45DA500A278FE /* EntryPoint */,
> 				E1798C7616E6815500240139 /* FileAPI */,
>+				939288E021404DF000EBBA33 /* IndexedDB */,
> 				2DA944BB188511DD00ED86DB /* ios */,
> 				510CC7DC16138E2900D03ED3 /* mac */,
> 				A11455A1211FCE7F00CA935B /* watchos */,
>@@ -7113,6 +7116,16 @@
> 			path = cocoa;
> 			sourceTree = "<group>";
> 		};
>+		939288E021404DF000EBBA33 /* IndexedDB */ = {
>+			isa = PBXGroup;
>+			children = (
>+				939288E121404E1000EBBA33 /* WebIDBConnectionToClient.cpp */,
>+				939288DD21404D6C00EBBA33 /* WebIDBConnectionToClient.h */,
>+				939288E221404E1000EBBA33 /* WebIDBConnectionToClient.messages.in */,
>+			);
>+			path = IndexedDB;
>+			sourceTree = "<group>";
>+		};
> 		9394AE411702B25B00344232 /* mac */ = {
> 			isa = PBXGroup;
> 			children = (
>@@ -9528,7 +9541,7 @@
> 				2D5036761BCED19F00E20BB3 /* WebGestureEvent.h in Headers */,
> 				93A88B331BC6E9CD00ABA5C2 /* WebHitTestResultData.h in Headers */,
> 				F44DFEB21E9E752F0038D196 /* WebIconUtilities.h in Headers */,
>-				510523701C739D42007993CB /* WebIDBConnectionToClient.h in Headers */,
>+				93261161214054F4000806E7 /* WebIDBConnectionToClient.h in Headers */,
> 				5105237A1C73DA77007993CB /* WebIDBConnectionToClientMessages.h in Headers */,
> 				514129941C6428BB0059E714 /* WebIDBConnectionToServer.h in Headers */,
> 				510523741C73D38B007993CB /* WebIDBConnectionToServerMessages.h in Headers */,
>@@ -11218,7 +11231,6 @@
> 				CD73BA47131ACC9A00EEDED2 /* WebFullScreenManagerProxyMessageReceiver.cpp in Sources */,
> 				BC0E606112D6BA910012A72A /* WebGeolocationManagerMessageReceiver.cpp in Sources */,
> 				BC0E618212D6CB1D0012A72A /* WebGeolocationManagerProxyMessageReceiver.cpp in Sources */,
>-				5105236F1C739D42007993CB /* WebIDBConnectionToClient.cpp in Sources */,
> 				510523791C73DA77007993CB /* WebIDBConnectionToClientMessageReceiver.cpp in Sources */,
> 				510523751C73D38F007993CB /* WebIDBConnectionToServerMessageReceiver.cpp in Sources */,
> 				FEDBDCD61E68D20000A59F8F /* WebInspectorInterruptDispatcherMessageReceiver.cpp in Sources */,
>diff --git a/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp b/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp
>index 417e5cfceb8f6fa32d911f8aaf1821afb7b16aea..09e79ea6d0a51e4cb37e904b678a6a4490d75711 100644
>--- a/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp
>+++ b/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp
>@@ -31,12 +31,10 @@
> #include "DataReference.h"
> #include "NetworkConnectionToWebProcessMessages.h"
> #include "NetworkProcessConnection.h"
>-#include "StorageToWebProcessConnectionMessages.h"
> #include "WebCoreArgumentCoders.h"
> #include "WebIDBConnectionToClientMessages.h"
> #include "WebIDBResult.h"
> #include "WebProcess.h"
>-#include "WebToStorageProcessConnection.h"
> #include <WebCore/IDBConnectionToServer.h>
> #include <WebCore/IDBCursorInfo.h>
> #include <WebCore/IDBError.h>
>@@ -64,7 +62,7 @@ WebIDBConnectionToServer::WebIDBConnectionToServer(PAL::SessionID sessionID)
> {
>     relaxAdoptionRequirement();
> 
>-    m_isOpenInServer = sendSync(Messages::StorageToWebProcessConnection::EstablishIDBConnectionToServer(sessionID), Messages::StorageToWebProcessConnection::EstablishIDBConnectionToServer::Reply(m_identifier));
>+    m_isOpenInServer = sendSync(Messages::NetworkConnectionToWebProcess::EstablishIDBConnectionToServer(sessionID), Messages::NetworkConnectionToWebProcess::EstablishIDBConnectionToServer::Reply(m_identifier));
> 
>     // FIXME: This creates a reference cycle, so neither this object nor the IDBConnectionToServer will ever be deallocated.
>     m_connectionToServer = IDBClient::IDBConnectionToServer::create(*this);
>@@ -73,12 +71,12 @@ WebIDBConnectionToServer::WebIDBConnectionToServer(PAL::SessionID sessionID)
> WebIDBConnectionToServer::~WebIDBConnectionToServer()
> {
>     if (m_isOpenInServer)
>-        send(Messages::StorageToWebProcessConnection::RemoveIDBConnectionToServer(m_identifier));
>+        send(Messages::NetworkConnectionToWebProcess::RemoveIDBConnectionToServer(m_identifier));
> }
> 
> IPC::Connection* WebIDBConnectionToServer::messageSenderConnection()
> {
>-    return &WebProcess::singleton().ensureWebToStorageProcessConnection(m_sessionID).connection();
>+    return &WebProcess::singleton().ensureNetworkProcessConnection().connection();
> }
> 
> IDBClient::IDBConnectionToServer& WebIDBConnectionToServer::coreConnectionToServer()
>diff --git a/Source/WebKit/WebProcess/Databases/WebDatabaseProvider.cpp b/Source/WebKit/WebProcess/Databases/WebDatabaseProvider.cpp
>index 38d67e494d220f0423d6f6fd7fbbc26c1cad6b49..b0798e99a8e753669c3ad3049683b59d36c323d2 100644
>--- a/Source/WebKit/WebProcess/Databases/WebDatabaseProvider.cpp
>+++ b/Source/WebKit/WebProcess/Databases/WebDatabaseProvider.cpp
>@@ -26,8 +26,8 @@
> #include "config.h"
> #include "WebDatabaseProvider.h"
> 
>+#include "NetworkProcessConnection.h"
> #include "WebProcess.h"
>-#include "WebToStorageProcessConnection.h"
> #include <pal/SessionID.h>
> #include <wtf/HashMap.h>
> #include <wtf/NeverDestroyed.h>
>@@ -67,7 +67,6 @@ WebDatabaseProvider::~WebDatabaseProvider()
> }
> 
> #if ENABLE(INDEXED_DATABASE)
>-
> WebCore::IDBClient::IDBConnectionToServer& WebDatabaseProvider::idbConnectionToServerForSession(const PAL::SessionID& sessionID)
> {
>     if (sessionID.isEphemeral()) {
>@@ -78,9 +77,8 @@ WebCore::IDBClient::IDBConnectionToServer& WebDatabaseProvider::idbConnectionToS
>         return result.iterator->value->connectionToServer();
>     }
> 
>-    return WebProcess::singleton().ensureWebToStorageProcessConnection(sessionID).idbConnectionToServerForSession(sessionID).coreConnectionToServer();
>+    return WebProcess::singleton().ensureNetworkProcessConnection().idbConnectionToServerForSession(sessionID).coreConnectionToServer();
> }
>-
> #endif
> 
> }
>diff --git a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>index 48c0806223a6f0fbf13bf3093b0daaec4db8bd9e..b098937be9658a3f5cc39566e632d6042d3d64a2 100644
>--- a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>+++ b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>@@ -33,6 +33,7 @@
> #include "WebCacheStorageConnectionMessages.h"
> #include "WebCacheStorageProvider.h"
> #include "WebCoreArgumentCoders.h"
>+#include "WebIDBConnectionToServerMessages.h"
> #include "WebLoaderStrategy.h"
> #include "WebMDNSRegisterMessages.h"
> #include "WebPage.h"
>@@ -107,6 +108,15 @@ void NetworkProcessConnection::didReceiveMessage(IPC::Connection& connection, IP
>         return;
>     }
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    if (decoder.messageReceiverName() == Messages::WebIDBConnectionToServer::messageReceiverName()) {
>+        auto idbConnection = m_webIDBConnectionsByIdentifier.get(decoder.destinationID());
>+        if (idbConnection)
>+            idbConnection->didReceiveMessage(connection, decoder);
>+        return;
>+    }
>+#endif
>+
>     didReceiveNetworkProcessConnectionMessage(connection, decoder);
> }
> 
>@@ -126,6 +136,16 @@ void NetworkProcessConnection::didClose(IPC::Connection&)
>         handler(dummyFilenames);
> 
>     m_writeBlobToFileCompletionHandlers.clear();
>+
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    for (auto& connection : m_webIDBConnectionsByIdentifier.values())
>+        connection->connectionToServerLost();
>+    
>+    m_webIDBConnectionsByIdentifier.clear();
>+    m_webIDBConnectionsBySession.clear();
>+#endif
>+
> }
> 
> void NetworkProcessConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference, IPC::StringReference)
>@@ -181,4 +201,17 @@ void NetworkProcessConnection::didCacheResource(const ResourceRequest& request,
> }
> #endif
> 
>+#if ENABLE(INDEXED_DATABASE)
>+WebIDBConnectionToServer& NetworkProcessConnection::idbConnectionToServerForSession(PAL::SessionID sessionID)
>+{
>+    return *m_webIDBConnectionsBySession.ensure(sessionID, [&] {
>+        auto connection = WebIDBConnectionToServer::create(sessionID);
>+        
>+        auto result = m_webIDBConnectionsByIdentifier.add(connection->identifier(), connection.copyRef());
>+        ASSERT_UNUSED(result, result.isNewEntry);
>+        
>+        return connection;
>+    }).iterator->value;
>+}
>+#endif
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.h b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.h
>index e872a81c19481cfdd2f54d4fb443a665bb46a311..2d2e92398c465978f998fd2090cadbc966372052 100644
>--- a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.h
>+++ b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.h
>@@ -28,6 +28,7 @@
> 
> #include "Connection.h"
> #include "ShareableResource.h"
>+#include "WebIDBConnectionToServer.h"
> #include <wtf/RefCounted.h>
> #include <wtf/text/WTFString.h>
> 
>@@ -63,6 +64,11 @@ public:
> 
>     void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, Function<void (const Vector<String>& filePaths)>&& completionHandler);
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    WebIDBConnectionToServer* existingIDBConnectionToServerForIdentifier(uint64_t identifier) { return m_webIDBConnectionsByIdentifier.get(identifier); };
>+    WebIDBConnectionToServer& idbConnectionToServerForSession(PAL::SessionID);
>+#endif
>+
> private:
>     NetworkProcessConnection(IPC::Connection::Identifier);
> 
>@@ -86,6 +92,12 @@ private:
>     Ref<IPC::Connection> m_connection;
> 
>     HashMap<uint64_t, Function<void (const Vector<String>&)>> m_writeBlobToFileCompletionHandlers;
>+
>+#if ENABLE(INDEXED_DATABASE)
>+    HashMap<PAL::SessionID, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsBySession;
>+    HashMap<uint64_t, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsByIdentifier;
>+#endif
>+
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.cpp b/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.cpp
>index a05642bd03aac03a2ed3994e9ac75a597cd7b551..460ea0fc029e8c81ad91ad8e08638fb72847ea67 100644
>--- a/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.cpp
>+++ b/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.cpp
>@@ -29,7 +29,6 @@
> 
> #include "ServiceWorkerClientFetchMessages.h"
> #include "StorageToWebProcessConnectionMessages.h"
>-#include "WebIDBConnectionToServerMessages.h"
> #include "WebProcess.h"
> #include "WebSWClientConnection.h"
> #include "WebSWClientConnectionMessages.h"
>@@ -55,15 +54,6 @@ WebToStorageProcessConnection::~WebToStorageProcessConnection()
> 
> void WebToStorageProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
> {
>-#if ENABLE(INDEXED_DATABASE)
>-    if (decoder.messageReceiverName() == Messages::WebIDBConnectionToServer::messageReceiverName()) {
>-        auto idbConnection = m_webIDBConnectionsByIdentifier.get(decoder.destinationID());
>-        if (idbConnection)
>-            idbConnection->didReceiveMessage(connection, decoder);
>-        return;
>-    }
>-#endif
>-
> #if ENABLE(SERVICE_WORKER)
>     if (decoder.messageReceiverName() == Messages::WebSWClientConnection::messageReceiverName()) {
>         auto serviceWorkerConnection = m_swConnectionsByIdentifier.get(makeObjectIdentifier<SWServerConnectionIdentifierType>(decoder.destinationID()));
>@@ -102,10 +92,6 @@ void WebToStorageProcessConnection::didClose(IPC::Connection& connection)
> {
>     auto protectedThis = makeRef(*this);
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    for (auto& connection : m_webIDBConnectionsByIdentifier.values())
>-        connection->connectionToServerLost();
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     for (auto& connection : m_swConnectionsBySession.values())
>         connection->connectionToServerLost();
>@@ -115,31 +101,12 @@ void WebToStorageProcessConnection::didClose(IPC::Connection& connection)
> #endif
> 
>     WebProcess::singleton().webToStorageProcessConnectionClosed(this);
>-
>-#if ENABLE(INDEXED_DATABASE)
>-    m_webIDBConnectionsByIdentifier.clear();
>-    m_webIDBConnectionsBySession.clear();
>-#endif
> }
> 
> void WebToStorageProcessConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference messageReceiverName, IPC::StringReference messageName)
> {
> }
> 
>-#if ENABLE(INDEXED_DATABASE)
>-WebIDBConnectionToServer& WebToStorageProcessConnection::idbConnectionToServerForSession(SessionID sessionID)
>-{
>-    return *m_webIDBConnectionsBySession.ensure(sessionID, [&] {
>-        auto connection = WebIDBConnectionToServer::create(sessionID);
>-
>-        auto result = m_webIDBConnectionsByIdentifier.add(connection->identifier(), connection.copyRef());
>-        ASSERT_UNUSED(result, result.isNewEntry);
>-
>-        return connection;
>-    }).iterator->value;
>-}
>-#endif
>-
> #if ENABLE(SERVICE_WORKER)
> WebSWClientConnection& WebToStorageProcessConnection::serviceWorkerConnectionForSession(SessionID sessionID)
> {
>diff --git a/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.h b/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.h
>index 2030d2212574a384deff628b860a1ac959837088..a55622ad0cbff0440e1f2778e24d299aec2c028a 100644
>--- a/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.h
>+++ b/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.h
>@@ -28,7 +28,6 @@
> 
> #include "Connection.h"
> #include "MessageSender.h"
>-#include "WebIDBConnectionToServer.h"
> #include "WebSWClientConnection.h"
> #include <WebCore/SWServer.h>
> #include <pal/SessionID.h>
>@@ -50,10 +49,6 @@ public:
>     
>     IPC::Connection& connection() { return m_connection.get(); }
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    WebIDBConnectionToServer* existingIDBConnectionToServerForIdentifier(uint64_t identifier) { return m_webIDBConnectionsByIdentifier.get(identifier); };
>-    WebIDBConnectionToServer& idbConnectionToServerForSession(PAL::SessionID);
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     WebSWClientConnection* existingServiceWorkerConnectionForSession(PAL::SessionID sessionID) { return m_swConnectionsBySession.get(sessionID); }
>     WebSWClientConnection& serviceWorkerConnectionForSession(PAL::SessionID);
>@@ -74,11 +69,6 @@ private:
> 
>     Ref<IPC::Connection> m_connection;
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    HashMap<PAL::SessionID, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsBySession;
>-    HashMap<uint64_t, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsByIdentifier;
>-#endif
>-
> #if ENABLE(SERVICE_WORKER)
>     HashMap<PAL::SessionID, RefPtr<WebSWClientConnection>> m_swConnectionsBySession;
>     HashMap<WebCore::SWServerConnectionIdentifier, WebSWClientConnection*> m_swConnectionsByIdentifier;
>diff --git a/Source/WebKit/WebProcess/WebProcess.cpp b/Source/WebKit/WebProcess/WebProcess.cpp
>index 0c1aeb6cd7eb0e9789d035bae307b8bb5e5c2fb2..87b613d4d121edc470249a331ae046a7d9172b3f 100644
>--- a/Source/WebKit/WebProcess/WebProcess.cpp
>+++ b/Source/WebKit/WebProcess/WebProcess.cpp
>@@ -1174,6 +1174,19 @@ void WebProcess::networkProcessConnectionClosed(NetworkProcessConnection* connec
>     ASSERT(m_networkProcessConnection);
>     ASSERT_UNUSED(connection, m_networkProcessConnection == connection);
> 
>+#if ENABLE(INDEXED_DATABASE)
>+    for (auto& page : m_pageMap.values()) {
>+        auto idbConnection = page->corePage()->optionalIDBConnection();
>+        if (!idbConnection)
>+            continue;
>+        
>+        if (connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())) {
>+            ASSERT(idbConnection == &connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())->coreConnectionToServer());
>+            page->corePage()->clearIDBConnection();
>+        }
>+    }
>+#endif
>+
>     m_networkProcessConnection = nullptr;
> 
>     logDiagnosticMessageForNetworkProcessCrash();
>@@ -1195,18 +1208,6 @@ void WebProcess::webToStorageProcessConnectionClosed(WebToStorageProcessConnecti
>     ASSERT(m_webToStorageProcessConnection);
>     ASSERT(m_webToStorageProcessConnection == connection);
> 
>-#if ENABLE(INDEXED_DATABASE)
>-    for (auto& page : m_pageMap.values()) {
>-        auto idbConnection = page->corePage()->optionalIDBConnection();
>-        if (!idbConnection)
>-            continue;
>-
>-        if (connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())) {
>-            ASSERT(idbConnection == &connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())->coreConnectionToServer());
>-            page->corePage()->clearIDBConnection();
>-        }
>-    }
>-#endif
> #if ENABLE(SERVICE_WORKER)
>     if (SWContextManager::singleton().connection()) {
>         RELEASE_LOG(ServiceWorker, "Service worker process is exiting because its storage process is gone");
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index 38012fdd8d4b8265ee2eefffede2b594ec8d651f..f627c269f29bff1ce3c436b486ada0d8396e0363 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,21 @@
>+2018-09-07  Sihui Liu  <sihui_liu@apple.com>
>+
>+        Move IndexedDB to Network Process
>+        https://bugs.webkit.org/show_bug.cgi?id=189415
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * TestWebKitAPI/Tests/WebKitCocoa/IDBDeleteRecovery.mm:
>+        (TEST):
>+        * TestWebKitAPI/Tests/WebKitCocoa/IDBIndexUpgradeToV2.mm:
>+        (TEST):
>+        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBDatabaseProcessKill.mm:
>+        (TEST):
>+        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBMultiProcess.mm:
>+        (TEST):
>+        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm:
>+        (TEST):
>+
> 2018-08-29  Don Olmstead  <don.olmstead@sony.com>
> 
>         [CMake] Split Tools/CMakeLists.txt into platform files
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBDeleteRecovery.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBDeleteRecovery.mm
>index d1fff2f8704a3b865e2d48d386eb967171a5e0cc..196b36f1a4e183aa99e731c559a39299dda5ee0c 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBDeleteRecovery.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBDeleteRecovery.mm
>@@ -59,7 +59,7 @@ TEST(IndexedDB, DeleteRecovery)
>     RetainPtr<WKWebViewConfiguration> configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
>     [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
> 
>-    [configuration.get().processPool _terminateStorageProcess];
>+    [configuration.get().processPool _terminateNetworkProcess];
> 
>     // Copy the inconsistent database files to the database directory
>     NSURL *url1 = [[NSBundle mainBundle] URLForResource:@"IDBDeleteRecovery" withExtension:@"sqlite3" subdirectory:@"TestWebKitAPI.resources"];
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBIndexUpgradeToV2.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBIndexUpgradeToV2.mm
>index e085bec80763ae74975e75686431c1d8b86316ae..58f9f85f282dd79692b4b5b89f9db2fffe5a866d 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBIndexUpgradeToV2.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBIndexUpgradeToV2.mm
>@@ -59,7 +59,7 @@ TEST(IndexedDB, IndexUpgradeToV2)
>     RetainPtr<WKWebViewConfiguration> configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
>     [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
> 
>-    [configuration.get().processPool _terminateStorageProcess];
>+    [configuration.get().processPool _terminateNetworkProcess];
> 
>     // Copy the inconsistent database files to the database directory
>     NSURL *url1 = [[NSBundle mainBundle] URLForResource:@"IndexUpgrade" withExtension:@"sqlite3" subdirectory:@"TestWebKitAPI.resources"];
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBDatabaseProcessKill.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBDatabaseProcessKill.mm
>index 391c1c4e9a6ad0a29dbe70c1378451cbfc2f0258..118c3c134a772b4a303b3d3baa4dc82ab21b5364 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBDatabaseProcessKill.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBDatabaseProcessKill.mm
>@@ -94,7 +94,7 @@ TEST(IndexedDB, DatabaseProcessKill)
>         TestWebKitAPI::Util::run(&receivedScriptMessage);
>         if (!killedDBProcess && openRequestUpgradeNeeded) {
>             killedDBProcess = true;
>-            [configuration.get().processPool _terminateStorageProcess];
>+            [configuration.get().processPool _terminateNetworkProcess];
>         }
>     }
> 
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBMultiProcess.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBMultiProcess.mm
>index 1f709de8c47e0b913b88728145de54a375fe7692..329b160f63e08bf21a4a1ea1f4351964417b164a 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBMultiProcess.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBMultiProcess.mm
>@@ -71,7 +71,7 @@ TEST(IndexedDB, IndexedDBMultiProcess)
>     RetainPtr<WKWebViewConfiguration> configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
>     [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
> 
>-    [configuration.get().processPool _terminateStorageProcess];
>+    [configuration.get().processPool _terminateNetworkProcess];
> 
>     RetainPtr<WKWebView> webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);
> 
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm
>index afa944611c4f8f5917fdf06bafbc2c4bed290461..b72992332f6d6c2dd7db7913455d785ad8f3a1c5 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm
>@@ -76,8 +76,8 @@ TEST(IndexedDB, IndexedDBPersistence)
>     // Ditch this web view (ditching its web process)
>     webView = nil;
> 
>-    // Terminate the storage process
>-    [configuration.get().processPool _terminateStorageProcess];
>+    // Terminate the network process
>+    [configuration.get().processPool _terminateNetworkProcess];
> 
>     // Make a new web view to finish the test
>     webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);

Actions: View | Formatted Diff | Diff

Attachments on bug 189415: 349160 | 349162 | 349169 | 349176 | 349185 | 349191 | 349194 | 349198 | 349343 | 349779 | 349782 | 349877