Changeset 233562 in webkit


Ignore:
Timestamp:
Jul 5, 2018 10:48:35 PM (6 years ago)
Author:
beidson@apple.com
Message:

IndexedDB operations in a Page fail after a StorageProcess crash.
<rdar://problem/41626526> and https://bugs.webkit.org/show_bug.cgi?id=187123

Reviewed by Alex Christensen.

Source/WebCore:

Test: storage/indexeddb/modern/opendatabase-after-storage-crash.html

When the connection to a StorageProcess goes away, explicitly tell all of the WebPages
in the WebProcess about it.

This puts Documents/Workers in an error mode where requests fail instead of timeout.
It also clears the Page's connection so *new* Documents and Workers will get a fresh
new connection that works.

  • Modules/indexeddb/client/IDBConnectionToServer.cpp:

(WebCore::IDBClient::IDBConnectionToServer::callResultFunctionLater):
(WebCore::IDBClient::IDBConnectionToServer::deleteDatabase):
(WebCore::IDBClient::IDBConnectionToServer::openDatabase):
(WebCore::IDBClient::IDBConnectionToServer::createObjectStore):
(WebCore::IDBClient::IDBConnectionToServer::deleteObjectStore):
(WebCore::IDBClient::IDBConnectionToServer::renameObjectStore):
(WebCore::IDBClient::IDBConnectionToServer::clearObjectStore):
(WebCore::IDBClient::IDBConnectionToServer::createIndex):
(WebCore::IDBClient::IDBConnectionToServer::deleteIndex):
(WebCore::IDBClient::IDBConnectionToServer::renameIndex):
(WebCore::IDBClient::IDBConnectionToServer::putOrAdd):
(WebCore::IDBClient::IDBConnectionToServer::getRecord):
(WebCore::IDBClient::IDBConnectionToServer::getAllRecords):
(WebCore::IDBClient::IDBConnectionToServer::getCount):
(WebCore::IDBClient::IDBConnectionToServer::deleteRecord):
(WebCore::IDBClient::IDBConnectionToServer::openCursor):
(WebCore::IDBClient::IDBConnectionToServer::iterateCursor):
(WebCore::IDBClient::IDBConnectionToServer::establishTransaction):
(WebCore::IDBClient::IDBConnectionToServer::commitTransaction):
(WebCore::IDBClient::IDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
(WebCore::IDBClient::IDBConnectionToServer::abortTransaction):
(WebCore::IDBClient::IDBConnectionToServer::didFireVersionChangeEvent):
(WebCore::IDBClient::IDBConnectionToServer::confirmDidCloseFromServer):
(WebCore::IDBClient::IDBConnectionToServer::connectionToServerLost):
(WebCore::IDBClient::IDBConnectionToServer::openDBRequestCancelled):
(WebCore::IDBClient::IDBConnectionToServer::databaseConnectionPendingClose):
(WebCore::IDBClient::IDBConnectionToServer::databaseConnectionClosed):
(WebCore::IDBClient::IDBConnectionToServer::abortOpenAndUpgradeNeeded):
(WebCore::IDBClient::IDBConnectionToServer::getAllDatabaseNames):

  • Modules/indexeddb/client/IDBConnectionToServer.h:
  • Modules/indexeddb/shared/IDBError.h:

(WebCore::IDBError::serverConnectionLostError):

  • page/Page.cpp:

(WebCore::Page::setSessionID):
(WebCore::Page::idbConnection):
(WebCore::Page::optionalIDBConnection):
(WebCore::Page::clearIDBConnection):

  • page/Page.h:

Source/WebKit:

When the connection to a StorageProcess goes away, explicitly tell all of the WebPages
in the WebProcess about it.

This puts Documents/Workers in an error mode where requests fail instead of timeout.
It also clears the Page's connection so *new* Documents and Workers will get a fresh
new connection that works.

  • UIProcess/API/C/WKContext.cpp:

(WKContextTerminateStorageProcess):

  • UIProcess/API/Cocoa/WKProcessPool.mm:

(-[WKProcessPool _terminateStorageProcess]):

  • UIProcess/Storage/StorageProcessProxy.cpp:

(WebKit::StorageProcessProxy::terminateForTesting):

  • UIProcess/Storage/StorageProcessProxy.h:
  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::terminateStorageProcessForTesting):
