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

Changeset 235954 in webkit


Ignore:
Timestamp:
Sep 12, 2018, 3:16:45 PM (8 years ago)
Author:
sihui_liu@apple.com
Message:

Move IndexedDB to Network Process
​https://bugs.webkit.org/show_bug.cgi?id=189415

Reviewed by Geoffrey Garen.

Source/WebKit:

We are going to eliminate storage process and move its functionality to network process.
The reasons why we want to do this:

  1. Lower resource usage of having an additional process for storage operations, especially

memory. Single storage process takes about 5MB memory on macOS.

  1. Reduce latency of Service Workers. After enabling Service Workers, we've seen

regression in app launch. The launch time of storage process is partly attributed to this:
Service Workers delay page loading until receiving response from storage process.

  1. We choose network process because UI process may have broader access in file system

that we don't want the storage operations to have.

This patch is the first piece towards the goal. It mainly moves indexedDB from storage process
to corresponding components of network process. Moving of Service Worker and stopping to
launch storage process will be done in following patches.

We expect to see the higher cpu and memory usage of network process as it is taking more work,
but the overall gain in memory and latency after we completely remove storage process should be
positive.

  • CMakeLists.txt:
  • DerivedSources.make:
  • 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):

Code moved from StorageToWebProcessConnection::didReceiveMessage.

(WebKit::NetworkConnectionToWebProcess::didClose):
(WebKit::NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles):

Network process receives and stores sandbox extension of temporary files for later indexedDB
use.

(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):

Instead of asking UI process to grant sandbox extension to storage process, now network
process just asks for sandbox extension fot itself.

(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):

Code moved from 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):

Tools:

  • 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):

LayoutTests:

  • storage/indexeddb/modern/opendatabase-after-storage-crash.html:
Location:
trunk
Files:
1 added
1 deleted
47 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r235948 r235954  
     12018-09-12  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Move IndexedDB to Network Process
     4        https://bugs.webkit.org/show_bug.cgi?id=189415
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        * storage/indexeddb/modern/opendatabase-after-storage-crash.html:
     9
    1102018-09-11  Dean Jackson  <dino@apple.com>
    211

  • trunk/LayoutTests/storage/indexeddb/modern/opendatabase-after-storage-crash.html

    r235415 r235954  
    6262        if (window.testRunner) {
    6363                testRunner.waitUntilDone();
    64                 testRunner.terminateStorageProcess();
     64                testRunner.terminateNetworkProcess();
    6565        }
    6666}

  • trunk/Source/WebKit/CMakeLists.txt

    r235921 r235954  
    1010    "${WEBKIT_DIR}/NetworkProcess/Downloads"
    1111    "${WEBKIT_DIR}/NetworkProcess/FileAPI"
     12    "${WEBKIT_DIR}/NetworkProcess/IndexedDB"
    1213    "${WEBKIT_DIR}/NetworkProcess/cache"
    1314    "${WEBKIT_DIR}/NetworkProcess/capture"
    … …  
    3334    "${WEBKIT_DIR}/Shared/WebsiteData"
    3435    "${WEBKIT_DIR}/StorageProcess"
    35     "${WEBKIT_DIR}/StorageProcess/IndexedDB"
    3636    "${WEBKIT_DIR}/StorageProcess/ServiceWorker"
    3737    "${WEBKIT_DIR}/UIProcess"
    … …  
    111111    NetworkProcess/NetworkSocketStream.messages.in
    112112
     113    NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in
     114
    113115    NetworkProcess/cache/CacheStorageEngineConnection.messages.in
    114116
    … …  
    131133    StorageProcess/StorageProcess.messages.in
    132134    StorageProcess/StorageToWebProcessConnection.messages.in
    133 
    134     StorageProcess/IndexedDB/WebIDBConnectionToClient.messages.in
    135135
    136136    StorageProcess/ServiceWorker/WebSWServerConnection.messages.in

  • trunk/Source/WebKit/ChangeLog

    r235953 r235954  
     12018-09-12  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Move IndexedDB to Network Process
     4        https://bugs.webkit.org/show_bug.cgi?id=189415
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        We are going to eliminate storage process and move its functionality to network process.
     9        The reasons why we want to do this:
     10        1. Lower resource usage of having an additional process for storage operations, especially
     11        memory. Single storage process takes about 5MB memory on macOS.
     12        2. Reduce latency of Service Workers. After enabling Service Workers, we've seen
     13        regression in app launch. The launch time of storage process is partly attributed to this:
     14        Service Workers delay page loading until receiving response from storage process.
     15        3. We choose network process because UI process may have broader access in file system
     16        that we don't want the storage operations to have.
     17
     18        This patch is the first piece towards the goal. It mainly moves indexedDB from storage process
     19        to corresponding components of network process. Moving of Service Worker and stopping to
     20        launch storage process will be done in following patches.
     21
     22        We expect to see the higher cpu and memory usage of network process as it is taking more work,
     23        but the overall gain in memory and latency after we completely remove storage process should be
     24        positive.
     25
     26
     27        * CMakeLists.txt:
     28        * DerivedSources.make:
     29
     30        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp: Renamed from Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.cpp.
     31        (WebKit::WebIDBConnectionToClient::create):
     32        (WebKit::WebIDBConnectionToClient::WebIDBConnectionToClient):
     33        (WebKit::WebIDBConnectionToClient::~WebIDBConnectionToClient):
     34        (WebKit::WebIDBConnectionToClient::disconnectedFromWebProcess):
     35        (WebKit::WebIDBConnectionToClient::messageSenderConnection):
     36        (WebKit::WebIDBConnectionToClient::connectionToClient):
     37        (WebKit::WebIDBConnectionToClient::didDeleteDatabase):
     38        (WebKit::WebIDBConnectionToClient::didOpenDatabase):
     39        (WebKit::WebIDBConnectionToClient::didAbortTransaction):
     40        (WebKit::WebIDBConnectionToClient::didCommitTransaction):
     41        (WebKit::WebIDBConnectionToClient::didCreateObjectStore):
     42        (WebKit::WebIDBConnectionToClient::didDeleteObjectStore):
     43        (WebKit::WebIDBConnectionToClient::didRenameObjectStore):
     44        (WebKit::WebIDBConnectionToClient::didClearObjectStore):
     45        (WebKit::WebIDBConnectionToClient::didCreateIndex):
     46        (WebKit::WebIDBConnectionToClient::didDeleteIndex):
     47        (WebKit::WebIDBConnectionToClient::didRenameIndex):
     48        (WebKit::WebIDBConnectionToClient::didPutOrAdd):
     49        (WebKit::WebIDBConnectionToClient::handleGetResult):
     50        (WebKit::WebIDBConnectionToClient::didGetRecord):
     51        (WebKit::WebIDBConnectionToClient::didGetAllRecords):
     52        (WebKit::WebIDBConnectionToClient::didGetCount):
     53        (WebKit::WebIDBConnectionToClient::didDeleteRecord):
     54        (WebKit::WebIDBConnectionToClient::didOpenCursor):
     55        (WebKit::WebIDBConnectionToClient::didIterateCursor):
     56        (WebKit::WebIDBConnectionToClient::fireVersionChangeEvent):
     57        (WebKit::WebIDBConnectionToClient::didStartTransaction):
     58        (WebKit::WebIDBConnectionToClient::didCloseFromServer):
     59        (WebKit::WebIDBConnectionToClient::notifyOpenDBRequestBlocked):
     60        (WebKit::WebIDBConnectionToClient::didGetAllDatabaseNames):
     61        (WebKit::WebIDBConnectionToClient::deleteDatabase):
     62        (WebKit::WebIDBConnectionToClient::openDatabase):
     63        (WebKit::WebIDBConnectionToClient::abortTransaction):
     64        (WebKit::WebIDBConnectionToClient::commitTransaction):
     65        (WebKit::WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction):
     66        (WebKit::WebIDBConnectionToClient::createObjectStore):
     67        (WebKit::WebIDBConnectionToClient::deleteObjectStore):
     68        (WebKit::WebIDBConnectionToClient::renameObjectStore):
     69        (WebKit::WebIDBConnectionToClient::clearObjectStore):
     70        (WebKit::WebIDBConnectionToClient::createIndex):
     71        (WebKit::WebIDBConnectionToClient::deleteIndex):
     72        (WebKit::WebIDBConnectionToClient::renameIndex):
     73        (WebKit::WebIDBConnectionToClient::putOrAdd):
     74        (WebKit::WebIDBConnectionToClient::getRecord):
     75        (WebKit::WebIDBConnectionToClient::getAllRecords):
     76        (WebKit::WebIDBConnectionToClient::getCount):
     77        (WebKit::WebIDBConnectionToClient::deleteRecord):
     78        (WebKit::WebIDBConnectionToClient::openCursor):
     79        (WebKit::WebIDBConnectionToClient::iterateCursor):
     80        (WebKit::WebIDBConnectionToClient::establishTransaction):
     81        (WebKit::WebIDBConnectionToClient::databaseConnectionPendingClose):
     82        (WebKit::WebIDBConnectionToClient::databaseConnectionClosed):
     83        (WebKit::WebIDBConnectionToClient::abortOpenAndUpgradeNeeded):
     84        (WebKit::WebIDBConnectionToClient::didFireVersionChangeEvent):
     85        (WebKit::WebIDBConnectionToClient::openDBRequestCancelled):
     86        (WebKit::WebIDBConnectionToClient::confirmDidCloseFromServer):
     87        (WebKit::WebIDBConnectionToClient::getAllDatabaseNames):
     88        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.h: Renamed from Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.h.
     89        * NetworkProcess/IndexedDB/WebIDBConnectionToClient.messages.in: Renamed from Source/WebKit/StorageProcess/IndexedDB/WebIDBConnectionToClient.messages.in.
     90        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     91        (WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
     92
     93        Code moved from StorageToWebProcessConnection::didReceiveMessage.
     94
     95        (WebKit::NetworkConnectionToWebProcess::didClose):
     96        (WebKit::NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles):
     97
     98        Network process receives and stores sandbox extension of temporary files for later indexedDB
     99        use.
     100
     101        (WebKit::generateIDBConnectionToServerIdentifier):
     102        (WebKit::NetworkConnectionToWebProcess::establishIDBConnectionToServer):
     103        (WebKit::NetworkConnectionToWebProcess::removeIDBConnectionToServer):
     104        * NetworkProcess/NetworkConnectionToWebProcess.h:
     105        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
     106        * NetworkProcess/NetworkProcess.cpp:
     107        (WebKit::NetworkProcess::NetworkProcess):
     108        (WebKit::NetworkProcess::initializeNetworkProcess):
     109        (WebKit::NetworkProcess::addWebsiteDataStore):
     110        (WebKit::NetworkProcess::fetchWebsiteData):
     111        (WebKit::NetworkProcess::deleteWebsiteData):
     112        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
     113        (WebKit::NetworkProcess::idbServer):
     114        (WebKit::NetworkProcess::ensurePathExists):
     115        (WebKit::NetworkProcess::postStorageTask):
     116        (WebKit::NetworkProcess::performNextStorageTask):
     117        (WebKit::NetworkProcess::prepareForAccessToTemporaryFile):
     118        (WebKit::NetworkProcess::accessToTemporaryFileComplete):
     119        (WebKit::NetworkProcess::indexedDatabaseOrigins):
     120        (WebKit::NetworkProcess::addIndexedDatabaseSession):
     121        (WebKit::NetworkProcess::getSandboxExtensionsForBlobFiles):
     122
     123        Instead of asking UI process to grant sandbox extension to storage process, now network
     124        process just asks for sandbox extension fot itself.
     125
     126        (WebKit::NetworkProcess::didGetSandboxExtensionsForBlobFiles):
     127        (WebKit::NetworkProcess::updateTemporaryFileSandboxExtensions):
     128        (WebKit::NetworkProcess::grantSandboxExtensionsToStorageProcessForBlobs): Deleted.
     129        (WebKit::NetworkProcess::didGrantSandboxExtensionsToStorageProcessForBlobs): Deleted.
     130        * NetworkProcess/NetworkProcess.h:
     131        (WebKit::NetworkProcess::queue):
     132        * NetworkProcess/NetworkProcess.messages.in:
     133        * NetworkProcess/NetworkProcessCreationParameters.cpp:
     134        (WebKit::NetworkProcessCreationParameters::encode const):
     135        (WebKit::NetworkProcessCreationParameters::decode):
     136        * NetworkProcess/NetworkProcessCreationParameters.h:
     137        * Shared/Storage/StorageProcessCreationParameters.cpp:
     138        (WebKit::StorageProcessCreationParameters::encode const):
     139        (WebKit::StorageProcessCreationParameters::decode):
     140        * Shared/Storage/StorageProcessCreationParameters.h:
     141        * Shared/WebsiteDataStoreParameters.cpp:
     142        (WebKit::WebsiteDataStoreParameters::encode const):
     143        (WebKit::WebsiteDataStoreParameters::decode):
     144        (WebKit::WebsiteDataStoreParameters::privateSessionParameters):
     145        * Shared/WebsiteDataStoreParameters.h:
     146        * Sources.txt:
     147        * StorageProcess/StorageProcess.cpp:
     148        (WebKit::StorageProcess::initializeWebsiteDataStore):
     149        (WebKit::StorageProcess::fetchWebsiteData):
     150        (WebKit::StorageProcess::deleteWebsiteData):
     151        (WebKit::StorageProcess::deleteWebsiteDataForOrigins):
     152        (WebKit::StorageProcess::idbServer): Deleted.
     153        (WebKit::StorageProcess::grantSandboxExtensionsForBlobs): Deleted.
     154        (WebKit::StorageProcess::prepareForAccessToTemporaryFile): Deleted.
     155        (WebKit::StorageProcess::accessToTemporaryFileComplete): Deleted.
     156        (WebKit::StorageProcess::indexedDatabaseOrigins): Deleted.
     157        (WebKit::StorageProcess::getSandboxExtensionsForBlobFiles): Deleted.
     158        (WebKit::StorageProcess::didGetSandboxExtensionsForBlobFiles): Deleted.
     159        * StorageProcess/StorageProcess.h:
     160        (WebKit::StorageProcess::queue): Deleted.
     161        * StorageProcess/StorageProcess.messages.in:
     162        * StorageProcess/StorageToWebProcessConnection.cpp:
     163        (WebKit::StorageToWebProcessConnection::didReceiveMessage):
     164        (WebKit::StorageToWebProcessConnection::didClose):
     165        (WebKit::generateIDBConnectionToServerIdentifier): Deleted.
     166        (WebKit::StorageToWebProcessConnection::establishIDBConnectionToServer): Deleted.
     167        (WebKit::StorageToWebProcessConnection::removeIDBConnectionToServer): Deleted.
     168        * StorageProcess/StorageToWebProcessConnection.h:
     169        * StorageProcess/StorageToWebProcessConnection.messages.in:
     170        * UIProcess/Network/NetworkProcessProxy.cpp:
     171        (WebKit::NetworkProcessProxy::getSandboxExtensionsForBlobFiles):
     172        (WebKit::NetworkProcessProxy::grantSandboxExtensionsToStorageProcessForBlobs): Deleted.
     173        * UIProcess/Network/NetworkProcessProxy.h:
     174        * UIProcess/Network/NetworkProcessProxy.messages.in:
     175        * UIProcess/Storage/StorageProcessProxy.cpp:
     176        (WebKit::StorageProcessProxy::getSandboxExtensionsForBlobFiles): Deleted.
     177        * UIProcess/Storage/StorageProcessProxy.h:
     178        * UIProcess/Storage/StorageProcessProxy.messages.in:
     179        * UIProcess/WebProcessPool.cpp:
     180        (WebKit::WebProcessPool::ensureNetworkProcess):
     181        (WebKit::WebProcessPool::ensureStorageProcessAndWebsiteDataStore):
     182        (WebKit::WebProcessPool::pageBeginUsingWebsiteDataStore):
     183        * UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm:
     184        (WebKit::WebsiteDataStore::parameters):
     185        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
     186        (WebKit::computeNetworkProcessAccessTypeForDataFetch):
     187        (WebKit::WebsiteDataStore::fetchDataAndApply):
     188        (WebKit::computeNetworkProcessAccessTypeForDataRemoval):
     189        (WebKit::WebsiteDataStore::removeData):
     190        (WebKit::WebsiteDataStore::storageProcessParameters):
     191        (WebKit::WebsiteDataStore::parameters):
     192        * WebKit.xcodeproj/project.pbxproj:
     193        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
     194        (WebKit::WebIDBConnectionToServer::WebIDBConnectionToServer):
     195        (WebKit::WebIDBConnectionToServer::~WebIDBConnectionToServer):
     196        (WebKit::WebIDBConnectionToServer::messageSenderConnection):
     197        * WebProcess/Databases/WebDatabaseProvider.cpp:
     198        (WebKit::WebDatabaseProvider::idbConnectionToServerForSession):
     199        * WebProcess/Network/NetworkProcessConnection.cpp:
     200        (WebKit::NetworkProcessConnection::didReceiveMessage):
     201        (WebKit::NetworkProcessConnection::didClose):
     202        (WebKit::NetworkProcessConnection::idbConnectionToServerForSession):
     203        * WebProcess/Network/NetworkProcessConnection.h:
     204        (WebKit::NetworkProcessConnection::existingIDBConnectionToServerForIdentifier):
     205        * WebProcess/Storage/WebToStorageProcessConnection.cpp:
     206        (WebKit::WebToStorageProcessConnection::didReceiveMessage):
     207
     208        Code moved from WebToStorageProcessConnection::didReceiveMessage.
     209
     210        (WebKit::WebToStorageProcessConnection::didClose):
     211        (WebKit::WebToStorageProcessConnection::idbConnectionToServerForSession): Deleted.
     212        * WebProcess/Storage/WebToStorageProcessConnection.h:
     213        (WebKit::WebToStorageProcessConnection::existingIDBConnectionToServerForIdentifier): Deleted.
     214        * WebProcess/WebProcess.cpp:
     215        (WebKit::WebProcess::networkProcessConnectionClosed):
     216        (WebKit::WebProcess::webToStorageProcessConnectionClosed):
     217
    12182018-09-11  Simon Fraser  <simon.fraser@apple.com>
    2219

  • trunk/Source/WebKit/DerivedSources.make

    r235921 r235954  
    2929    $(WebKit2)/NetworkProcess/mac \
    3030    $(WebKit2)/NetworkProcess/webrtc \
     31    $(WebKit2)/NetworkProcess/IndexedDB \
    3132    $(WebKit2)/PluginProcess \
    3233    $(WebKit2)/PluginProcess/mac \
    … …  
    3738    $(WebKit2)/Shared/mac \
    3839    $(WebKit2)/StorageProcess \
    39     $(WebKit2)/StorageProcess/IndexedDB \
    4040    $(WebKit2)/StorageProcess/ServiceWorker \
    4141    $(WebKit2)/StorageProcess/mac \

  • trunk/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp

    r235953 r235954  
    3030
    3131#include "DataReference.h"
    32 #include "StorageProcess.h"
     32#include "NetworkProcess.h"
    3333#include "WebCoreArgumentCoders.h"
    3434#include "WebIDBConnectionToServerMessages.h"
    … …  
    4646namespace WebKit {
    4747
    48 Ref<WebIDBConnectionToClient> WebIDBConnectionToClient::create(StorageToWebProcessConnection& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
     48Ref<WebIDBConnectionToClient> WebIDBConnectionToClient::create(NetworkConnectionToWebProcess& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
    4949{
    5050    return adoptRef(*new WebIDBConnectionToClient(connection, serverConnectionIdentifier, sessionID));
    5151}
    5252
    53 WebIDBConnectionToClient::WebIDBConnectionToClient(StorageToWebProcessConnection& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
     53WebIDBConnectionToClient::WebIDBConnectionToClient(NetworkConnectionToWebProcess& connection, uint64_t serverConnectionIdentifier, PAL::SessionID sessionID)
    5454    : m_connection(connection)
    5555    , m_identifier(serverConnectionIdentifier)
    … …  
    5858    relaxAdoptionRequirement();
    5959    m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this);
    60     StorageProcess::singleton().idbServer(m_sessionID).registerConnection(*m_connectionToClient);
     60    NetworkProcess::singleton().idbServer(m_sessionID).registerConnection(*m_connectionToClient);
    6161}
    6262
    … …  
    6767void WebIDBConnectionToClient::disconnectedFromWebProcess()
    6868{
    69     StorageProcess::singleton().idbServer(m_sessionID).unregisterConnection(*m_connectionToClient);
     69    NetworkProcess::singleton().idbServer(m_sessionID).unregisterConnection(*m_connectionToClient);
    7070}
    7171
    … …  
    159159
    160160#if ENABLE(SANDBOX_EXTENSIONS)
    161     StorageProcess::singleton().getSandboxExtensionsForBlobFiles(blobFilePaths, [protectedThis = makeRef(*this), this, resultData](SandboxExtension::HandleArray&& handles) {
     161    NetworkProcess::singleton().getSandboxExtensionsForBlobFiles(blobFilePaths, [protectedThis = makeRef(*this), this, resultData](SandboxExtension::HandleArray&& handles) {
    162162        send(MessageType({ resultData, WTFMove(handles) }));
    163163    });
    … …  
    224224void WebIDBConnectionToClient::deleteDatabase(const IDBRequestData& request)
    225225{
    226     StorageProcess::singleton().idbServer(m_sessionID).deleteDatabase(request);
     226    NetworkProcess::singleton().idbServer(m_sessionID).deleteDatabase(request);
    227227}
    228228
    229229void WebIDBConnectionToClient::openDatabase(const IDBRequestData& request)
    230230{
    231     StorageProcess::singleton().idbServer(m_sessionID).openDatabase(request);
     231    NetworkProcess::singleton().idbServer(m_sessionID).openDatabase(request);
    232232}
    233233
    234234void WebIDBConnectionToClient::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
    235235{
    236     StorageProcess::singleton().idbServer(m_sessionID).abortTransaction(transactionIdentifier);
     236    NetworkProcess::singleton().idbServer(m_sessionID).abortTransaction(transactionIdentifier);
    237237}
    238238
    239239void WebIDBConnectionToClient::commitTransaction(const IDBResourceIdentifier& transactionIdentifier)
    240240{
    241     StorageProcess::singleton().idbServer(m_sessionID).commitTransaction(transactionIdentifier);
     241    NetworkProcess::singleton().idbServer(m_sessionID).commitTransaction(transactionIdentifier);
    242242}
    243243
    244244void WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    245245{
    246     StorageProcess::singleton().idbServer(m_sessionID).didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
     246    NetworkProcess::singleton().idbServer(m_sessionID).didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
    247247}
    248248
    249249void WebIDBConnectionToClient::createObjectStore(const IDBRequestData& request, const IDBObjectStoreInfo& info)
    250250{
    251     StorageProcess::singleton().idbServer(m_sessionID).createObjectStore(request, info);
     251    NetworkProcess::singleton().idbServer(m_sessionID).createObjectStore(request, info);
    252252}
    253253
    254254void WebIDBConnectionToClient::deleteObjectStore(const IDBRequestData& request, const String& name)
    255255{
    256     StorageProcess::singleton().idbServer(m_sessionID).deleteObjectStore(request, name);
     256    NetworkProcess::singleton().idbServer(m_sessionID).deleteObjectStore(request, name);
    257257}
    258258
    259259void WebIDBConnectionToClient::renameObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& newName)
    260260{
    261     StorageProcess::singleton().idbServer(m_sessionID).renameObjectStore(request, objectStoreIdentifier, newName);
     261    NetworkProcess::singleton().idbServer(m_sessionID).renameObjectStore(request, objectStoreIdentifier, newName);
    262262}
    263263
    264264void WebIDBConnectionToClient::clearObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier)
    265265{
    266     StorageProcess::singleton().idbServer(m_sessionID).clearObjectStore(request, objectStoreIdentifier);
     266    NetworkProcess::singleton().idbServer(m_sessionID).clearObjectStore(request, objectStoreIdentifier);
    267267}
    268268
    269269void WebIDBConnectionToClient::createIndex(const IDBRequestData& request, const IDBIndexInfo& info)
    270270{
    271     StorageProcess::singleton().idbServer(m_sessionID).createIndex(request, info);
     271    NetworkProcess::singleton().idbServer(m_sessionID).createIndex(request, info);
    272272}
    273273
    274274void WebIDBConnectionToClient::deleteIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& name)
    275275{
    276     StorageProcess::singleton().idbServer(m_sessionID).deleteIndex(request, objectStoreIdentifier, name);
     276    NetworkProcess::singleton().idbServer(m_sessionID).deleteIndex(request, objectStoreIdentifier, name);
    277277}
    278278
    279279void WebIDBConnectionToClient::renameIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName)
    280280{
    281     StorageProcess::singleton().idbServer(m_sessionID).renameIndex(request, objectStoreIdentifier, indexIdentifier, newName);
     281    NetworkProcess::singleton().idbServer(m_sessionID).renameIndex(request, objectStoreIdentifier, indexIdentifier, newName);
    282282}
    283283
    … …  
    294294    IndexedDB::ObjectStoreOverwriteMode mode = static_cast<IndexedDB::ObjectStoreOverwriteMode>(overwriteMode);
    295295
    296     StorageProcess::singleton().idbServer(m_sessionID).putOrAdd(request, key, value, mode);
     296    NetworkProcess::singleton().idbServer(m_sessionID).putOrAdd(request, key, value, mode);
    297297}
    298298
    299299void WebIDBConnectionToClient::getRecord(const IDBRequestData& request, const IDBGetRecordData& getRecordData)
    300300{
    301     StorageProcess::singleton().idbServer(m_sessionID).getRecord(request, getRecordData);
     301    NetworkProcess::singleton().idbServer(m_sessionID).getRecord(request, getRecordData);
    302302}
    303303
    304304void WebIDBConnectionToClient::getAllRecords(const IDBRequestData& request, const IDBGetAllRecordsData& getAllRecordsData)
    305305{
    306     StorageProcess::singleton().idbServer(m_sessionID).getAllRecords(request, getAllRecordsData);
     306    NetworkProcess::singleton().idbServer(m_sessionID).getAllRecords(request, getAllRecordsData);
    307307}
    308308
    309309void WebIDBConnectionToClient::getCount(const IDBRequestData& request, const IDBKeyRangeData& range)
    310310{
    311     StorageProcess::singleton().idbServer(m_sessionID).getCount(request, range);
     311    NetworkProcess::singleton().idbServer(m_sessionID).getCount(request, range);
    312312}
    313313
    314314void WebIDBConnectionToClient::deleteRecord(const IDBRequestData& request, const IDBKeyRangeData& range)
    315315{
    316     StorageProcess::singleton().idbServer(m_sessionID).deleteRecord(request, range);
     316    NetworkProcess::singleton().idbServer(m_sessionID).deleteRecord(request, range);
    317317}
    318318
    319319void WebIDBConnectionToClient::openCursor(const IDBRequestData& request, const IDBCursorInfo& info)
    320320{
    321     StorageProcess::singleton().idbServer(m_sessionID).openCursor(request, info);
     321    NetworkProcess::singleton().idbServer(m_sessionID).openCursor(request, info);
    322322}
    323323
    324324void WebIDBConnectionToClient::iterateCursor(const IDBRequestData& request, const IDBIterateCursorData& data)
    325325{
    326     StorageProcess::singleton().idbServer(m_sessionID).iterateCursor(request, data);
     326    NetworkProcess::singleton().idbServer(m_sessionID).iterateCursor(request, data);
    327327}
    328328
    329329void WebIDBConnectionToClient::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
    330330{
    331     StorageProcess::singleton().idbServer(m_sessionID).establishTransaction(databaseConnectionIdentifier, info);
     331    NetworkProcess::singleton().idbServer(m_sessionID).establishTransaction(databaseConnectionIdentifier, info);
    332332}
    333333
    334334void WebIDBConnectionToClient::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier)
    335335{
    336     StorageProcess::singleton().idbServer(m_sessionID).databaseConnectionPendingClose(databaseConnectionIdentifier);
     336    NetworkProcess::singleton().idbServer(m_sessionID).databaseConnectionPendingClose(databaseConnectionIdentifier);
    337337}
    338338
    339339void WebIDBConnectionToClient::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
    340340{
    341     StorageProcess::singleton().idbServer(m_sessionID).databaseConnectionClosed(databaseConnectionIdentifier);
     341    NetworkProcess::singleton().idbServer(m_sessionID).databaseConnectionClosed(databaseConnectionIdentifier);
    342342}
    343343
    344344void WebIDBConnectionToClient::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    345345{
    346     StorageProcess::singleton().idbServer(m_sessionID).abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
     346    NetworkProcess::singleton().idbServer(m_sessionID).abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
    347347}
    348348
    349349void WebIDBConnectionToClient::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    350350{
    351     StorageProcess::singleton().idbServer(m_sessionID).didFireVersionChangeEvent(databaseConnectionIdentifier, transactionIdentifier);
     351    NetworkProcess::singleton().idbServer(m_sessionID).didFireVersionChangeEvent(databaseConnectionIdentifier, transactionIdentifier);
    352352}
    353353
    354354void WebIDBConnectionToClient::openDBRequestCancelled(const IDBRequestData& requestData)
    355355{
    356     StorageProcess::singleton().idbServer(m_sessionID).openDBRequestCancelled(requestData);
     356    NetworkProcess::singleton().idbServer(m_sessionID).openDBRequestCancelled(requestData);
    357357}
    358358
    359359void WebIDBConnectionToClient::confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier)
    360360{
    361     StorageProcess::singleton().idbServer(m_sessionID).confirmDidCloseFromServer(databaseConnectionIdentifier);
     361    NetworkProcess::singleton().idbServer(m_sessionID).confirmDidCloseFromServer(databaseConnectionIdentifier);
    362362}
    363363
    364364void WebIDBConnectionToClient::getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID)
    365365{
    366     StorageProcess::singleton().idbServer(m_sessionID).getAllDatabaseNames(serverConnectionIdentifier, topOrigin, openingOrigin, callbackID);
     366    NetworkProcess::singleton().idbServer(m_sessionID).getAllDatabaseNames(serverConnectionIdentifier, topOrigin, openingOrigin, callbackID);
    367367}
    368368

  • trunk/Source/WebKit/NetworkProcess/IndexedDB/WebIDBConnectionToClient.h

    r235953 r235954  
    2929
    3030#include "MessageSender.h"
    31 #include "StorageToWebProcessConnection.h"
     31#include "NetworkConnectionToWebProcess.h"
    3232#include <WebCore/IDBConnectionToClient.h>
    3333#include <pal/SessionID.h>
    … …  
    5353class WebIDBConnectionToClient final : public WebCore::IDBServer::IDBConnectionToClientDelegate, public IPC::MessageSender, public RefCounted<WebIDBConnectionToClient> {
    5454public:
    55     static Ref<WebIDBConnectionToClient> create(StorageToWebProcessConnection&, uint64_t serverConnectionIdentifier, PAL::SessionID);
     55    static Ref<WebIDBConnectionToClient> create(NetworkConnectionToWebProcess&, uint64_t serverConnectionIdentifier, PAL::SessionID);
    5656
    5757    virtual ~WebIDBConnectionToClient();
    … …  
    127127
    128128private:
    129     WebIDBConnectionToClient(StorageToWebProcessConnection&, uint64_t serverConnectionIdentifier, PAL::SessionID);
     129    WebIDBConnectionToClient(NetworkConnectionToWebProcess&, uint64_t serverConnectionIdentifier, PAL::SessionID);
    130130
    131131    IPC::Connection* messageSenderConnection() final;
    … …  
    133133    template<class MessageType> void handleGetResult(const WebCore::IDBResultData&);
    134134
    135     Ref<StorageToWebProcessConnection> m_connection;
     135    Ref<NetworkConnectionToWebProcess> m_connection;
    136136
    137137    uint64_t m_identifier;

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r235101 r235954  
    5050#include "WebCoreArgumentCoders.h"
    5151#include "WebErrors.h"
     52#include "WebIDBConnectionToClient.h"
     53#include "WebIDBConnectionToClientMessages.h"
    5254#include "WebsiteDataStore.h"
    5355#include "WebsiteDataStoreParameters.h"
    … …  
    5759#include <WebCore/SameSiteInfo.h>
    5860#include <WebCore/SecurityPolicy.h>
    59 #include <pal/SessionID.h>
    6061
    6162namespace WebKit {
    … …  
    147148    }
    148149
     150#if ENABLE(INDEXED_DATABASE)
     151    if (decoder.messageReceiverName() == Messages::WebIDBConnectionToClient::messageReceiverName()) {
     152        auto iterator = m_webIDBConnections.find(decoder.destinationID());
     153        if (iterator != m_webIDBConnections.end())
     154            iterator->value->didReceiveMessage(connection, decoder);
     155        return;
     156    }
     157#endif
     158
    149159    ASSERT_NOT_REACHED();
    150160}
    … …  
    197207    }
    198208#endif
     209
     210#if ENABLE(INDEXED_DATABASE)
     211    auto idbConnections = m_webIDBConnections;
     212    for (auto& connection : idbConnections.values())
     213        connection->disconnectedFromWebProcess();
     214   
     215    m_webIDBConnections.clear();
     216#endif
     217
    199218}
    200219
    … …  
    484503            file->revokeFileAccess();
    485504
    486         NetworkProcess::singleton().grantSandboxExtensionsToStorageProcessForBlobs(fileNames, [this, protectedThis = WTFMove(protectedThis), requestIdentifier, fileNames]() {
    487             if (!m_connection->isValid())
    488                 return;
    489 
    490             m_connection->send(Messages::NetworkProcessConnection::DidWriteBlobsToTemporaryFiles(requestIdentifier, fileNames), 0);
     505#if ENABLE(SANDBOX_EXTENSIONS)
     506        NetworkProcess::singleton().getSandboxExtensionsForBlobFiles(fileNames, [protectedThis = WTFMove(protectedThis), fileNames](SandboxExtension::HandleArray&& handles) {
     507            ASSERT(fileNames.size() == handles.size());
     508            NetworkProcess::singleton().updateTemporaryFileSandboxExtensions(fileNames, handles);
    491509        });
     510#endif
     511
     512        if (!m_connection->isValid())
     513            return;
     514        m_connection->send(Messages::NetworkProcessConnection::DidWriteBlobsToTemporaryFiles(requestIdentifier, fileNames), 0);
    492515    });
    493516}
    … …  
    644667}
    645668
     669#if ENABLE(INDEXED_DATABASE)
     670static uint64_t generateIDBConnectionToServerIdentifier()
     671{
     672    ASSERT(RunLoop::isMain());
     673    static uint64_t identifier = 0;
     674    return ++identifier;
     675}
     676
     677void NetworkConnectionToWebProcess::establishIDBConnectionToServer(PAL::SessionID sessionID, uint64_t& serverConnectionIdentifier)
     678{
     679    serverConnectionIdentifier = generateIDBConnectionToServerIdentifier();
     680    LOG(IndexedDB, "StorageToWebProcessConnection::establishIDBConnectionToServer - %" PRIu64, serverConnectionIdentifier);
     681    ASSERT(!m_webIDBConnections.contains(serverConnectionIdentifier));
     682   
     683    m_webIDBConnections.set(serverConnectionIdentifier, WebIDBConnectionToClient::create(*this, serverConnectionIdentifier, sessionID));
     684}
     685
     686void NetworkConnectionToWebProcess::removeIDBConnectionToServer(uint64_t serverConnectionIdentifier)
     687{
     688    ASSERT(m_webIDBConnections.contains(serverConnectionIdentifier));
     689   
     690    auto connection = m_webIDBConnections.take(serverConnectionIdentifier);
     691    connection->disconnectedFromWebProcess();
     692}
     693#endif
     694
    646695} // namespace WebKit

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

    r233801 r235954  
    3636#include <WebCore/NetworkLoadInformation.h>
    3737#include <WebCore/ResourceLoadPriority.h>
     38#include <pal/SessionID.h>
    3839#include <wtf/RefCounted.h>
    3940
    … …  
    5556class NetworkSocketStream;
    5657class SyncNetworkResourceLoader;
     58class WebIDBConnectionToClient;
    5759typedef uint64_t ResourceLoadIdentifier;
    5860
    … …  
    239241
    240242    RefPtr<CacheStorageEngineConnection> m_cacheStorageConnection;
     243
     244#if ENABLE(INDEXED_DATABASE)
     245    // Messages handlers (Modern IDB)
     246    void establishIDBConnectionToServer(PAL::SessionID, uint64_t& serverConnectionIdentifier);
     247    void removeIDBConnectionToServer(uint64_t serverConnectionIdentifier);
     248   
     249    HashMap<uint64_t, RefPtr<WebIDBConnectionToClient>> m_webIDBConnections;
     250#endif
     251
    241252};
    242253

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in

    r235951 r235954  
    7171    GetNetworkLoadIntermediateInformation(uint64_t resourceLoadIdentifier) -> (Vector<WebCore::NetworkTransactionInformation> transactions);
    7272    TakeNetworkLoadInformationMetrics(uint64_t resourceLoadIdentifier) -> (WebCore::NetworkLoadMetrics networkMetrics);
     73
     74#if ENABLE(INDEXED_DATABASE)
     75    EstablishIDBConnectionToServer(PAL::SessionID sessionID) -> (uint64_t serverConnectionIdentifier)
     76    RemoveIDBConnectionToServer(uint64_t serverConnectionIdentifier)
     77#endif
     78
    7379}

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

    r235179 r235954  
    115115    , m_clearCacheDispatchGroup(0)
    116116#endif
     117    , m_storageTaskQueue(WorkQueue::create("com.apple.WebKit.StorageTask"))
    117118{
    118119    NetworkProcessPlatformStrategies::initialize();
    … …  
    289290
    290291    SessionTracker::setSession(PAL::SessionID::defaultSessionID(), NetworkSession::create(NetworkSessionCreationParameters()));
     292
     293#if ENABLE(INDEXED_DATABASE)
     294    addIndexedDatabaseSession(PAL::SessionID::defaultSessionID(), parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
     295#endif
    291296
    292297    auto* defaultSession = SessionTracker::networkSession(PAL::SessionID::defaultSessionID());
    … …  
    389394void NetworkProcess::addWebsiteDataStore(WebsiteDataStoreParameters&& parameters)
    390395{
     396#if ENABLE(INDEXED_DATABASE)
     397    addIndexedDatabaseSession(parameters.networkSessionParameters.sessionID, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
     398#endif
     399
    391400    RemoteNetworkingContext::ensureWebsiteDataStoreSession(WTFMove(parameters));
    392401}
    … …  
    397406    m_sessionsControlledByAutomation.remove(sessionID);
    398407    CacheStorage::Engine::destroyEngine(sessionID);
    399 }
    400 
    401 void NetworkProcess::grantSandboxExtensionsToStorageProcessForBlobs(const Vector<String>& filenames, Function<void ()>&& completionHandler)
    402 {
    403     static uint64_t lastRequestID;
    404 
    405     uint64_t requestID = ++lastRequestID;
    406     m_sandboxExtensionForBlobsCompletionHandlers.set(requestID, WTFMove(completionHandler));
    407     parentProcessConnection()->send(Messages::NetworkProcessProxy::GrantSandboxExtensionsToStorageProcessForBlobs(requestID, filenames), 0);
    408 }
    409 
    410 void NetworkProcess::didGrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID)
    411 {
    412     if (auto handler = m_sandboxExtensionForBlobsCompletionHandlers.take(requestID))
    413         handler();
    414408}
    415409
    … …  
    576570#endif
    577571
     572#if ENABLE(INDEXED_DATABASE)
     573    auto path = m_idbDatabasePaths.get(sessionID);
     574    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
     575        // FIXME: Pick the right database store based on the session ID.
     576        postStorageTask(CrossThreadTask([this, callbackAggregator = callbackAggregator.copyRef(), path = WTFMove(path)]() mutable {
     577            RunLoop::main().dispatch([callbackAggregator = WTFMove(callbackAggregator), securityOrigins = indexedDatabaseOrigins(path)] {
     578                for (const auto& securityOrigin : securityOrigins)
     579                    callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
     580            });
     581        }));
     582    }
     583#endif
     584
    578585    if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
    579586        fetchDiskCacheEntries(sessionID, fetchOptions, [callbackAggregator = WTFMove(callbackAggregator)](auto entries) mutable {
    … …  
    608615    if (websiteDataTypes.contains(WebsiteDataType::DOMCache))
    609616        CacheStorage::Engine::clearAllCaches(sessionID, [clearTasksHandler = clearTasksHandler.copyRef()] { });
     617
     618#if ENABLE(INDEXED_DATABASE)
     619    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
     620        idbServer(sessionID).closeAndDeleteDatabasesModifiedSince(modifiedSince, [clearTasksHandler = clearTasksHandler.copyRef()] { });
     621#endif
    610622
    611623    if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
    … …  
    660672            CacheStorage::Engine::clearCachesForOrigin(sessionID, SecurityOriginData { originData }, [clearTasksHandler = clearTasksHandler.copyRef()] { });
    661673    }
     674
     675#if ENABLE(INDEXED_DATABASE)
     676    if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
     677        idbServer(sessionID).closeAndDeleteDatabasesForOrigins(originDatas, [clearTasksHandler = clearTasksHandler.copyRef()] { });
     678#endif
    662679
    663680    if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
    … …  
    949966}
    950967
     968#if ENABLE(INDEXED_DATABASE)
     969IDBServer::IDBServer& NetworkProcess::idbServer(PAL::SessionID sessionID)
     970{
     971    auto addResult = m_idbServers.add(sessionID, nullptr);
     972    if (!addResult.isNewEntry) {
     973        ASSERT(addResult.iterator->value);
     974        return *addResult.iterator->value;
     975    }
     976   
     977    auto path = m_idbDatabasePaths.get(sessionID);
     978    // There should already be a registered path for this PAL::SessionID.
     979    // If there's not, then where did this PAL::SessionID come from?
     980    ASSERT(!path.isEmpty());
     981   
     982    addResult.iterator->value = IDBServer::IDBServer::create(path, NetworkProcess::singleton());
     983    return *addResult.iterator->value;
     984}
     985
     986void NetworkProcess::ensurePathExists(const String& path)
     987{
     988    ASSERT(!RunLoop::isMain());
     989   
     990    if (!FileSystem::makeAllDirectories(path))
     991        LOG_ERROR("Failed to make all directories for path '%s'", path.utf8().data());
     992}
     993
     994void NetworkProcess::postStorageTask(CrossThreadTask&& task)
     995{
     996    ASSERT(RunLoop::isMain());
     997   
     998    LockHolder locker(m_storageTaskMutex);
     999   
     1000    m_storageTasks.append(WTFMove(task));
     1001   
     1002    m_storageTaskQueue->dispatch([this] {
     1003        performNextStorageTask();
     1004    });
     1005}
     1006
     1007void NetworkProcess::performNextStorageTask()
     1008{
     1009    ASSERT(!RunLoop::isMain());
     1010   
     1011    CrossThreadTask task;
     1012    {
     1013        LockHolder locker(m_storageTaskMutex);
     1014        ASSERT(!m_storageTasks.isEmpty());
     1015        task = m_storageTasks.takeFirst();
     1016    }
     1017   
     1018    task.performTask();
     1019}
     1020
     1021void NetworkProcess::prepareForAccessToTemporaryFile(const String& path)
     1022{
     1023    if (auto extension = m_blobTemporaryFileSandboxExtensions.get(path))
     1024        extension->consume();
     1025}
     1026
     1027void NetworkProcess::accessToTemporaryFileComplete(const String& path)
     1028{
     1029    // We've either hard linked the temporary blob file to the database directory, copied it there,
     1030    // or the transaction is being aborted.
     1031    // In any of those cases, we can delete the temporary blob file now.
     1032    FileSystem::deleteFile(path);
     1033   
     1034    if (auto extension = m_blobTemporaryFileSandboxExtensions.take(path))
     1035        extension->revoke();
     1036}
     1037
     1038HashSet<WebCore::SecurityOriginData> NetworkProcess::indexedDatabaseOrigins(const String& path)
     1039{
     1040    if (path.isEmpty())
     1041        return { };
     1042   
     1043    HashSet<WebCore::SecurityOriginData> securityOrigins;
     1044    for (auto& topOriginPath : FileSystem::listDirectory(path, "*")) {
     1045        auto databaseIdentifier = FileSystem::pathGetFileName(topOriginPath);
     1046        if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
     1047            securityOrigins.add(WTFMove(*securityOrigin));
     1048       
     1049        for (auto& originPath : FileSystem::listDirectory(topOriginPath, "*")) {
     1050            databaseIdentifier = FileSystem::pathGetFileName(originPath);
     1051            if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
     1052                securityOrigins.add(WTFMove(*securityOrigin));
     1053        }
     1054    }
     1055
     1056    return securityOrigins;
     1057}
     1058
     1059void NetworkProcess::addIndexedDatabaseSession(PAL::SessionID sessionID, String& indexedDatabaseDirectory, SandboxExtension::Handle& handle)
     1060{
     1061    // *********
     1062    // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
     1063    // *********
     1064    auto addResult = m_idbDatabasePaths.ensure(sessionID, [path = indexedDatabaseDirectory] {
     1065        return path;
     1066    });
     1067    if (addResult.isNewEntry) {
     1068        SandboxExtension::consumePermanently(handle);
     1069        if (!indexedDatabaseDirectory.isEmpty())
     1070            postStorageTask(createCrossThreadTask(*this, &NetworkProcess::ensurePathExists, indexedDatabaseDirectory));
     1071    }
     1072}
     1073
     1074#endif // ENABLE(INDEXED_DATABASE)
     1075
     1076#if ENABLE(SANDBOX_EXTENSIONS)
     1077void NetworkProcess::getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void(SandboxExtension::HandleArray&&)>&& completionHandler)
     1078{
     1079
     1080    static uint64_t lastRequestID;
     1081   
     1082    uint64_t requestID = ++lastRequestID;
     1083    m_sandboxExtensionForBlobsCompletionHandlersStorageForNetworkProcess.set(requestID, WTFMove(completionHandler));
     1084    parentProcessConnection()->send(Messages::NetworkProcessProxy::GetSandboxExtensionsForBlobFiles(requestID, filenames), 0);
     1085}
     1086
     1087void NetworkProcess::didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&& handles)
     1088{
     1089    if (auto handler = m_sandboxExtensionForBlobsCompletionHandlersStorageForNetworkProcess.take(requestID))
     1090        handler(WTFMove(handles));
     1091}
     1092   
     1093void NetworkProcess::updateTemporaryFileSandboxExtensions(const Vector<String>& paths, SandboxExtension::HandleArray& handles)
     1094{
     1095    for (size_t i = 0; i < handles.size(); ++i) {
     1096        auto result = m_blobTemporaryFileSandboxExtensions.add(paths[i], SandboxExtension::create(WTFMove(handles[i])));
     1097        ASSERT_UNUSED(result, result.isNewEntry);
     1098    }
     1099}
     1100#endif // ENABLE(SANDBOX_EXTENSIONS)
     1101
    9511102#if !PLATFORM(COCOA)
    9521103void NetworkProcess::initializeProcess(const ChildProcessInitializationParameters&)

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

    r234968 r235954  
    3131#include "MessageReceiverMap.h"
    3232#include "NetworkContentRuleListManager.h"
     33#include "SandboxExtension.h"
    3334#include <WebCore/DiagnosticLoggingClient.h>
     35#include <WebCore/IDBBackingStore.h>
     36#include <WebCore/IDBKeyData.h>
     37#include <WebCore/IDBServer.h>
     38#include <WebCore/UniqueIDBDatabase.h>
    3439#include <memory>
    3540#include <pal/SessionID.h>
    36 #include <wtf/Forward.h>
     41#include <wtf/CrossThreadTask.h>
    3742#include <wtf/Function.h>
    3843#include <wtf/HashSet.h>
    … …  
    7580}
    7681
    77 class NetworkProcess : public ChildProcess, private DownloadManager::Client {
     82class NetworkProcess : public ChildProcess, private DownloadManager::Client
     83#if ENABLE(INDEXED_DATABASE)
     84    , public WebCore::IDBServer::IDBBackingStoreTemporaryFileHandler
     85#endif
     86{
    7887    WTF_MAKE_NONCOPYABLE(NetworkProcess);
    7988    friend NeverDestroyed<NetworkProcess>;
    … …  
    130139
    131140    void addWebsiteDataStore(WebsiteDataStoreParameters&&);
    132 
    133     void grantSandboxExtensionsToStorageProcessForBlobs(const Vector<String>& filenames, Function<void ()>&& completionHandler);
    134141
    135142#if HAVE(CFNETWORK_STORAGE_PARTITIONING)
    … …  
    160167#endif
    161168
     169    WorkQueue& queue() { return m_storageTaskQueue.get(); }
     170    void postStorageTask(CrossThreadTask&&);
     171#if ENABLE(INDEXED_DATABASE)
     172
     173    WebCore::IDBServer::IDBServer& idbServer(PAL::SessionID);
     174   
     175    // WebCore::IDBServer::IDBBackingStoreFileHandler
     176    void prepareForAccessToTemporaryFile(const String& path) final;
     177    void accessToTemporaryFileComplete(const String& path) final;
     178#endif
     179
     180#if ENABLE(SANDBOX_EXTENSIONS)
     181    void getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void(SandboxExtension::HandleArray&&)>&& completionHandler);
     182    void updateTemporaryFileSandboxExtensions(const Vector<String>& paths, SandboxExtension::HandleArray&);
     183#endif
     184
    162185private:
    163186    NetworkProcess();
    … …  
    211234    void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, WallTime modifiedSince, uint64_t callbackID);
    212235    void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>& origins, const Vector<String>& cookieHostNames, const Vector<String>& HSTSCacheHostnames, uint64_t callbackID);
     236
     237#if ENABLE(SANDBOX_EXTENSIONS)
     238    void didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&&);
     239#endif
    213240
    214241    void clearCachedCredentials();
    … …  
    235262    void didSyncAllCookies();
    236263
    237     void didGrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID);
    238 
    239264    void writeBlobToFilePath(const WebCore::URL&, const String& path, SandboxExtension::Handle&&, uint64_t requestID);
    240265
    … …  
    258283    void registerURLSchemeAsCORSEnabled(const String&) const;
    259284    void registerURLSchemeAsCanDisplayOnlyIfCanRequest(const String&) const;
     285
     286    // For execution on work queue thread only
     287    void performNextStorageTask();
     288    void ensurePathExists(const String& path);
     289
     290#if ENABLE(INDEXED_DATABASE)
     291    void addIndexedDatabaseSession(PAL::SessionID, String&, SandboxExtension::Handle&);
     292    HashSet<WebCore::SecurityOriginData> indexedDatabaseOrigins(const String& path);
     293#endif
    260294
    261295    // Connections to WebProcesses.
    … …  
    279313    NetworkProcessSupplementMap m_supplements;
    280314
    281     HashMap<uint64_t, Function<void()>> m_sandboxExtensionForBlobsCompletionHandlers;
    282315    HashSet<PAL::SessionID> m_sessionsControlledByAutomation;
    283316
    … …  
    299332    NetworkContentRuleListManager m_NetworkContentRuleListManager;
    300333#endif
     334
     335    Ref<WorkQueue> m_storageTaskQueue;
     336
     337#if ENABLE(INDEXED_DATABASE)
     338    HashMap<PAL::SessionID, String> m_idbDatabasePaths;
     339    HashMap<PAL::SessionID, RefPtr<WebCore::IDBServer::IDBServer>> m_idbServers;
     340#endif
     341
     342    HashMap<String, RefPtr<SandboxExtension>> m_blobTemporaryFileSandboxExtensions;
     343    HashMap<uint64_t, WTF::Function<void(SandboxExtension::HandleArray&&)>> m_sandboxExtensionForBlobsCompletionHandlersStorageForNetworkProcess;
     344   
     345    Deque<CrossThreadTask> m_storageTasks;
     346    Lock m_storageTaskMutex;
     347
    301348};
    302349

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.messages.in

    r234941 r235954  
    7474    ProcessDidResume()
    7575
    76     DidGrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID)
     76#if ENABLE(SANDBOX_EXTENSIONS)
     77    DidGetSandboxExtensionsForBlobFiles(uint64_t requestID, WebKit::SandboxExtension::HandleArray extensions)
     78#endif
    7779
    7880    WriteBlobToFilePath(WebCore::URL blobURL, String path, WebKit::SandboxExtension::Handle handle, uint64_t callbackID)

  • trunk/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp

    r235179 r235954  
    109109    encoder << wirelessContextIdentifier;
    110110#endif
     111
     112#if ENABLE(INDEXED_DATABASE)
     113    encoder << indexedDatabaseDirectory << indexedDatabaseDirectoryExtensionHandle;
     114#endif
     115
    111116}
    112117
    … …  
    247252#endif
    248253
     254#if ENABLE(INDEXED_DATABASE)
     255    if (!decoder.decode(result.indexedDatabaseDirectory))
     256        return false;
     257   
     258    std::optional<SandboxExtension::Handle> indexedDatabaseDirectoryExtensionHandle;
     259    decoder >> indexedDatabaseDirectoryExtensionHandle;
     260    if (!indexedDatabaseDirectoryExtensionHandle)
     261        return false;
     262    result.indexedDatabaseDirectoryExtensionHandle = WTFMove(*indexedDatabaseDirectoryExtensionHandle);
     263#endif
     264
    249265    return true;
    250266}

  • trunk/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h

    r235179 r235954  
    125125    unsigned wirelessContextIdentifier { 0 };
    126126#endif
     127
     128#if ENABLE(INDEXED_DATABASE)
     129    String indexedDatabaseDirectory;
     130    SandboxExtension::Handle indexedDatabaseDirectoryExtensionHandle;
     131#endif
     132
    127133};
    128134

  • trunk/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.cpp

    r229927 r235954  
    3838{
    3939    encoder << sessionID;
    40 #if ENABLE(INDEXED_DATABASE)
    41     encoder << indexedDatabaseDirectory << indexedDatabaseDirectoryExtensionHandle;
    42 #endif
    4340#if ENABLE(SERVICE_WORKER)
    4441    encoder << serviceWorkerRegistrationDirectory << serviceWorkerRegistrationDirectoryExtensionHandle << urlSchemesServiceWorkersCanHandle << shouldDisableServiceWorkerProcessTerminationDelay;
    … …  
    5047    if (!decoder.decode(result.sessionID))
    5148        return false;
    52 #if ENABLE(INDEXED_DATABASE)
    53     if (!decoder.decode(result.indexedDatabaseDirectory))
    54         return false;
    5549
    56     std::optional<SandboxExtension::Handle> indexedDatabaseDirectoryExtensionHandle;
    57     decoder >> indexedDatabaseDirectoryExtensionHandle;
    58     if (!indexedDatabaseDirectoryExtensionHandle)
    59         return false;
    60     result.indexedDatabaseDirectoryExtensionHandle = WTFMove(*indexedDatabaseDirectoryExtensionHandle);
    61 #endif
    6250#if ENABLE(SERVICE_WORKER)
    6351    if (!decoder.decode(result.serviceWorkerRegistrationDirectory))

  • trunk/Source/WebKit/Shared/Storage/StorageProcessCreationParameters.h

    r229927 r235954  
    4545
    4646    PAL::SessionID sessionID;
    47    
    48 #if ENABLE(INDEXED_DATABASE)
    49     String indexedDatabaseDirectory;
    50     SandboxExtension::Handle indexedDatabaseDirectoryExtensionHandle;
    51 #endif
    5247
    5348#if ENABLE(SERVICE_WORKER)

  • trunk/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp

    r235127 r235954  
    4242    encoder << cookieStoragePathExtensionHandle;
    4343    encoder << pendingCookies;
     44
     45#if ENABLE(INDEXED_DATABASE)
     46    encoder << indexedDatabaseDirectory << indexedDatabaseDirectoryExtensionHandle;
     47#endif
    4448}
    4549
    4650std::optional<WebsiteDataStoreParameters> WebsiteDataStoreParameters::decode(IPC::Decoder& decoder)
    4751{
     52    WebsiteDataStoreParameters parameters;
     53
    4854    std::optional<NetworkSessionCreationParameters> networkSessionParameters;
    4955    decoder >> networkSessionParameters;
    5056    if (!networkSessionParameters)
    5157        return std::nullopt;
     58    parameters.networkSessionParameters = WTFMove(*networkSessionParameters);
    5259
    5360    std::optional<Vector<uint8_t>> uiProcessCookieStorageIdentifier;
    … …  
    5562    if (!uiProcessCookieStorageIdentifier)
    5663        return std::nullopt;
     64    parameters.uiProcessCookieStorageIdentifier = WTFMove(*uiProcessCookieStorageIdentifier);
    5765
    5866    std::optional<SandboxExtension::Handle> cookieStoragePathExtensionHandle;
    … …  
    6068    if (!cookieStoragePathExtensionHandle)
    6169        return std::nullopt;
     70    parameters.cookieStoragePathExtensionHandle = WTFMove(*cookieStoragePathExtensionHandle);
    6271
    6372    std::optional<Vector<WebCore::Cookie>> pendingCookies;
    … …  
    6574    if (!pendingCookies)
    6675        return std::nullopt;
    67     return {{ WTFMove(*uiProcessCookieStorageIdentifier), WTFMove(*cookieStoragePathExtensionHandle), WTFMove(*pendingCookies), WTFMove(*networkSessionParameters)}};
     76    parameters.pendingCookies = WTFMove(*pendingCookies);
     77
     78#if ENABLE(INDEXED_DATABASE)
     79    std::optional<String> indexedDatabaseDirectory;
     80    decoder >> indexedDatabaseDirectory;
     81    if (!indexedDatabaseDirectory)
     82        return std::nullopt;
     83    parameters.indexedDatabaseDirectory = WTFMove(*indexedDatabaseDirectory);
     84   
     85    std::optional<SandboxExtension::Handle> indexedDatabaseDirectoryExtensionHandle;
     86    decoder >> indexedDatabaseDirectoryExtensionHandle;
     87    if (!indexedDatabaseDirectoryExtensionHandle)
     88        return std::nullopt;
     89    parameters.indexedDatabaseDirectoryExtensionHandle = WTFMove(*indexedDatabaseDirectoryExtensionHandle);
     90#endif
     91
     92    return WTFMove(parameters);
    6893}
    6994
    … …  
    75100        , nullptr , { } , { }
    76101#endif
    77     }};
     102        }
     103#if ENABLE(INDEXED_DATABASE)
     104        , { }, { }
     105#endif
     106    };
    78107}
    79108

  • trunk/Source/WebKit/Shared/WebsiteDataStoreParameters.h

    r232863 r235954  
    5656    Vector<WebCore::Cookie> pendingCookies;
    5757    NetworkSessionCreationParameters networkSessionParameters;
     58
     59#if ENABLE(INDEXED_DATABASE)
     60    String indexedDatabaseDirectory;
     61    SandboxExtension::Handle indexedDatabaseDirectoryExtensionHandle;
     62#endif
    5863};
    5964

  • trunk/Source/WebKit/Sources.txt

    r235921 r235954  
    4747
    4848NetworkProcess/FileAPI/NetworkBlobRegistry.cpp
     49
     50NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
    4951
    5052NetworkProcess/cache/CacheStorageEngine.cpp
    … …  
    221223StorageProcess/StorageToWebProcessConnection.cpp @no-unify
    222224
    223 StorageProcess/IndexedDB/WebIDBConnectionToClient.cpp @no-unify
    224 
    225225StorageProcess/ServiceWorker/WebSWOriginStore.cpp @no-unify
    226226StorageProcess/ServiceWorker/WebSWServerConnection.cpp @no-unify

  • trunk/Source/WebKit/StorageProcess/StorageProcess.cpp

    r233853 r235954  
    3939#include "WebsiteData.h"
    4040#include <WebCore/FileSystem.h>
    41 #include <WebCore/IDBKeyData.h>
    4241#include <WebCore/NotImplemented.h>
    4342#include <WebCore/SWServerWorker.h>
    … …  
    153152}
    154153
    155 #if ENABLE(INDEXED_DATABASE)
    156 IDBServer::IDBServer& StorageProcess::idbServer(PAL::SessionID sessionID)
    157 {
    158     auto addResult = m_idbServers.add(sessionID, nullptr);
    159     if (!addResult.isNewEntry) {
    160         ASSERT(addResult.iterator->value);
    161         return *addResult.iterator->value;
    162     }
    163 
    164     auto path = m_idbDatabasePaths.get(sessionID);
    165     // There should already be a registered path for this PAL::SessionID.
    166     // If there's not, then where did this PAL::SessionID come from?
    167     ASSERT(!path.isEmpty());
    168 
    169     addResult.iterator->value = IDBServer::IDBServer::create(path, StorageProcess::singleton());
    170     return *addResult.iterator->value;
    171 }
    172 #endif
    173 
    174154void StorageProcess::initializeWebsiteDataStore(const StorageProcessCreationParameters& parameters)
    175155{
    176 #if ENABLE(INDEXED_DATABASE)
    177     // *********
    178     // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
    179     // *********
    180 
    181     auto addResult = m_idbDatabasePaths.ensure(parameters.sessionID, [path = parameters.indexedDatabaseDirectory] {
    182         return path;
    183     });
    184     if (addResult.isNewEntry) {
    185         SandboxExtension::consumePermanently(parameters.indexedDatabaseDirectoryExtensionHandle);
    186         if (!parameters.indexedDatabaseDirectory.isEmpty())
    187             postStorageTask(createCrossThreadTask(*this, &StorageProcess::ensurePathExists, parameters.indexedDatabaseDirectory));
    188     }
    189 #endif
    190156#if ENABLE(SERVICE_WORKER)
    191157    if (!parentProcessHasServiceWorkerEntitlement())
    192158        return;
    193159
    194     addResult = m_swDatabasePaths.ensure(parameters.sessionID, [path = parameters.serviceWorkerRegistrationDirectory] {
     160    auto addResult = m_swDatabasePaths.ensure(parameters.sessionID, [path = parameters.serviceWorkerRegistrationDirectory] {
    195161        return path;
    196162    });
    … …  
    325291    }
    326292#endif
    327 
    328 #if ENABLE(INDEXED_DATABASE)
    329     path = m_idbDatabasePaths.get(sessionID);
    330     if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
    331         // FIXME: Pick the right database store based on the session ID.
    332         postStorageTask(CrossThreadTask([this, callbackAggregator = callbackAggregator.copyRef(), path = WTFMove(path), rawWebsiteData]() mutable {
    333             RunLoop::main().dispatch([callbackAggregator = WTFMove(callbackAggregator), rawWebsiteData, securityOrigins = indexedDatabaseOrigins(path)] {
    334                 for (const auto& securityOrigin : securityOrigins)
    335                     rawWebsiteData->entries.append({ securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
    336             });
    337         }));
    338     }
    339 #endif
    340293}
    341294
    … …  
    349302    if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations))
    350303        swServerForSession(sessionID).clearAll([callbackAggregator = callbackAggregator.copyRef()] { });
    351 #endif
    352 
    353 #if ENABLE(INDEXED_DATABASE)
    354     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
    355         idbServer(sessionID).closeAndDeleteDatabasesModifiedSince(modifiedSince, [callbackAggregator = WTFMove(callbackAggregator)] { });
    356304#endif
    357305}
    … …  
    370318    }
    371319#endif
    372 
    373 #if ENABLE(INDEXED_DATABASE)
    374     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases))
    375         idbServer(sessionID).closeAndDeleteDatabasesForOrigins(securityOrigins, [callbackAggregator = WTFMove(callbackAggregator)] { });
    376 #endif
    377 }
    378 
    379 #if ENABLE(SANDBOX_EXTENSIONS)
    380 void StorageProcess::grantSandboxExtensionsForBlobs(const Vector<String>& paths, SandboxExtension::HandleArray&& handles)
    381 {
    382     ASSERT(paths.size() == handles.size());
    383 
    384     for (size_t i = 0; i < paths.size(); ++i) {
    385         auto result = m_blobTemporaryFileSandboxExtensions.add(paths[i], SandboxExtension::create(WTFMove(handles[i])));
    386         ASSERT_UNUSED(result, result.isNewEntry);
    387     }
    388 }
    389 #endif
    390 
    391 #if ENABLE(INDEXED_DATABASE)
    392 void StorageProcess::prepareForAccessToTemporaryFile(const String& path)
    393 {
    394     if (auto extension = m_blobTemporaryFileSandboxExtensions.get(path))
    395         extension->consume();
    396 }
    397 
    398 void StorageProcess::accessToTemporaryFileComplete(const String& path)
    399 {
    400     // We've either hard linked the temporary blob file to the database directory, copied it there,
    401     // or the transaction is being aborted.
    402     // In any of those cases, we can delete the temporary blob file now.
    403     FileSystem::deleteFile(path);
    404 
    405     if (auto extension = m_blobTemporaryFileSandboxExtensions.take(path))
    406         extension->revoke();
    407 }
    408 
    409 HashSet<WebCore::SecurityOriginData> StorageProcess::indexedDatabaseOrigins(const String& path)
    410 {
    411     if (path.isEmpty())
    412         return { };
    413 
    414     HashSet<WebCore::SecurityOriginData> securityOrigins;
    415     for (auto& topOriginPath : FileSystem::listDirectory(path, "*")) {
    416         auto databaseIdentifier = FileSystem::pathGetFileName(topOriginPath);
    417         if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
    418             securityOrigins.add(WTFMove(*securityOrigin));
    419        
    420         for (auto& originPath : FileSystem::listDirectory(topOriginPath, "*")) {
    421             databaseIdentifier = FileSystem::pathGetFileName(originPath);
    422             if (auto securityOrigin = SecurityOriginData::fromDatabaseIdentifier(databaseIdentifier))
    423                 securityOrigins.add(WTFMove(*securityOrigin));
    424         }
    425     }
    426 
    427     return securityOrigins;
    428 }
    429 
    430 #endif
    431 
    432 #if ENABLE(SANDBOX_EXTENSIONS)
    433 void StorageProcess::getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void (SandboxExtension::HandleArray&&)>&& completionHandler)
    434 {
    435     static uint64_t lastRequestID;
    436 
    437     uint64_t requestID = ++lastRequestID;
    438     m_sandboxExtensionForBlobsCompletionHandlers.set(requestID, WTFMove(completionHandler));
    439     parentProcessConnection()->send(Messages::StorageProcessProxy::GetSandboxExtensionsForBlobFiles(requestID, filenames), 0);
    440 }
    441 
    442 void StorageProcess::didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&& handles)
    443 {
    444     if (auto handler = m_sandboxExtensionForBlobsCompletionHandlers.take(requestID))
    445         handler(WTFMove(handles));
    446 }
    447 #endif
     320}
    448321
    449322#if ENABLE(SERVICE_WORKER)

  • trunk/Source/WebKit/StorageProcess/StorageProcess.h

    r234910 r235954  
    2727
    2828#include "ChildProcess.h"
    29 #include "SandboxExtension.h"
    3029#include <WebCore/FetchIdentifier.h>
    31 #include <WebCore/IDBBackingStore.h>
    32 #include <WebCore/IDBServer.h>
    3330#include <WebCore/SecurityOriginData.h>
    3431#include <WebCore/ServiceWorkerIdentifier.h>
    3532#include <WebCore/ServiceWorkerTypes.h>
    36 #include <WebCore/UniqueIDBDatabase.h>
    3733#include <pal/SessionID.h>
    3834#include <wtf/CrossThreadTask.h>
    … …  
    6460
    6561class StorageProcess : public ChildProcess
    66 #if ENABLE(INDEXED_DATABASE)
    67     , public WebCore::IDBServer::IDBBackingStoreTemporaryFileHandler
    68 #endif
    6962{
    7063    WTF_MAKE_NONCOPYABLE(StorageProcess);
    … …  
    7669    ~StorageProcess();
    7770
    78     WorkQueue& queue() { return m_queue.get(); }
    7971    void postStorageTask(CrossThreadTask&&);
    80 
    81 #if ENABLE(INDEXED_DATABASE)
    82     WebCore::IDBServer::IDBServer& idbServer(PAL::SessionID);
    83 
    84     // WebCore::IDBServer::IDBBackingStoreFileHandler
    85     void prepareForAccessToTemporaryFile(const String& path) final;
    86     void accessToTemporaryFileComplete(const String& path) final;
    87 #endif
    88 
    89 #if ENABLE(SANDBOX_EXTENSIONS)
    90     void getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void (SandboxExtension::HandleArray&&)>&& completionHandler);
    91 #endif
    9272
    9373#if PLATFORM(IOS)
    … …  
    136116    void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, WallTime modifiedSince, uint64_t callbackID);
    137117    void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<WebCore::SecurityOriginData>& origins, uint64_t callbackID);
    138 #if ENABLE(SANDBOX_EXTENSIONS)
    139     void grantSandboxExtensionsForBlobs(const Vector<String>& paths, SandboxExtension::HandleArray&&);
    140     void didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&&);
    141 #endif
     118
    142119#if ENABLE(SERVICE_WORKER)
    143120    void didReceiveFetchResponse(WebCore::SWServerConnectionIdentifier, WebCore::FetchIdentifier, const WebCore::ResourceResponse&);
    … …  
    157134    bool needsServerToContextConnectionForOrigin(const WebCore::SecurityOriginData&) const;
    158135#endif
    159 #if ENABLE(INDEXED_DATABASE)
    160     HashSet<WebCore::SecurityOriginData> indexedDatabaseOrigins(const String& path);
    161 #endif
    162136
    163137    // For execution on work queue thread only
    … …  
    168142
    169143    Ref<WorkQueue> m_queue;
    170 
    171 #if ENABLE(INDEXED_DATABASE)
    172     HashMap<PAL::SessionID, String> m_idbDatabasePaths;
    173     HashMap<PAL::SessionID, RefPtr<WebCore::IDBServer::IDBServer>> m_idbServers;
    174 #endif
    175     HashMap<String, RefPtr<SandboxExtension>> m_blobTemporaryFileSandboxExtensions;
    176     HashMap<uint64_t, WTF::Function<void (SandboxExtension::HandleArray&&)>> m_sandboxExtensionForBlobsCompletionHandlers;
    177144
    178145    Deque<CrossThreadTask> m_storageTasks;

  • trunk/Source/WebKit/StorageProcess/StorageProcess.messages.in

    r235951 r235954  
    3131    DeleteWebsiteData(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes, WallTime modifiedSince, uint64_t callbackID)
    3232    DeleteWebsiteDataForOrigins(PAL::SessionID sessionID, OptionSet<WebKit::WebsiteDataType> websiteDataTypes, Vector<WebCore::SecurityOriginData> origins, uint64_t callbackID)
    33 #if ENABLE(SANDBOX_EXTENSIONS)
    34     GrantSandboxExtensionsForBlobs(Vector<String> paths, WebKit::SandboxExtension::HandleArray extensions)
    35     DidGetSandboxExtensionsForBlobFiles(uint64_t requestID, WebKit::SandboxExtension::HandleArray extensions)
    36 #endif
    3733
    3834    DestroySession(PAL::SessionID sessionID)

  • trunk/Source/WebKit/StorageProcess/StorageToWebProcessConnection.cpp

    r232824 r235954  
    3131#include "StorageProcessMessages.h"
    3232#include "StorageToWebProcessConnectionMessages.h"
    33 #include "WebIDBConnectionToClient.h"
    34 #include "WebIDBConnectionToClientMessages.h"
    3533#include "WebSWServerConnection.h"
    3634#include "WebSWServerConnectionMessages.h"
    … …  
    7068void StorageToWebProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
    7169{
    72     if (decoder.messageReceiverName() == Messages::StorageToWebProcessConnection::messageReceiverName()) {
    73         didReceiveStorageToWebProcessConnectionMessage(connection, decoder);
    74         return;
    75     }
    76 
    7770    if (decoder.messageReceiverName() == Messages::StorageProcess::messageReceiverName()) {
    7871        StorageProcess::singleton().didReceiveStorageProcessMessage(connection, decoder);
    7972        return;
    8073    }
    81 
    82 #if ENABLE(INDEXED_DATABASE)
    83     if (decoder.messageReceiverName() == Messages::WebIDBConnectionToClient::messageReceiverName()) {
    84         auto iterator = m_webIDBConnections.find(decoder.destinationID());
    85         if (iterator != m_webIDBConnections.end())
    86             iterator->value->didReceiveMessage(connection, decoder);
    87         return;
    88     }
    89 #endif
    9074
    9175#if ENABLE(SERVICE_WORKER)
    … …  
    137121#endif
    138122
    139 #if ENABLE(INDEXED_DATABASE)
    140     auto idbConnections = m_webIDBConnections;
    141     for (auto& connection : idbConnections.values())
    142         connection->disconnectedFromWebProcess();
    143 
    144     m_webIDBConnections.clear();
    145 #endif
    146 
    147123#if ENABLE(SERVICE_WORKER)
    148124    unregisterSWConnections();
    … …  
    181157#endif
    182158
    183 #if ENABLE(INDEXED_DATABASE)
    184 static uint64_t generateIDBConnectionToServerIdentifier()
    185 {
    186     ASSERT(RunLoop::isMain());
    187     static uint64_t identifier = 0;
    188     return ++identifier;
    189 }
    190 
    191 void StorageToWebProcessConnection::establishIDBConnectionToServer(SessionID sessionID, uint64_t& serverConnectionIdentifier)
    192 {
    193     serverConnectionIdentifier = generateIDBConnectionToServerIdentifier();
    194     LOG(IndexedDB, "StorageToWebProcessConnection::establishIDBConnectionToServer - %" PRIu64, serverConnectionIdentifier);
    195     ASSERT(!m_webIDBConnections.contains(serverConnectionIdentifier));
    196 
    197     m_webIDBConnections.set(serverConnectionIdentifier, WebIDBConnectionToClient::create(*this, serverConnectionIdentifier, sessionID));
    198 }
    199 
    200 void StorageToWebProcessConnection::removeIDBConnectionToServer(uint64_t serverConnectionIdentifier)
    201 {
    202     ASSERT(m_webIDBConnections.contains(serverConnectionIdentifier));
    203 
    204     auto connection = m_webIDBConnections.take(serverConnectionIdentifier);
    205     connection->disconnectedFromWebProcess();
    206 }
    207 #endif
    208 
    209159} // namespace WebKit

  • trunk/Source/WebKit/StorageProcess/StorageToWebProcessConnection.h

    r232824 r235954  
    3535namespace WebKit {
    3636
    37 class WebIDBConnectionToClient;
    3837class WebSWServerConnection;
    3938class WebSWServerToContextConnection;
    … …  
    6160    uint64_t messageSenderDestinationID() override { return 0; }
    6261
    63 #if ENABLE(INDEXED_DATABASE)
    64     // Messages handlers (Modern IDB)
    65     void establishIDBConnectionToServer(PAL::SessionID, uint64_t& serverConnectionIdentifier);
    66     void removeIDBConnectionToServer(uint64_t serverConnectionIdentifier);
    67 
    68     HashMap<uint64_t, RefPtr<WebIDBConnectionToClient>> m_webIDBConnections;
    69 #endif // ENABLE(INDEXED_DATABASE)
    70 
    7162#if ENABLE(SERVICE_WORKER)
    7263    void establishSWServerConnection(PAL::SessionID, WebCore::SWServerConnectionIdentifier&);

  • trunk/Source/WebKit/StorageProcess/StorageToWebProcessConnection.messages.in

    r227907 r235954  
    2222
    2323messages -> StorageToWebProcessConnection LegacyReceiver {
    24 #if ENABLE(INDEXED_DATABASE)
    25     EstablishIDBConnectionToServer(PAL::SessionID sessionID) -> (uint64_t serverConnectionIdentifier)
    26     RemoveIDBConnectionToServer(uint64_t serverConnectionIdentifier)
    27 #endif
    2824#if ENABLE(SERVICE_WORKER)
    2925    EstablishSWServerConnection(PAL::SessionID sessionID) -> (WebCore::SWServerConnectionIdentifier serverConnectionIdentifier)

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

    r235265 r235954  
    326326}
    327327
    328 void NetworkProcessProxy::grantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID, const Vector<String>& paths)
    329 {
    330 #if ENABLE(SANDBOX_EXTENSIONS)
    331     SandboxExtension::HandleArray extensions;
    332     extensions.allocate(paths.size());
    333     for (size_t i = 0; i < paths.size(); ++i) {
    334         // ReadWrite is required for creating hard links as well as deleting the temporary file, which the StorageProcess will do.
    335         SandboxExtension::createHandle(paths[i], SandboxExtension::Type::ReadWrite, extensions[i]);
    336     }
    337 
    338     m_processPool.sendToStorageProcessRelaunchingIfNecessary(Messages::StorageProcess::GrantSandboxExtensionsForBlobs(paths, extensions));
    339 #endif
    340     connection()->send(Messages::NetworkProcess::DidGrantSandboxExtensionsToStorageProcessForBlobs(requestID), 0);
    341 }
    342 
    343328void NetworkProcessProxy::didFinishLaunching(ProcessLauncher* launcher, IPC::Connection::Identifier connectionIdentifier)
    344329{
    … …  
    646631}
    647632
     633#if ENABLE(SANDBOX_EXTENSIONS)
     634void NetworkProcessProxy::getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths)
     635{
     636    SandboxExtension::HandleArray extensions;
     637    extensions.allocate(paths.size());
     638    for (size_t i = 0; i < paths.size(); ++i) {
     639        // ReadWrite is required for creating hard links, which is something that might be done with these extensions.
     640        SandboxExtension::createHandle(paths[i], SandboxExtension::Type::ReadWrite, extensions[i]);
     641    }
     642   
     643    send(Messages::NetworkProcess::DidGetSandboxExtensionsForBlobFiles(requestID, extensions), 0);
     644}
     645#endif
     646
    648647} // namespace WebKit
    649648

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h

    r234941 r235954  
    140140    void didDeleteWebsiteDataForOrigins(uint64_t callbackID);
    141141    void didWriteBlobToFilePath(bool success, uint64_t callbackID);
    142     void grantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID, const Vector<String>& paths);
    143142    void logDiagnosticMessage(uint64_t pageID, const String& message, const String& description, WebCore::ShouldSample);
    144143    void logDiagnosticMessageWithResult(uint64_t pageID, const String& message, const String& description, uint32_t result, WebCore::ShouldSample);
    … …  
    154153#if ENABLE(CONTENT_EXTENSIONS)
    155154    void contentExtensionRules(UserContentControllerIdentifier);
     155#endif
     156
     157#if ENABLE(SANDBOX_EXTENSIONS)
     158    void getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths);
    156159#endif
    157160

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in

    r234941 r235954  
    3434    DidWriteBlobToFilePath(bool success, uint64_t callbackID)
    3535
    36     GrantSandboxExtensionsToStorageProcessForBlobs(uint64_t requestID, Vector<String> paths)
    37 
    3836    ProcessReadyToSuspend()
    3937    SetIsHoldingLockedFiles(bool isHoldingLockedFiles)
    … …  
    5553
    5654    RetrieveCacheStorageParameters(PAL::SessionID sessionID)
     55
     56#if ENABLE(SANDBOX_EXTENSIONS)
     57    GetSandboxExtensionsForBlobFiles(uint64_t requestID, Vector<String> paths)
     58#endif
    5759}

  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp

    r235521 r235954  
    222222}
    223223
    224 #if ENABLE(SANDBOX_EXTENSIONS)
    225 void StorageProcessProxy::getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths)
    226 {
    227     SandboxExtension::HandleArray extensions;
    228     extensions.allocate(paths.size());
    229     for (size_t i = 0; i < paths.size(); ++i) {
    230         // ReadWrite is required for creating hard links, which is something that might be done with these extensions.
    231         SandboxExtension::createHandle(paths[i], SandboxExtension::Type::ReadWrite, extensions[i]);
    232     }
    233 
    234     send(Messages::StorageProcess::DidGetSandboxExtensionsForBlobFiles(requestID, extensions), 0);
    235 }
    236 #endif
    237 
    238224void StorageProcessProxy::didFinishLaunching(ProcessLauncher* launcher, IPC::Connection::Identifier connectionIdentifier)
    239225{

  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h

    r234261 r235954  
    8080    void didDeleteWebsiteData(uint64_t callbackID);
    8181    void didDeleteWebsiteDataForOrigins(uint64_t callbackID);
    82 #if ENABLE(SANDBOX_EXTENSIONS)
    83     void getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths);
    84 #endif
    8582#if ENABLE(SERVICE_WORKER)
    8683    void establishWorkerContextConnectionToStorageProcess(WebCore::SecurityOriginData&&);

  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.messages.in

    r229735 r235954  
    2828    DidDeleteWebsiteDataForOrigins(uint64_t callbackID)
    2929
    30 #if ENABLE(SANDBOX_EXTENSIONS)
    31     GetSandboxExtensionsForBlobFiles(uint64_t requestID, Vector<String> paths)
    32 #endif
    33 
    3430#if ENABLE(SERVICE_WORKER)
    3531    EstablishWorkerContextConnectionToStorageProcess(struct WebCore::SecurityOriginData origin)

  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r235952 r235954  
    525525    parameters.urlSchemesRegisteredAsCanDisplayOnlyIfCanRequest = copyToVector(m_schemesToRegisterAsCanDisplayOnlyIfCanRequest);
    526526
     527#if ENABLE(INDEXED_DATABASE)
     528    // *********
     529    // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
     530    // *********
     531    parameters.indexedDatabaseDirectory = m_configuration->indexedDBDatabaseDirectory();
     532    if (parameters.indexedDatabaseDirectory.isEmpty())
     533        parameters.indexedDatabaseDirectory = API::WebsiteDataStore::defaultDataStore()->websiteDataStore().parameters().indexedDatabaseDirectory;
     534   
     535    SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
     536#endif
     537
    527538    // Add any platform specific parameters
    528539    platformInitializeNetworkProcess(parameters);
    … …  
    585596void WebProcessPool::ensureStorageProcessAndWebsiteDataStore(WebsiteDataStore* relevantDataStore)
    586597{
    587     // *********
    588     // IMPORTANT: Do not change the directory structure for indexed databases on disk without first consulting a reviewer from Apple (<rdar://problem/17454712>)
    589     // *********
    590 
    591598    if (!m_storageProcess) {
    592599        auto parameters = m_websiteDataStore ? m_websiteDataStore->websiteDataStore().storageProcessParameters() : (relevantDataStore ? relevantDataStore->storageProcessParameters() : API::WebsiteDataStore::defaultDataStore()->websiteDataStore().storageProcessParameters());
    … …  
    594601        ASSERT(parameters.sessionID.isValid());
    595602
    596 #if ENABLE(INDEXED_DATABASE)
    597         if (parameters.indexedDatabaseDirectory.isEmpty()) {
    598             parameters.indexedDatabaseDirectory = m_configuration->indexedDBDatabaseDirectory();
    599             SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
    600         }
    601 #endif
    602603#if ENABLE(SERVICE_WORKER)
    603604        if (parameters.serviceWorkerRegistrationDirectory.isEmpty()) {
    … …  
    12121213        page.websiteDataStore().clearPendingCookies();
    12131214
    1214 #if ENABLE(INDEXED_DATABASE)
    1215         if (!page.websiteDataStore().resolvedIndexedDatabaseDirectory().isEmpty())
    1216             ensureStorageProcessAndWebsiteDataStore(&page.websiteDataStore());
     1215#if ENABLE(SERVICE_WORKER)
     1216        ensureStorageProcessAndWebsiteDataStore(&page.websiteDataStore());
    12171217#endif
    12181218    }

  • trunk/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm

    r235127 r235954  
    8686        SandboxExtension::createHandleForReadWriteDirectory(WebCore::FileSystem::directoryName(cookieFile), parameters.cookieStoragePathExtensionHandle);
    8787
     88#if ENABLE(INDEXED_DATABASE)
     89    parameters.indexedDatabaseDirectory = resolvedIndexedDatabaseDirectory();
     90    if (!parameters.indexedDatabaseDirectory.isEmpty())
     91        SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
     92#endif
     93
    8894    return parameters;
    8995}

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp

    r234440 r235954  
    224224    if (dataTypes.contains(WebsiteDataType::DOMCache))
    225225        processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
     226   
     227    if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !isNonPersistentStore)
     228        processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
    226229
    227230    return processAccessType;
    … …  
    511514    }
    512515
    513     if ((dataTypes.contains(WebsiteDataType::IndexedDBDatabases)
    514516#if ENABLE(SERVICE_WORKER)
    515         || dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)
    516 #endif
    517         ) && isPersistent()) {
     517    if (dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && isPersistent()) {
    518518        for (auto& processPool : processPools()) {
    519519            processPool->ensureStorageProcessAndWebsiteDataStore(this);
    … …  
    525525        }
    526526    }
     527#endif
    527528
    528529    if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
    … …  
    657658        processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
    658659
     660    if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !isNonPersistentStore)
     661        processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
     662
    659663    return processAccessType;
    660664}
    … …  
    821825    }
    822826
    823     if ((dataTypes.contains(WebsiteDataType::IndexedDBDatabases)
    824827#if ENABLE(SERVICE_WORKER)
    825         || dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)
    826 #endif
    827         ) && isPersistent()) {
     828    if (dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && isPersistent()) {
    828829        for (auto& processPool : processPools()) {
    829830            processPool->ensureStorageProcessAndWebsiteDataStore(this);
    … …  
    835836        }
    836837    }
     838#endif
    837839
    838840    if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
    … …  
    11221124    }
    11231125
    1124     if ((dataTypes.contains(WebsiteDataType::IndexedDBDatabases)
    11251126#if ENABLE(SERVICE_WORKER)
    1126         || dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)
    1127 #endif
    1128         ) && isPersistent()) {
     1127    if (dataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && isPersistent()) {
    11291128        for (auto& processPool : processPools()) {
    11301129            processPool->ensureStorageProcessAndWebsiteDataStore(this);
    … …  
    11361135        }
    11371136    }
     1137#endif
    11381138
    11391139    if (dataTypes.contains(WebsiteDataType::MediaKeys) && isPersistent()) {
    … …  
    15971597    parameters.sessionID = m_sessionID;
    15981598
     1599#if ENABLE(SERVICE_WORKER)
     1600    parameters.serviceWorkerRegistrationDirectory = resolvedServiceWorkerRegistrationDirectory();
     1601    if (!parameters.serviceWorkerRegistrationDirectory.isEmpty())
     1602        SandboxExtension::createHandleForReadWriteDirectory(parameters.serviceWorkerRegistrationDirectory, parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
     1603#endif
     1604
     1605    return parameters;
     1606}
     1607
     1608Vector<WebCore::Cookie> WebsiteDataStore::pendingCookies() const
     1609{
     1610    return copyToVector(m_pendingCookies);
     1611}
     1612
     1613void WebsiteDataStore::addPendingCookie(const WebCore::Cookie& cookie)
     1614{
     1615    m_pendingCookies.add(cookie);
     1616}
     1617
     1618void WebsiteDataStore::removePendingCookie(const WebCore::Cookie& cookie)
     1619{
     1620    m_pendingCookies.remove(cookie);
     1621}
     1622   
     1623void WebsiteDataStore::clearPendingCookies()
     1624{
     1625    m_pendingCookies.clear();
     1626}
     1627
     1628#if !PLATFORM(COCOA)
     1629WebsiteDataStoreParameters WebsiteDataStore::parameters()
     1630{
     1631    // FIXME: Implement cookies.
     1632    WebsiteDataStoreParameters parameters;
     1633    parameters.networkSessionParameters.sessionID = m_sessionID;
     1634
     1635    resolveDirectoriesIfNecessary();
     1636
    15991637#if ENABLE(INDEXED_DATABASE)
    16001638    parameters.indexedDatabaseDirectory = resolvedIndexedDatabaseDirectory();
    … …  
    16021640        SandboxExtension::createHandleForReadWriteDirectory(parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
    16031641#endif
    1604 #if ENABLE(SERVICE_WORKER)
    1605     parameters.serviceWorkerRegistrationDirectory = resolvedServiceWorkerRegistrationDirectory();
    1606     if (!parameters.serviceWorkerRegistrationDirectory.isEmpty())
    1607         SandboxExtension::createHandleForReadWriteDirectory(parameters.serviceWorkerRegistrationDirectory, parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
    1608 #endif
    1609 
    1610     return parameters;
    1611 }
    1612 
    1613 Vector<WebCore::Cookie> WebsiteDataStore::pendingCookies() const
    1614 {
    1615     return copyToVector(m_pendingCookies);
    1616 }
    1617 
    1618 void WebsiteDataStore::addPendingCookie(const WebCore::Cookie& cookie)
    1619 {
    1620     m_pendingCookies.add(cookie);
    1621 }
    1622 
    1623 void WebsiteDataStore::removePendingCookie(const WebCore::Cookie& cookie)
    1624 {
    1625     m_pendingCookies.remove(cookie);
    1626 }
    1627    
    1628 void WebsiteDataStore::clearPendingCookies()
    1629 {
    1630     m_pendingCookies.clear();
    1631 }
    1632 
    1633 #if !PLATFORM(COCOA)
    1634 WebsiteDataStoreParameters WebsiteDataStore::parameters()
    1635 {
    1636     // FIXME: Implement cookies.
    1637     WebsiteDataStoreParameters parameters;
    1638     parameters.networkSessionParameters.sessionID = m_sessionID;
     1642
    16391643    return parameters;
    16401644}

  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r235951 r235954  
    891891                4A3CC18F19B07B8A00D14AEF /* WKUserMediaPermissionRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 4A410F3619AF7AC3002EBAB5 /* WKUserMediaPermissionRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    892892                4F601432155C5AA2001FBDE0 /* BlockingResponseMap.h in Headers */ = {isa = PBXBuildFile; fileRef = 4F601430155C5A32001FBDE0 /* BlockingResponseMap.h */; };
    893                 5105236F1C739D42007993CB /* WebIDBConnectionToClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5105236D1C7393E9007993CB /* WebIDBConnectionToClient.cpp */; };
    894                 510523701C739D42007993CB /* WebIDBConnectionToClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 5105236E1C7393E9007993CB /* WebIDBConnectionToClient.h */; };
    895893                510523741C73D38B007993CB /* WebIDBConnectionToServerMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 510523731C73D37B007993CB /* WebIDBConnectionToServerMessages.h */; };
    896894                510523751C73D38F007993CB /* WebIDBConnectionToServerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 510523721C73D37B007993CB /* WebIDBConnectionToServerMessageReceiver.cpp */; };
    … …  
    12031201                9321D58A1A38F196008052BE /* WKImmediateActionTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 9321D5891A38F196008052BE /* WKImmediateActionTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
    12041202                9323611E1B015DA800FA9232 /* _WKOverlayScrollbarStyle.h in Headers */ = {isa = PBXBuildFile; fileRef = 9323611D1B015DA800FA9232 /* _WKOverlayScrollbarStyle.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1203                93261161214054F4000806E7 /* WebIDBConnectionToClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 939288DD21404D6C00EBBA33 /* WebIDBConnectionToClient.h */; };
    12051204                933DF82E1B3BC09000AEA9E3 /* WKImagePreviewViewController.h in Headers */ = {isa = PBXBuildFile; fileRef = 933DF82D1B3BC09000AEA9E3 /* WKImagePreviewViewController.h */; };
    12061205                934B724419F5B9BE00AE96D6 /* WKActionMenuItemTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 934B724319F5B9BE00AE96D6 /* WKActionMenuItemTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    37133712                9391F283121B38F500EBF7E8 /* WebFrameNetworkingContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFrameNetworkingContext.h; sourceTree = "<group>"; };
    37143713                9391F284121B38F500EBF7E8 /* WebFrameNetworkingContext.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebFrameNetworkingContext.mm; sourceTree = "<group>"; };
     3714                939288DD21404D6C00EBBA33 /* WebIDBConnectionToClient.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebIDBConnectionToClient.h; sourceTree = "<group>"; };
     3715                939288E121404E1000EBBA33 /* WebIDBConnectionToClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebIDBConnectionToClient.cpp; sourceTree = "<group>"; };
     3716                939288E221404E1000EBBA33 /* WebIDBConnectionToClient.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebIDBConnectionToClient.messages.in; sourceTree = "<group>"; };
    37153717                9395E6891BF2C33200F49BCE /* WKPreviewElementInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKPreviewElementInfo.h; sourceTree = "<group>"; };
    37163718                9395E68B1BF2C35200F49BCE /* WKPreviewElementInfo.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKPreviewElementInfo.mm; sourceTree = "<group>"; };
    … …  
    63416343                                BC82837C16B45DA500A278FE /* EntryPoint */,
    63426344                                E1798C7616E6815500240139 /* FileAPI */,
     6345                                939288E021404DF000EBBA33 /* IndexedDB */,
    63436346                                2DA944BB188511DD00ED86DB /* ios */,
    63446347                                510CC7DC16138E2900D03ED3 /* mac */,
    … …  
    69086911                        );
    69096912                        path = cocoa;
     6913                        sourceTree = "<group>";
     6914                };
     6915                939288E021404DF000EBBA33 /* IndexedDB */ = {
     6916                        isa = PBXGroup;
     6917                        children = (
     6918                                939288E121404E1000EBBA33 /* WebIDBConnectionToClient.cpp */,
     6919                                939288DD21404D6C00EBBA33 /* WebIDBConnectionToClient.h */,
     6920                                939288E221404E1000EBBA33 /* WebIDBConnectionToClient.messages.in */,
     6921                        );
     6922                        path = IndexedDB;
    69106923                        sourceTree = "<group>";
    69116924                };
    … …  
    93239336                                93A88B331BC6E9CD00ABA5C2 /* WebHitTestResultData.h in Headers */,
    93249337                                F44DFEB21E9E752F0038D196 /* WebIconUtilities.h in Headers */,
    9325                                 510523701C739D42007993CB /* WebIDBConnectionToClient.h in Headers */,
     9338                                93261161214054F4000806E7 /* WebIDBConnectionToClient.h in Headers */,
    93269339                                5105237A1C73DA77007993CB /* WebIDBConnectionToClientMessages.h in Headers */,
    93279340                                514129941C6428BB0059E714 /* WebIDBConnectionToServer.h in Headers */,
    … …  
    1094010953                                BC0E606112D6BA910012A72A /* WebGeolocationManagerMessageReceiver.cpp in Sources */,
    1094110954                                BC0E618212D6CB1D0012A72A /* WebGeolocationManagerProxyMessageReceiver.cpp in Sources */,
    10942                                 5105236F1C739D42007993CB /* WebIDBConnectionToClient.cpp in Sources */,
    1094310955                                510523791C73DA77007993CB /* WebIDBConnectionToClientMessageReceiver.cpp in Sources */,
    1094410956                                510523751C73D38F007993CB /* WebIDBConnectionToServerMessageReceiver.cpp in Sources */,

  • trunk/Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp

    r235205 r235954  
    3232#include "NetworkConnectionToWebProcessMessages.h"
    3333#include "NetworkProcessConnection.h"
    34 #include "StorageToWebProcessConnectionMessages.h"
    3534#include "WebCoreArgumentCoders.h"
    3635#include "WebIDBConnectionToClientMessages.h"
    3736#include "WebIDBResult.h"
    3837#include "WebProcess.h"
    39 #include "WebToStorageProcessConnection.h"
    4038#include <WebCore/IDBConnectionToServer.h>
    4139#include <WebCore/IDBCursorInfo.h>
    … …  
    6563    relaxAdoptionRequirement();
    6664
    67     m_isOpenInServer = sendSync(Messages::StorageToWebProcessConnection::EstablishIDBConnectionToServer(sessionID), Messages::StorageToWebProcessConnection::EstablishIDBConnectionToServer::Reply(m_identifier));
     65    m_isOpenInServer = sendSync(Messages::NetworkConnectionToWebProcess::EstablishIDBConnectionToServer(sessionID), Messages::NetworkConnectionToWebProcess::EstablishIDBConnectionToServer::Reply(m_identifier));
    6866
    6967    // FIXME: This creates a reference cycle, so neither this object nor the IDBConnectionToServer will ever be deallocated.
    … …  
    7472{
    7573    if (m_isOpenInServer)
    76         send(Messages::StorageToWebProcessConnection::RemoveIDBConnectionToServer(m_identifier));
     74        send(Messages::NetworkConnectionToWebProcess::RemoveIDBConnectionToServer(m_identifier));
    7775}
    7876
    7977IPC::Connection* WebIDBConnectionToServer::messageSenderConnection()
    8078{
    81     return &WebProcess::singleton().ensureWebToStorageProcessConnection(m_sessionID).connection();
     79    return &WebProcess::singleton().ensureNetworkProcessConnection().connection();
    8280}
    8381

  • trunk/Source/WebKit/WebProcess/Databases/WebDatabaseProvider.cpp

    r235205 r235954  
    2727#include "WebDatabaseProvider.h"
    2828
     29#include "NetworkProcessConnection.h"
    2930#include "WebProcess.h"
    30 #include "WebToStorageProcessConnection.h"
    3131#include <pal/SessionID.h>
    3232#include <wtf/HashMap.h>
    … …  
    6868
    6969#if ENABLE(INDEXED_DATABASE)
    70 
    7170WebCore::IDBClient::IDBConnectionToServer& WebDatabaseProvider::idbConnectionToServerForSession(const PAL::SessionID& sessionID)
    7271{
    … …  
    7978    }
    8079
    81     return WebProcess::singleton().ensureWebToStorageProcessConnection(sessionID).idbConnectionToServerForSession(sessionID).coreConnectionToServer();
     80    return WebProcess::singleton().ensureNetworkProcessConnection().idbConnectionToServerForSession(sessionID).coreConnectionToServer();
    8281}
    83 
    8482#endif
    8583

  • trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp

    r235205 r235954  
    3434#include "WebCacheStorageProvider.h"
    3535#include "WebCoreArgumentCoders.h"
     36#include "WebIDBConnectionToServerMessages.h"
    3637#include "WebLoaderStrategy.h"
    3738#include "WebMDNSRegisterMessages.h"
    … …  
    108109    }
    109110
     111#if ENABLE(INDEXED_DATABASE)
     112    if (decoder.messageReceiverName() == Messages::WebIDBConnectionToServer::messageReceiverName()) {
     113        auto idbConnection = m_webIDBConnectionsByIdentifier.get(decoder.destinationID());
     114        if (idbConnection)
     115            idbConnection->didReceiveMessage(connection, decoder);
     116        return;
     117    }
     118#endif
     119
    110120    didReceiveNetworkProcessConnectionMessage(connection, decoder);
    111121}
    … …  
    127137
    128138    m_writeBlobToFileCompletionHandlers.clear();
     139
     140
     141#if ENABLE(INDEXED_DATABASE)
     142    for (auto& connection : m_webIDBConnectionsByIdentifier.values())
     143        connection->connectionToServerLost();
     144   
     145    m_webIDBConnectionsByIdentifier.clear();
     146    m_webIDBConnectionsBySession.clear();
     147#endif
     148
    129149}
    130150
    … …  
    182202#endif
    183203
     204#if ENABLE(INDEXED_DATABASE)
     205WebIDBConnectionToServer& NetworkProcessConnection::idbConnectionToServerForSession(PAL::SessionID sessionID)
     206{
     207    return *m_webIDBConnectionsBySession.ensure(sessionID, [&] {
     208        auto connection = WebIDBConnectionToServer::create(sessionID);
     209       
     210        auto result = m_webIDBConnectionsByIdentifier.add(connection->identifier(), connection.copyRef());
     211        ASSERT_UNUSED(result, result.isNewEntry);
     212       
     213        return connection;
     214    }).iterator->value;
     215}
     216#endif
    184217} // namespace WebKit

  • trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.h

    r230007 r235954  
    2929#include "Connection.h"
    3030#include "ShareableResource.h"
     31#include "WebIDBConnectionToServer.h"
    3132#include <wtf/RefCounted.h>
    3233#include <wtf/text/WTFString.h>
    … …  
    6465    void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, Function<void (const Vector<String>& filePaths)>&& completionHandler);
    6566
     67#if ENABLE(INDEXED_DATABASE)
     68    WebIDBConnectionToServer* existingIDBConnectionToServerForIdentifier(uint64_t identifier) { return m_webIDBConnectionsByIdentifier.get(identifier); };
     69    WebIDBConnectionToServer& idbConnectionToServerForSession(PAL::SessionID);
     70#endif
     71
    6672private:
    6773    NetworkProcessConnection(IPC::Connection::Identifier);
    … …  
    8793
    8894    HashMap<uint64_t, Function<void (const Vector<String>&)>> m_writeBlobToFileCompletionHandlers;
     95
     96#if ENABLE(INDEXED_DATABASE)
     97    HashMap<PAL::SessionID, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsBySession;
     98    HashMap<uint64_t, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsByIdentifier;
     99#endif
     100
    89101};
    90102

  • trunk/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.cpp

    r235205 r235954  
    3030#include "ServiceWorkerClientFetchMessages.h"
    3131#include "StorageToWebProcessConnectionMessages.h"
    32 #include "WebIDBConnectionToServerMessages.h"
    3332#include "WebProcess.h"
    3433#include "WebSWClientConnection.h"
    … …  
    5655void WebToStorageProcessConnection::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
    5756{
    58 #if ENABLE(INDEXED_DATABASE)
    59     if (decoder.messageReceiverName() == Messages::WebIDBConnectionToServer::messageReceiverName()) {
    60         auto idbConnection = m_webIDBConnectionsByIdentifier.get(decoder.destinationID());
    61         if (idbConnection)
    62             idbConnection->didReceiveMessage(connection, decoder);
    63         return;
    64     }
    65 #endif
    66 
    6757#if ENABLE(SERVICE_WORKER)
    6858    if (decoder.messageReceiverName() == Messages::WebSWClientConnection::messageReceiverName()) {
    … …  
    10393    auto protectedThis = makeRef(*this);
    10494
    105 #if ENABLE(INDEXED_DATABASE)
    106     for (auto& connection : m_webIDBConnectionsByIdentifier.values())
    107         connection->connectionToServerLost();
    108 #endif
    10995#if ENABLE(SERVICE_WORKER)
    11096    for (auto& connection : m_swConnectionsBySession.values())
    … …  
    116102
    117103    WebProcess::singleton().webToStorageProcessConnectionClosed(this);
    118 
    119 #if ENABLE(INDEXED_DATABASE)
    120     m_webIDBConnectionsByIdentifier.clear();
    121     m_webIDBConnectionsBySession.clear();
    122 #endif
    123104}
    124105
    … …  
    126107{
    127108}
    128 
    129 #if ENABLE(INDEXED_DATABASE)
    130 WebIDBConnectionToServer& WebToStorageProcessConnection::idbConnectionToServerForSession(SessionID sessionID)
    131 {
    132     return *m_webIDBConnectionsBySession.ensure(sessionID, [&] {
    133         auto connection = WebIDBConnectionToServer::create(sessionID);
    134 
    135         auto result = m_webIDBConnectionsByIdentifier.add(connection->identifier(), connection.copyRef());
    136         ASSERT_UNUSED(result, result.isNewEntry);
    137 
    138         return connection;
    139     }).iterator->value;
    140 }
    141 #endif
    142109
    143110#if ENABLE(SERVICE_WORKER)

  • trunk/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.h

    r233562 r235954  
    2929#include "Connection.h"
    3030#include "MessageSender.h"
    31 #include "WebIDBConnectionToServer.h"
    3231#include "WebSWClientConnection.h"
    3332#include <WebCore/SWServer.h>
    … …  
    5150    IPC::Connection& connection() { return m_connection.get(); }
    5251
    53 #if ENABLE(INDEXED_DATABASE)
    54     WebIDBConnectionToServer* existingIDBConnectionToServerForIdentifier(uint64_t identifier) { return m_webIDBConnectionsByIdentifier.get(identifier); };
    55     WebIDBConnectionToServer& idbConnectionToServerForSession(PAL::SessionID);
    56 #endif
    5752#if ENABLE(SERVICE_WORKER)
    5853    WebSWClientConnection* existingServiceWorkerConnectionForSession(PAL::SessionID sessionID) { return m_swConnectionsBySession.get(sessionID); }
    … …  
    7570    Ref<IPC::Connection> m_connection;
    7671
    77 #if ENABLE(INDEXED_DATABASE)
    78     HashMap<PAL::SessionID, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsBySession;
    79     HashMap<uint64_t, RefPtr<WebIDBConnectionToServer>> m_webIDBConnectionsByIdentifier;
    80 #endif
    81 
    8272#if ENABLE(SERVICE_WORKER)
    8373    HashMap<PAL::SessionID, RefPtr<WebSWClientConnection>> m_swConnectionsBySession;

  • trunk/Source/WebKit/WebProcess/WebProcess.cpp

    r235758 r235954  
    11811181    ASSERT_UNUSED(connection, m_networkProcessConnection == connection);
    11821182
    1183     m_networkProcessConnection = nullptr;
    1184 
    1185     logDiagnosticMessageForNetworkProcessCrash();
    1186 
    1187     m_webLoaderStrategy.networkProcessCrashed();
    1188     WebSocketStream::networkProcessCrashed();
    1189 
    1190     for (auto& page : m_pageMap.values())
    1191         page->stopAllURLSchemeTasks();
    1192 }
    1193 
    1194 WebLoaderStrategy& WebProcess::webLoaderStrategy()
    1195 {
    1196     return m_webLoaderStrategy;
    1197 }
    1198 
    1199 void WebProcess::webToStorageProcessConnectionClosed(WebToStorageProcessConnection* connection)
    1200 {
    1201     ASSERT(m_webToStorageProcessConnection);
    1202     ASSERT(m_webToStorageProcessConnection == connection);
    1203 
    12041183#if ENABLE(INDEXED_DATABASE)
    12051184    for (auto& page : m_pageMap.values()) {
    … …  
    12071186        if (!idbConnection)
    12081187            continue;
    1209 
     1188       
    12101189        if (connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())) {
    12111190            ASSERT(idbConnection == &connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())->coreConnectionToServer());
    … …  
    12141193    }
    12151194#endif
     1195
     1196    m_networkProcessConnection = nullptr;
     1197
     1198    logDiagnosticMessageForNetworkProcessCrash();
     1199
     1200    m_webLoaderStrategy.networkProcessCrashed();
     1201    WebSocketStream::networkProcessCrashed();
     1202
     1203    for (auto& page : m_pageMap.values())
     1204        page->stopAllURLSchemeTasks();
     1205}
     1206
     1207WebLoaderStrategy& WebProcess::webLoaderStrategy()
     1208{
     1209    return m_webLoaderStrategy;
     1210}
     1211
     1212void WebProcess::webToStorageProcessConnectionClosed(WebToStorageProcessConnection* connection)
     1213{
     1214    ASSERT(m_webToStorageProcessConnection);
     1215    ASSERT(m_webToStorageProcessConnection == connection);
     1216
    12161217#if ENABLE(SERVICE_WORKER)
    12171218    if (SWContextManager::singleton().connection()) {

  • trunk/Tools/ChangeLog

    r235952 r235954  
     12018-09-12  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Move IndexedDB to Network Process
     4        https://bugs.webkit.org/show_bug.cgi?id=189415
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        * TestWebKitAPI/Tests/WebKitCocoa/IDBDeleteRecovery.mm:
     9        (TEST):
     10        * TestWebKitAPI/Tests/WebKitCocoa/IDBIndexUpgradeToV2.mm:
     11        (TEST):
     12        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBDatabaseProcessKill.mm:
     13        (TEST):
     14        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBMultiProcess.mm:
     15        (TEST):
     16        * TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm:
     17        (TEST):
     18
    1192018-09-12  Chris Dumez  <cdumez@apple.com>
    220

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBDeleteRecovery.mm

    r220105 r235954  
    6060    [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
    6161
    62     [configuration.get().processPool _terminateStorageProcess];
     62    [configuration.get().processPool _terminateNetworkProcess];
    6363
    6464    // Copy the inconsistent database files to the database directory

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IDBIndexUpgradeToV2.mm

    r220105 r235954  
    6060    [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
    6161
    62     [configuration.get().processPool _terminateStorageProcess];
     62    [configuration.get().processPool _terminateNetworkProcess];
    6363
    6464    // Copy the inconsistent database files to the database directory

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBDatabaseProcessKill.mm

    r220105 r235954  
    9595        if (!killedDBProcess && openRequestUpgradeNeeded) {
    9696            killedDBProcess = true;
    97             [configuration.get().processPool _terminateStorageProcess];
     97            [configuration.get().processPool _terminateNetworkProcess];
    9898        }
    9999    }

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBMultiProcess.mm

    r220105 r235954  
    7272    [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
    7373
    74     [configuration.get().processPool _terminateStorageProcess];
     74    [configuration.get().processPool _terminateNetworkProcess];
    7575
    7676    RetainPtr<WKWebView> webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/IndexedDBPersistence.mm

    r232258 r235954  
    7777    webView = nil;
    7878
    79     // Terminate the storage process
    80     [configuration.get().processPool _terminateStorageProcess];
     79    // Terminate the network process
     80    [configuration.get().processPool _terminateNetworkProcess];
    8181
    8282    // Make a new web view to finish the test
Note: See TracChangeset for help on using the changeset viewer.