(WebKit::WebProcessPool::terminateStorageProcess): Deleted.

  • UIProcess/WebProcessPool.h:
  • WebProcess/Storage/WebToStorageProcessConnection.cpp:

(WebKit::WebToStorageProcessConnection::didClose):

  • WebProcess/Storage/WebToStorageProcessConnection.h:

(WebKit::WebToStorageProcessConnection::existingIDBConnectionToServerForIdentifier):

  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::webToStorageProcessConnectionClosed):

LayoutTests:

  • storage/indexeddb/modern/opendatabase-after-storage-crash.html: Added.
Location:
trunk
Files:
2 added
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r233560 r233562  
     12018-07-05  Brady Eidson  <beidson@apple.com>
     2
     3        IndexedDB operations in a Page fail after a StorageProcess crash.
     4        <rdar://problem/41626526> and https://bugs.webkit.org/show_bug.cgi?id=187123
     5
     6        Reviewed by Alex Christensen.
     7
     8        * storage/indexeddb/modern/opendatabase-after-storage-crash.html: Added.
     9
    1102018-07-05  Ryosuke Niwa  <rniwa@webkit.org>
    211
  • trunk/LayoutTests/TestExpectations

    r233500 r233562  
    119119http/tests/navigation/process-swap-window-open.html [ Skip ]
    120120http/tests/navigation/useragent-reload.php [ Skip ]
     121storage/indexeddb/modern/opendatabase-after-storage-crash.html [ Skip ]
    121122
    122123# Only Mac and iOS have an implementation of UIScriptController::doAsyncTask().
  • trunk/LayoutTests/platform/wk2/TestExpectations

    r233414 r233562  
    737737
    738738http/tests/navigation/useragent-reload.php [ Pass ]
     739storage/indexeddb/modern/opendatabase-after-storage-crash.html [ Pass ]
     740
    739741
    740742### END OF (5) Progressions, expected successes that are expected failures in WebKit1.
  • trunk/Source/WebCore/ChangeLog

    r233560 r233562  
     12018-07-05  Brady Eidson  <beidson@apple.com>
     2
     3        IndexedDB operations in a Page fail after a StorageProcess crash.
     4        <rdar://problem/41626526> and https://bugs.webkit.org/show_bug.cgi?id=187123
     5
     6        Reviewed by Alex Christensen.
     7
     8        Test: storage/indexeddb/modern/opendatabase-after-storage-crash.html
     9
     10        When the connection to a StorageProcess goes away, explicitly tell all of the WebPages
     11        in the WebProcess about it.
     12       
     13        This puts Documents/Workers in an error mode where requests fail instead of timeout.
     14        It also clears the Page's connection so *new* Documents and Workers will get a fresh
     15        new connection that works.
     16       
     17        * Modules/indexeddb/client/IDBConnectionToServer.cpp:
     18        (WebCore::IDBClient::IDBConnectionToServer::callResultFunctionLater):
     19        (WebCore::IDBClient::IDBConnectionToServer::deleteDatabase):
     20        (WebCore::IDBClient::IDBConnectionToServer::openDatabase):
     21        (WebCore::IDBClient::IDBConnectionToServer::createObjectStore):
     22        (WebCore::IDBClient::IDBConnectionToServer::deleteObjectStore):
     23        (WebCore::IDBClient::IDBConnectionToServer::renameObjectStore):
     24        (WebCore::IDBClient::IDBConnectionToServer::clearObjectStore):
     25        (WebCore::IDBClient::IDBConnectionToServer::createIndex):
     26        (WebCore::IDBClient::IDBConnectionToServer::deleteIndex):
     27        (WebCore::IDBClient::IDBConnectionToServer::renameIndex):
     28        (WebCore::IDBClient::IDBConnectionToServer::putOrAdd):
     29        (WebCore::IDBClient::IDBConnectionToServer::getRecord):
     30        (WebCore::IDBClient::IDBConnectionToServer::getAllRecords):
     31        (WebCore::IDBClient::IDBConnectionToServer::getCount):
     32        (WebCore::IDBClient::IDBConnectionToServer::deleteRecord):
     33        (WebCore::IDBClient::IDBConnectionToServer::openCursor):
     34        (WebCore::IDBClient::IDBConnectionToServer::iterateCursor):
     35        (WebCore::IDBClient::IDBConnectionToServer::establishTransaction):
     36        (WebCore::IDBClient::IDBConnectionToServer::commitTransaction):
     37        (WebCore::IDBClient::IDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
     38        (WebCore::IDBClient::IDBConnectionToServer::abortTransaction):
     39        (WebCore::IDBClient::IDBConnectionToServer::didFireVersionChangeEvent):
     40        (WebCore::IDBClient::IDBConnectionToServer::confirmDidCloseFromServer):
     41        (WebCore::IDBClient::IDBConnectionToServer::connectionToServerLost):
     42        (WebCore::IDBClient::IDBConnectionToServer::openDBRequestCancelled):
     43        (WebCore::IDBClient::IDBConnectionToServer::databaseConnectionPendingClose):
     44        (WebCore::IDBClient::IDBConnectionToServer::databaseConnectionClosed):
     45        (WebCore::IDBClient::IDBConnectionToServer::abortOpenAndUpgradeNeeded):
     46        (WebCore::IDBClient::IDBConnectionToServer::getAllDatabaseNames):
     47        * Modules/indexeddb/client/IDBConnectionToServer.h:
     48
     49        * Modules/indexeddb/shared/IDBError.h:
     50        (WebCore::IDBError::serverConnectionLostError):
     51
     52        * page/Page.cpp:
     53        (WebCore::Page::setSessionID):
     54        (WebCore::Page::idbConnection):
     55        (WebCore::Page::optionalIDBConnection):
     56        (WebCore::Page::clearIDBConnection):
     57        * page/Page.h:
     58
    1592018-07-05  Ryosuke Niwa  <rniwa@webkit.org>
    260
  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp

    r229979 r233562  
    6565}
    6666
     67void IDBConnectionToServer::callResultFunctionWithErrorLater(ResultFunction function, const IDBResourceIdentifier& requestIdentifier)
     68{
     69    callOnMainThread([this, protectedThis = makeRef(*this), function, requestIdentifier]() {
     70        (this->*function)(IDBResultData::error(requestIdentifier, IDBError::serverConnectionLostError()));
     71    });
     72}
     73
    6774void IDBConnectionToServer::deleteDatabase(const IDBRequestData& request)
    6875{
    6976    LOG(IndexedDB, "IDBConnectionToServer::deleteDatabase - %s", request.databaseIdentifier().debugString().utf8().data());
    70     m_delegate->deleteDatabase(request);
     77   
     78    if (m_serverConnectionIsValid)
     79        m_delegate->deleteDatabase(request);
     80    else
     81        callResultFunctionWithErrorLater(&IDBConnectionToServer::didDeleteDatabase, request.requestIdentifier());
    7182}
    7283
     
    8091{
    8192    LOG(IndexedDB, "IDBConnectionToServer::openDatabase - %s (%s) (%" PRIu64 ")", request.databaseIdentifier().debugString().utf8().data(), request.requestIdentifier().loggingString().utf8().data(), request.requestedVersion());
    82     m_delegate->openDatabase(request);
     93
     94    if (m_serverConnectionIsValid)
     95        m_delegate->openDatabase(request);
     96    else
     97        callResultFunctionWithErrorLater(&IDBConnectionToServer::didOpenDatabase, request.requestIdentifier());
    8398}
    8499
     
    94109    ASSERT(isMainThread());
    95110
    96     m_delegate->createObjectStore(requestData, info);
     111    if (m_serverConnectionIsValid)
     112        m_delegate->createObjectStore(requestData, info);
     113    else
     114        callResultFunctionWithErrorLater(&IDBConnectionToServer::didCreateObjectStore, requestData.requestIdentifier());
    97115}
    98116
     
    108126    ASSERT(isMainThread());
    109127
    110     m_delegate->deleteObjectStore(requestData, objectStoreName);
     128    if (m_serverConnectionIsValid)
     129        m_delegate->deleteObjectStore(requestData, objectStoreName);
     130    else
     131        callResultFunctionWithErrorLater(&IDBConnectionToServer::didDeleteObjectStore, requestData.requestIdentifier());
    111132}
    112133
     
    122143    ASSERT(isMainThread());
    123144
    124     m_delegate->renameObjectStore(requestData, objectStoreIdentifier, newName);
     145    if (m_serverConnectionIsValid)
     146        m_delegate->renameObjectStore(requestData, objectStoreIdentifier, newName);
     147    else
     148        callResultFunctionWithErrorLater(&IDBConnectionToServer::didRenameObjectStore, requestData.requestIdentifier());
    125149}
    126150
     
    136160    ASSERT(isMainThread());
    137161
    138     m_delegate->clearObjectStore(requestData, objectStoreIdentifier);
     162    if (m_serverConnectionIsValid)
     163        m_delegate->clearObjectStore(requestData, objectStoreIdentifier);
     164    else
     165        callResultFunctionWithErrorLater(&IDBConnectionToServer::didClearObjectStore, requestData.requestIdentifier());
    139166}
    140167
     
    150177    ASSERT(isMainThread());
    151178
    152     m_delegate->createIndex(requestData, info);
     179    if (m_serverConnectionIsValid)
     180        m_delegate->createIndex(requestData, info);
     181    else
     182        callResultFunctionWithErrorLater(&IDBConnectionToServer::didCreateIndex, requestData.requestIdentifier());
    153183}
    154184
     
    164194    ASSERT(isMainThread());
    165195
    166     m_delegate->deleteIndex(requestData, objectStoreIdentifier, indexName);
     196    if (m_serverConnectionIsValid)
     197        m_delegate->deleteIndex(requestData, objectStoreIdentifier, indexName);
     198    else
     199        callResultFunctionWithErrorLater(&IDBConnectionToServer::didDeleteIndex, requestData.requestIdentifier());
    167200}
    168201
     
    178211    ASSERT(isMainThread());
    179212
    180     m_delegate->renameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName);
     213    if (m_serverConnectionIsValid)
     214        m_delegate->renameIndex(requestData, objectStoreIdentifier, indexIdentifier, newName);
     215    else
     216        callResultFunctionWithErrorLater(&IDBConnectionToServer::didRenameIndex, requestData.requestIdentifier());
    181217}
    182218
     
    192228    ASSERT(isMainThread());
    193229
    194     m_delegate->putOrAdd(requestData, key, value, overwriteMode);
     230    if (m_serverConnectionIsValid)
     231        m_delegate->putOrAdd(requestData, key, value, overwriteMode);
     232    else
     233        callResultFunctionWithErrorLater(&IDBConnectionToServer::didPutOrAdd, requestData.requestIdentifier());
    195234}
    196235
     
    207246    ASSERT(!getRecordData.keyRangeData.isNull);
    208247
    209     m_delegate->getRecord(requestData, getRecordData);
     248    if (m_serverConnectionIsValid)
     249        m_delegate->getRecord(requestData, getRecordData);
     250    else
     251        callResultFunctionWithErrorLater(&IDBConnectionToServer::didGetRecord, requestData.requestIdentifier());
    210252}
    211253
     
    221263    ASSERT(isMainThread());
    222264
    223     m_delegate->getAllRecords(requestData, getAllRecordsData);
     265    if (m_serverConnectionIsValid)
     266        m_delegate->getAllRecords(requestData, getAllRecordsData);
     267    else
     268        callResultFunctionWithErrorLater(&IDBConnectionToServer::didGetAllRecords, requestData.requestIdentifier());
    224269}
    225270
     
    236281    ASSERT(!keyRangeData.isNull);
    237282
    238     m_delegate->getCount(requestData, keyRangeData);
     283    if (m_serverConnectionIsValid)
     284        m_delegate->getCount(requestData, keyRangeData);
     285    else
     286        callResultFunctionWithErrorLater(&IDBConnectionToServer::didGetCount, requestData.requestIdentifier());
    239287}
    240288
     
    251299    ASSERT(!keyRangeData.isNull);
    252300
    253     m_delegate->deleteRecord(requestData, keyRangeData);
     301    if (m_serverConnectionIsValid)
     302        m_delegate->deleteRecord(requestData, keyRangeData);
     303    else
     304        callResultFunctionWithErrorLater(&IDBConnectionToServer::didDeleteRecord, requestData.requestIdentifier());
    254305}
    255306
     
    265316    ASSERT(isMainThread());
    266317
    267     m_delegate->openCursor(requestData, info);
     318    if (m_serverConnectionIsValid)
     319        m_delegate->openCursor(requestData, info);
     320    else
     321        callResultFunctionWithErrorLater(&IDBConnectionToServer::didOpenCursor, requestData.requestIdentifier());
    268322}
    269323
     
    279333    ASSERT(isMainThread());
    280334
    281     m_delegate->iterateCursor(requestData, data);
     335    if (m_serverConnectionIsValid)
     336        m_delegate->iterateCursor(requestData, data);
     337    else
     338        callResultFunctionWithErrorLater(&IDBConnectionToServer::didIterateCursor, requestData.requestIdentifier());
    282339}
    283340
     
    293350    ASSERT(isMainThread());
    294351
    295     m_delegate->establishTransaction(databaseConnectionIdentifier, info);
     352    if (m_serverConnectionIsValid)
     353        m_delegate->establishTransaction(databaseConnectionIdentifier, info);
    296354}
    297355
     
    301359    ASSERT(isMainThread());
    302360
    303     m_delegate->commitTransaction(transactionIdentifier);
     361    if (m_serverConnectionIsValid)
     362        m_delegate->commitTransaction(transactionIdentifier);
     363    else {
     364        callOnMainThread([this, protectedThis = makeRef(*this), transactionIdentifier] {
     365            didCommitTransaction(transactionIdentifier, IDBError::serverConnectionLostError());
     366        });
     367    }
    304368}
    305369
     
    317381    ASSERT(isMainThread());
    318382
    319     m_delegate->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
     383    if (m_serverConnectionIsValid)
     384        m_delegate->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
    320385}
    321386
     
    325390    ASSERT(isMainThread());
    326391
    327     m_delegate->abortTransaction(transactionIdentifier);
     392    if (m_serverConnectionIsValid)
     393        m_delegate->abortTransaction(transactionIdentifier);
     394    else {
     395        callOnMainThread([this, protectedThis = makeRef(*this), transactionIdentifier] {
     396            didAbortTransaction(transactionIdentifier, IDBError::serverConnectionLostError());
     397        });
     398    }
    328399}
    329400
     
    349420    ASSERT(isMainThread());
    350421
    351     m_delegate->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
     422    if (m_serverConnectionIsValid)
     423        m_delegate->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
    352424}
    353425
     
    373445    ASSERT(isMainThread());
    374446
    375     m_delegate->confirmDidCloseFromServer(databaseConnectionIdentifier);
     447    if (m_serverConnectionIsValid)
     448        m_delegate->confirmDidCloseFromServer(databaseConnectionIdentifier);
    376449}
    377450
     
    380453    LOG(IndexedDB, "IDBConnectionToServer::connectionToServerLost");
    381454    ASSERT(isMainThread());
    382 
     455    ASSERT(m_serverConnectionIsValid);
     456   
     457    m_serverConnectionIsValid = false;
    383458    m_proxy->connectionToServerLost(error);
    384459}
     
    397472    ASSERT(isMainThread());
    398473
    399     m_delegate->openDBRequestCancelled(requestData);
     474    if (m_serverConnectionIsValid)
     475        m_delegate->openDBRequestCancelled(requestData);
    400476}
    401477
     
    405481    ASSERT(isMainThread());
    406482
    407     m_delegate->databaseConnectionPendingClose(databaseConnectionIdentifier);
     483    if (m_serverConnectionIsValid)
     484        m_delegate->databaseConnectionPendingClose(databaseConnectionIdentifier);
    408485}
    409486
     
    413490    ASSERT(isMainThread());
    414491
    415     m_delegate->databaseConnectionClosed(databaseConnectionIdentifier);
     492    if (m_serverConnectionIsValid)
     493        m_delegate->databaseConnectionClosed(databaseConnectionIdentifier);
    416494}
    417495
     
    421499    ASSERT(isMainThread());
    422500
    423     m_delegate->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
     501    if (m_serverConnectionIsValid)
     502        m_delegate->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
    424503}
    425504
     
    430509    m_getAllDatabaseNamesCallbacks.add(++callbackID, WTFMove(callback));
    431510
    432     m_delegate->getAllDatabaseNames(mainFrameOrigin.data(), openingOrigin.data(), callbackID);
     511    if (m_serverConnectionIsValid)
     512        m_delegate->getAllDatabaseNames(mainFrameOrigin.data(), openingOrigin.data(), callbackID);
     513    else {
     514        callOnMainThread([this, protectedThis = makeRef(*this), callbackID = callbackID] {
     515            didGetAllDatabaseNames(callbackID, { });
     516        });
     517    }
    433518}
    434519
  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h

    r218048 r233562  
    5656    WEBCORE_EXPORT static Ref<IDBConnectionToServer> create(IDBConnectionToServerDelegate&);
    5757
    58     uint64_t identifier() const;
     58    WEBCORE_EXPORT uint64_t identifier() const;
    5959
    6060    IDBConnectionProxy& proxy();
     
    144144    IDBConnectionToServer(IDBConnectionToServerDelegate&);
    145145
     146    typedef void (IDBConnectionToServer::*ResultFunction)(const IDBResultData&);
     147    void callResultFunctionWithErrorLater(ResultFunction, const IDBResourceIdentifier& requestIdentifier);
     148   
    146149    Ref<IDBConnectionToServerDelegate> m_delegate;
     150    bool m_serverConnectionIsValid { true };
    147151
    148152    HashMap<uint64_t, WTF::Function<void (const Vector<String>&)>> m_getAllDatabaseNamesCallbacks;
  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBError.h

    r233122 r233562  
    4141    {
    4242        return IDBError { UnknownError, "Database deleted by request of the user"_s };
     43    }
     44   
     45    static IDBError serverConnectionLostError()
     46    {
     47        return IDBError { UnknownError, "Connection to Indexed Database server lost. Refresh the page to try again"_s };
    4348    }
    4449
  • trunk/Source/WebCore/page/Page.cpp

    r233560 r233562  
    21972197#if ENABLE(INDEXED_DATABASE)
    21982198    if (sessionID != m_sessionID)
    2199         m_idbIDBConnectionToServer = nullptr;
     2199        m_idbConnectionToServer = nullptr;
    22002200#endif
    22012201
     
    23212321IDBClient::IDBConnectionToServer& Page::idbConnection()
    23222322{
    2323     if (!m_idbIDBConnectionToServer)
    2324         m_idbIDBConnectionToServer = &databaseProvider().idbConnectionToServerForSession(m_sessionID);
     2323    if (!m_idbConnectionToServer)
     2324        m_idbConnectionToServer = &databaseProvider().idbConnectionToServerForSession(m_sessionID);
    23252325   
    2326     return *m_idbIDBConnectionToServer;
     2326    return *m_idbConnectionToServer;
     2327}
     2328
     2329IDBClient::IDBConnectionToServer* Page::optionalIDBConnection()
     2330{
     2331    return m_idbConnectionToServer.get();
     2332}
     2333
     2334void Page::clearIDBConnection()
     2335{
     2336    m_idbConnectionToServer = nullptr;
    23272337}
    23282338#endif
  • trunk/Source/WebCore/page/Page.h

    r233560 r233562  
    607607#if ENABLE(INDEXED_DATABASE)
    608608    IDBClient::IDBConnectionToServer& idbConnection();
     609    WEBCORE_EXPORT IDBClient::IDBConnectionToServer* optionalIDBConnection();
     610    WEBCORE_EXPORT void clearIDBConnection();
    609611#endif
    610612
     
    822824
    823825#if ENABLE(INDEXED_DATABASE)
    824     RefPtr<IDBClient::IDBConnectionToServer> m_idbIDBConnectionToServer;
     826    RefPtr<IDBClient::IDBConnectionToServer> m_idbConnectionToServer;
    825827#endif
    826828
  • trunk/Source/WebKit/ChangeLog

    r233561 r233562  
     12018-07-05  Brady Eidson  <beidson@apple.com>
     2
     3        IndexedDB operations in a Page fail after a StorageProcess crash.
     4        <rdar://problem/41626526> and https://bugs.webkit.org/show_bug.cgi?id=187123
     5
     6        Reviewed by Alex Christensen.
     7
     8        When the connection to a StorageProcess goes away, explicitly tell all of the WebPages
     9        in the WebProcess about it.
     10       
     11        This puts Documents/Workers in an error mode where requests fail instead of timeout.
     12        It also clears the Page's connection so *new* Documents and Workers will get a fresh
     13        new connection that works.
     14       
     15        * UIProcess/API/C/WKContext.cpp:
     16        (WKContextTerminateStorageProcess):
     17       
     18        * UIProcess/API/Cocoa/WKProcessPool.mm:
     19        (-[WKProcessPool _terminateStorageProcess]):
     20       
     21        * UIProcess/Storage/StorageProcessProxy.cpp:
     22        (WebKit::StorageProcessProxy::terminateForTesting):
     23        * UIProcess/Storage/StorageProcessProxy.h:
     24       
     25        * UIProcess/WebProcessPool.cpp:
     26        (WebKit::WebProcessPool::terminateStorageProcessForTesting):
     27        (WebKit::WebProcessPool::terminateStorageProcess): Deleted.
     28        * UIProcess/WebProcessPool.h:
     29       
     30        * WebProcess/Storage/WebToStorageProcessConnection.cpp:
     31        (WebKit::WebToStorageProcessConnection::didClose):
     32        * WebProcess/Storage/WebToStorageProcessConnection.h:
     33        (WebKit::WebToStorageProcessConnection::existingIDBConnectionToServerForIdentifier):
     34       
     35        * WebProcess/WebProcess.cpp:
     36        (WebKit::WebProcess::webToStorageProcessConnectionClosed):
     37
    1382018-07-05  Simon Fraser  <simon.fraser@apple.com>
    239
  • trunk/Source/WebKit/UIProcess/API/C/WKContext.cpp

    r232516 r233562  
    614614void WKContextTerminateStorageProcess(WKContextRef context)
    615615{
    616     toImpl(context)->terminateStorageProcess();
     616    toImpl(context)->terminateStorageProcessForTesting();
    617617}
    618618
  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKProcessPool.mm

    r233431 r233562  
    426426- (void)_terminateStorageProcess
    427427{
    428     _processPool->terminateStorageProcess();
     428    _processPool->terminateStorageProcessForTesting();
    429429}
    430430
  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp

    r232886 r233562  
    6666}
    6767
     68void StorageProcessProxy::terminateForTesting()
     69{
     70    for (auto& callback : m_pendingFetchWebsiteDataCallbacks.values())
     71        callback({ });
     72
     73    for (auto& callback : m_pendingDeleteWebsiteDataCallbacks.values())
     74        callback();
     75
     76    for (auto& callback : m_pendingDeleteWebsiteDataForOriginsCallbacks.values())
     77        callback();
     78   
     79    m_pendingFetchWebsiteDataCallbacks.clear();
     80    m_pendingDeleteWebsiteDataCallbacks.clear();
     81    m_pendingDeleteWebsiteDataForOriginsCallbacks.clear();
     82   
     83    terminate();
     84}
     85
    6886void StorageProcessProxy::getLaunchOptions(ProcessLauncher::LaunchOptions& launchOptions)
    6987{
  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h

    r231931 r233562  
    5959    void getStorageProcessConnection(WebProcessProxy&, Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply&&);
    6060
     61    void terminateForTesting();
     62
    6163private:
    6264    StorageProcessProxy(WebProcessPool&);
  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r233240 r233562  
    16031603}
    16041604
    1605 void WebProcessPool::terminateStorageProcess()
     1605void WebProcessPool::terminateStorageProcessForTesting()
    16061606{
    16071607    if (!m_storageProcess)
    16081608        return;
    16091609
    1610     m_storageProcess->terminate();
     1610    m_storageProcess->terminateForTesting();
    16111611    m_storageProcess = nullptr;
    16121612}
  • trunk/Source/WebKit/UIProcess/WebProcessPool.h

    r233240 r233562  
    273273
    274274    void clearCachedCredentials();
    275     void terminateStorageProcess();
     275    void terminateStorageProcessForTesting();
    276276    void terminateNetworkProcess();
    277277    void terminateServiceWorkerProcesses();
  • trunk/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.cpp

    r227789 r233562  
    102102void WebToStorageProcessConnection::didClose(IPC::Connection& connection)
    103103{
     104    auto protectedThis = makeRef(*this);
     105
    104106#if ENABLE(INDEXED_DATABASE)
    105107    for (auto& connection : m_webIDBConnectionsByIdentifier.values())
    106108        connection->connectionToServerLost();
    107 
    108     m_webIDBConnectionsByIdentifier.clear();
    109     m_webIDBConnectionsBySession.clear();
    110109#endif
    111110#if ENABLE(SERVICE_WORKER)
     
    118117
    119118    WebProcess::singleton().webToStorageProcessConnectionClosed(this);
     119
     120#if ENABLE(INDEXED_DATABASE)
     121    m_webIDBConnectionsByIdentifier.clear();
     122    m_webIDBConnectionsBySession.clear();
     123#endif
    120124}
    121125
  • trunk/Source/WebKit/WebProcess/Storage/WebToStorageProcessConnection.h

    r227161 r233562  
    5252
    5353#if ENABLE(INDEXED_DATABASE)
     54    WebIDBConnectionToServer* existingIDBConnectionToServerForIdentifier(uint64_t identifier) { return m_webIDBConnectionsByIdentifier.get(identifier); };
    5455    WebIDBConnectionToServer& idbConnectionToServerForSession(PAL::SessionID);
    5556#endif
  • trunk/Source/WebKit/WebProcess/WebProcess.cpp

    r233479 r233562  
    11801180    ASSERT(m_webToStorageProcessConnection == connection);
    11811181
    1182     m_webToStorageProcessConnection = nullptr;
    1183 
     1182#if ENABLE(INDEXED_DATABASE)
     1183    for (auto& page : m_pageMap.values()) {
     1184        auto idbConnection = page->corePage()->optionalIDBConnection();
     1185        if (!idbConnection)
     1186            continue;
     1187
     1188        if (connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())) {
     1189            ASSERT(idbConnection == &connection->existingIDBConnectionToServerForIdentifier(idbConnection->identifier())->coreConnectionToServer());
     1190            page->corePage()->clearIDBConnection();
     1191        }
     1192    }
     1193#endif
    11841194#if ENABLE(SERVICE_WORKER)
    11851195    if (SWContextManager::singleton().connection()) {
     
    11881198    }
    11891199#endif
     1200
     1201    m_webToStorageProcessConnection = nullptr;
    11901202}
    11911203
Note: See TracChangeset for help on using the changeset viewer.