Changeset 200695 in webkit


Ignore:
Timestamp:
May 11, 2016 11:42:03 AM (8 years ago)
Author:
beidson@apple.com
Message:

Modern IDB: IDBOpenDBRequests that are stop()'ed don't notify the IDBServer of that fact.
https://bugs.webkit.org/show_bug.cgi?id=157448

Reviewed by Alex Christensen.

Source/WebCore:

No new tests (Previously skipped tests cover new behavior, and are now unskipped).

There's two main parts to this patch:

1 - When an IDBOpenDBRequest is stop()'ed due to page navigation or worker termination,

we now notify the IDBServer of that.

2 - Lot's of little tweaks to UniqueIDBDatabase to handle shutting down version change

transactions and/or connections related to the cancelled openDB request.

Fortunately the changes to UniqueIDBDatabase were all well covered by existing tests.

  • Modules/indexeddb/IDBOpenDBRequest.cpp:

(WebCore::IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit):
(WebCore::IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion):
(WebCore::IDBOpenDBRequest::cancelForStop):
(WebCore::IDBOpenDBRequest::dispatchEvent):

  • Modules/indexeddb/IDBOpenDBRequest.h:
  • Modules/indexeddb/IDBRequest.cpp:

(WebCore::IDBRequest::stop):
(WebCore::IDBRequest::cancelForStop):

  • Modules/indexeddb/IDBRequest.h:
  • Modules/indexeddb/client/IDBConnectionProxy.cpp:

(WebCore::IDBClient::IDBConnectionProxy::openDBRequestCancelled):
(WebCore::IDBClient::IDBConnectionProxy::didFinishHandlingVersionChangeTransaction):

  • Modules/indexeddb/client/IDBConnectionProxy.h:
  • Modules/indexeddb/client/IDBConnectionToServer.cpp:

(WebCore::IDBClient::IDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
(WebCore::IDBClient::IDBConnectionToServer::openDBRequestCancelled):

  • Modules/indexeddb/client/IDBConnectionToServer.h:
  • Modules/indexeddb/client/IDBConnectionToServerDelegate.h:
  • Modules/indexeddb/server/IDBServer.cpp:

(WebCore::IDBServer::IDBServer::didFinishHandlingVersionChangeTransaction):
(WebCore::IDBServer::IDBServer::databaseConnectionClosed):
(WebCore::IDBServer::IDBServer::openDBRequestCancelled):

  • Modules/indexeddb/server/IDBServer.h:
  • Modules/indexeddb/server/UniqueIDBDatabase.cpp:

(WebCore::IDBServer::UniqueIDBDatabase::didDeleteBackingStore):
(WebCore::IDBServer::UniqueIDBDatabase::handleCurrentOperation):
(WebCore::IDBServer::UniqueIDBDatabase::openDBRequestCancelled):
(WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):
(WebCore::IDBServer::UniqueIDBDatabase::performCommitTransaction):
(WebCore::IDBServer::UniqueIDBDatabase::didPerformCommitTransaction):
(WebCore::IDBServer::UniqueIDBDatabase::abortTransaction):
(WebCore::IDBServer::UniqueIDBDatabase::didFinishHandlingVersionChange):
(WebCore::IDBServer::UniqueIDBDatabase::performAbortTransaction):
(WebCore::IDBServer::UniqueIDBDatabase::didPerformAbortTransaction):
(WebCore::IDBServer::UniqueIDBDatabase::connectionClosedFromClient):
(WebCore::IDBServer::UniqueIDBDatabase::transactionCompleted):
(WebCore::IDBServer::UniqueIDBDatabase::forgetErrorCallback):

  • Modules/indexeddb/server/UniqueIDBDatabase.h:
  • Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp:

(WebCore::IDBServer::UniqueIDBDatabaseConnection::abortTransactionWithoutCallback):
(WebCore::IDBServer::UniqueIDBDatabaseConnection::didFinishHandlingVersionChange):

  • Modules/indexeddb/server/UniqueIDBDatabaseConnection.h:
  • Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp:

(WebCore::IDBServer::UniqueIDBDatabaseTransaction::didFinishHandlingVersionChange): Deleted.

  • Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h:
  • Modules/indexeddb/shared/InProcessIDBServer.cpp:

(WebCore::InProcessIDBServer::didFinishHandlingVersionChangeTransaction):
(WebCore::InProcessIDBServer::openDBRequestCancelled):

  • Modules/indexeddb/shared/InProcessIDBServer.h:

Source/WebKit2:

  • DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp:

(WebKit::WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction):
(WebKit::WebIDBConnectionToClient::openDBRequestCancelled):

  • DatabaseProcess/IndexedDB/WebIDBConnectionToClient.h:
  • DatabaseProcess/IndexedDB/WebIDBConnectionToClient.messages.in:
  • WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:

(WebKit::WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
(WebKit::WebIDBConnectionToServer::openDBRequestCancelled):

  • WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h:

LayoutTests:

  • TestExpectations:
  • storage/indexeddb/pending-version-change-stuck-private-expected.txt:
  • storage/indexeddb/pending-version-change-stuck-works-with-terminate-expected.txt:
  • storage/indexeddb/pending-version-change-stuck-works-with-terminate-private-expected.txt:
Location:
trunk
Files:
31 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r200694 r200695  
     12016-05-11  Brady Eidson  <beidson@apple.com>
     2
     3        Modern IDB: IDBOpenDBRequests that are stop()'ed don't notify the IDBServer of that fact.
     4        https://bugs.webkit.org/show_bug.cgi?id=157448
     5
     6        Reviewed by Alex Christensen.
     7
     8        * TestExpectations:
     9        * storage/indexeddb/pending-version-change-stuck-private-expected.txt:
     10        * storage/indexeddb/pending-version-change-stuck-works-with-terminate-expected.txt:
     11        * storage/indexeddb/pending-version-change-stuck-works-with-terminate-private-expected.txt:
     12
    1132016-05-11  Joseph Pecoraro  <pecoraro@apple.com>
    214
  • trunk/LayoutTests/TestExpectations

    r200674 r200695  
    914914storage/indexeddb/dont-commit-on-blocked-private.html [ Failure ]
    915915
    916 # IDB workers tests that timeout
    917 storage/indexeddb/pending-version-change-stuck.html
    918 storage/indexeddb/pending-version-change-stuck-private.html
    919 storage/indexeddb/pending-version-change-stuck-works-with-terminate.html
    920 storage/indexeddb/pending-version-change-stuck-works-with-terminate-private.html
    921 
    922916# Test's behavior specific to Legacy IDB with LevelDB backend
    923917# Modern IDB is spec-compliant without supporting this behavior
  • trunk/LayoutTests/storage/indexeddb/pending-version-change-stuck-private-expected.txt

    r195247 r200695  
    66indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
    77
    8 request = indexedDB.open("pending-version-change-stuck.html")
     8request = indexedDB.open("pending-version-change-stuck-private.html")
    99PASS Open worked after page reload.
    1010PASS successfullyParsed is true
  • trunk/LayoutTests/storage/indexeddb/pending-version-change-stuck-works-with-terminate-expected.txt

    r147254 r200695  
    66indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
    77
    8 dbname = "pending-version-change-stuck-works-with-terminate.html"
    98indexedDB.open(dbname)
    109PASS Open worked after page reload.
  • trunk/LayoutTests/storage/indexeddb/pending-version-change-stuck-works-with-terminate-private-expected.txt

    r195394 r200695  
    66indexedDB = self.indexedDB || self.webkitIndexedDB || self.mozIndexedDB || self.msIndexedDB || self.OIndexedDB;
    77
    8 dbname = "pending-version-change-stuck-works-with-terminate.html"
    98indexedDB.open(dbname)
    109PASS Open worked after page reload.
  • trunk/Source/WebCore/ChangeLog

    r200691 r200695  
     12016-05-11  Brady Eidson  <beidson@apple.com>
     2
     3        Modern IDB: IDBOpenDBRequests that are stop()'ed don't notify the IDBServer of that fact.
     4        https://bugs.webkit.org/show_bug.cgi?id=157448
     5
     6        Reviewed by Alex Christensen.
     7
     8        No new tests (Previously skipped tests cover new behavior, and are now unskipped).
     9
     10        There's two main parts to this patch:
     11       
     12        1 - When an IDBOpenDBRequest is stop()'ed due to page navigation or worker termination,
     13            we now notify the IDBServer of that.
     14        2 - Lot's of little tweaks to UniqueIDBDatabase to handle shutting down version change
     15            transactions and/or connections related to the cancelled openDB request.
     16           
     17        Fortunately the changes to UniqueIDBDatabase were all well covered by existing tests.
     18       
     19        * Modules/indexeddb/IDBOpenDBRequest.cpp:
     20        (WebCore::IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit):
     21        (WebCore::IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion):
     22        (WebCore::IDBOpenDBRequest::cancelForStop):
     23        (WebCore::IDBOpenDBRequest::dispatchEvent):
     24        * Modules/indexeddb/IDBOpenDBRequest.h:
     25
     26        * Modules/indexeddb/IDBRequest.cpp:
     27        (WebCore::IDBRequest::stop):
     28        (WebCore::IDBRequest::cancelForStop):
     29        * Modules/indexeddb/IDBRequest.h:
     30
     31        * Modules/indexeddb/client/IDBConnectionProxy.cpp:
     32        (WebCore::IDBClient::IDBConnectionProxy::openDBRequestCancelled):
     33        (WebCore::IDBClient::IDBConnectionProxy::didFinishHandlingVersionChangeTransaction):
     34        * Modules/indexeddb/client/IDBConnectionProxy.h:
     35
     36        * Modules/indexeddb/client/IDBConnectionToServer.cpp:
     37        (WebCore::IDBClient::IDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
     38        (WebCore::IDBClient::IDBConnectionToServer::openDBRequestCancelled):
     39        * Modules/indexeddb/client/IDBConnectionToServer.h:
     40
     41        * Modules/indexeddb/client/IDBConnectionToServerDelegate.h:
     42
     43        * Modules/indexeddb/server/IDBServer.cpp:
     44        (WebCore::IDBServer::IDBServer::didFinishHandlingVersionChangeTransaction):
     45        (WebCore::IDBServer::IDBServer::databaseConnectionClosed):
     46        (WebCore::IDBServer::IDBServer::openDBRequestCancelled):
     47        * Modules/indexeddb/server/IDBServer.h:
     48
     49        * Modules/indexeddb/server/UniqueIDBDatabase.cpp:
     50        (WebCore::IDBServer::UniqueIDBDatabase::didDeleteBackingStore):
     51        (WebCore::IDBServer::UniqueIDBDatabase::handleCurrentOperation):
     52        (WebCore::IDBServer::UniqueIDBDatabase::openDBRequestCancelled):
     53        (WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):
     54        (WebCore::IDBServer::UniqueIDBDatabase::performCommitTransaction):
     55        (WebCore::IDBServer::UniqueIDBDatabase::didPerformCommitTransaction):
     56        (WebCore::IDBServer::UniqueIDBDatabase::abortTransaction):
     57        (WebCore::IDBServer::UniqueIDBDatabase::didFinishHandlingVersionChange):
     58        (WebCore::IDBServer::UniqueIDBDatabase::performAbortTransaction):
     59        (WebCore::IDBServer::UniqueIDBDatabase::didPerformAbortTransaction):
     60        (WebCore::IDBServer::UniqueIDBDatabase::connectionClosedFromClient):
     61        (WebCore::IDBServer::UniqueIDBDatabase::transactionCompleted):
     62        (WebCore::IDBServer::UniqueIDBDatabase::forgetErrorCallback):
     63        * Modules/indexeddb/server/UniqueIDBDatabase.h:
     64
     65        * Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp:
     66        (WebCore::IDBServer::UniqueIDBDatabaseConnection::abortTransactionWithoutCallback):
     67        (WebCore::IDBServer::UniqueIDBDatabaseConnection::didFinishHandlingVersionChange):
     68        * Modules/indexeddb/server/UniqueIDBDatabaseConnection.h:
     69
     70        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp:
     71        (WebCore::IDBServer::UniqueIDBDatabaseTransaction::didFinishHandlingVersionChange): Deleted.
     72        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h:
     73
     74        * Modules/indexeddb/shared/InProcessIDBServer.cpp:
     75        (WebCore::InProcessIDBServer::didFinishHandlingVersionChangeTransaction):
     76        (WebCore::InProcessIDBServer::openDBRequestCancelled):
     77        * Modules/indexeddb/shared/InProcessIDBServer.h:
     78
    1792016-05-11  Chris Dumez  <cdumez@apple.com>
    280
  • trunk/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp

    r200495 r200695  
    8585void IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit()
    8686{
    87     LOG(IndexedDB, "IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit()");
     87    LOG(IndexedDB, "IDBOpenDBRequest::fireSuccessAfterVersionChangeCommit() - %s", resourceIdentifier().loggingString().utf8().data());
    8888
    8989    ASSERT(currentThread() == originThreadID());
     
    9999void IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion()
    100100{
    101     LOG(IndexedDB, "IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion()");
     101    LOG(IndexedDB, "IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion() - %s", resourceIdentifier().loggingString().utf8().data());
    102102
    103103    ASSERT(currentThread() == originThreadID());
     
    112112}
    113113
     114void IDBOpenDBRequest::cancelForStop()
     115{
     116    connectionProxy().openDBRequestCancelled({ connectionProxy(), *this });
     117}
     118
    114119bool IDBOpenDBRequest::dispatchEvent(Event& event)
    115120{
     
    119124
    120125    if (m_transaction && m_transaction->isVersionChange() && (event.type() == eventNames().errorEvent || event.type() == eventNames().successEvent))
    121         m_transaction->database().connectionProxy().didFinishHandlingVersionChangeTransaction(*m_transaction);
     126        m_transaction->database().connectionProxy().didFinishHandlingVersionChangeTransaction(m_transaction->database().databaseConnectionIdentifier(), *m_transaction);
    122127
    123128    return result;
  • trunk/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.h

    r199843 r200695  
    5757    bool dispatchEvent(Event&) final;
    5858
     59    void cancelForStop() final;
     60
    5961    void onError(const IDBResultData&);
    6062    void onSuccess(const IDBResultData&);
  • trunk/Source/WebCore/Modules/indexeddb/IDBRequest.cpp

    r200521 r200695  
    243243    ASSERT(!m_contextStopped);
    244244
     245    cancelForStop();
     246
    245247    removeAllEventListeners();
    246248
    247249    m_contextStopped = true;
     250}
     251
     252void IDBRequest::cancelForStop()
     253{
     254    // The base IDBRequest class has nothing additional to do here.
    248255}
    249256
  • trunk/Source/WebCore/Modules/indexeddb/IDBRequest.h

    r200483 r200695  
    140140    bool canSuspendForDocumentSuspension() const final;
    141141    void stop() final;
     142    virtual void cancelForStop();
    142143
    143144    void refEventTarget() final { RefCounted::ref(); }
  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp

    r200521 r200695  
    294294}
    295295
     296void IDBConnectionProxy::openDBRequestCancelled(const IDBRequestData& requestData)
     297{
     298    callConnectionOnMainThread(&IDBConnectionToServer::openDBRequestCancelled, requestData);
     299}
     300
    296301void IDBConnectionProxy::establishTransaction(IDBTransaction& transaction)
    297302{
     
    374379}
    375380
    376 void IDBConnectionProxy::didFinishHandlingVersionChangeTransaction(IDBTransaction& transaction)
    377 {
    378     callConnectionOnMainThread(&IDBConnectionToServer::didFinishHandlingVersionChangeTransaction, transaction.info().identifier());
     381void IDBConnectionProxy::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, IDBTransaction& transaction)
     382{
     383    callConnectionOnMainThread(&IDBConnectionToServer::didFinishHandlingVersionChangeTransaction, databaseConnectionIdentifier, transaction.info().identifier());
    379384}
    380385
  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h

    r200521 r200695  
    8181
    8282    void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
     83    void openDBRequestCancelled(const IDBRequestData&);
    8384
    8485    void establishTransaction(IDBTransaction&);
     
    9091    void didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
    9192
    92     void didFinishHandlingVersionChangeTransaction(IDBTransaction&);
     93    void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, IDBTransaction&);
    9394    void databaseConnectionClosed(IDBDatabase&);
    9495
  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp

    r200503 r200695  
    269269}
    270270
    271 void IDBConnectionToServer::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)
     271void IDBConnectionToServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    272272{
    273273    LOG(IndexedDB, "IDBConnectionToServer::didFinishHandlingVersionChangeTransaction");
    274274    ASSERT(isMainThread());
    275275
    276     m_delegate->didFinishHandlingVersionChangeTransaction(transactionIdentifier);
     276    m_delegate->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
    277277}
    278278
     
    323323
    324324    m_proxy->notifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion);
     325}
     326
     327void IDBConnectionToServer::openDBRequestCancelled(const IDBRequestData& requestData)
     328{
     329    LOG(IndexedDB, "IDBConnectionToServer::openDBRequestCancelled");
     330    ASSERT(isMainThread());
     331
     332    m_delegate->openDBRequestCancelled(requestData);
    325333}
    326334
  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h

    r200503 r200695  
    9898    WEBCORE_EXPORT void didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
    9999
    100     void didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier&);
     100    void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier&);
    101101
    102102    void abortTransaction(const IDBResourceIdentifier& transactionIdentifier);
     
    108108    WEBCORE_EXPORT void didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
    109109    WEBCORE_EXPORT void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
     110    void openDBRequestCancelled(const IDBRequestData&);
    110111
    111112    void establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo&);
  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServerDelegate.h

    r200503 r200695  
    11/*
    2  * Copyright (C) 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2015, 2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2424 */
    2525
    26 #ifndef IDBConnectionToServerDelegate_h
    27 #define IDBConnectionToServerDelegate_h
     26#pragma once
    2827
    2928#if ENABLE(INDEXED_DATABASE)
     
    6160    virtual void abortTransaction(const IDBResourceIdentifier&) = 0;
    6261    virtual void commitTransaction(const IDBResourceIdentifier&) = 0;
    63     virtual void didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier&) = 0;
     62    virtual void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier&) = 0;
    6463    virtual void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&) = 0;
    6564    virtual void deleteObjectStore(const IDBRequestData&, const String& objectStoreName) = 0;
     
    7877    virtual void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier) = 0;
    7978    virtual void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier) = 0;
     79    virtual void openDBRequestCancelled(const IDBRequestData&) = 0;
    8080
    8181    virtual void getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID) = 0;
     
    8989
    9090#endif // ENABLE(INDEXED_DATABASE)
    91 #endif // IDBConnectionToServerDelegate_h
  • trunk/Source/WebCore/Modules/indexeddb/server/IDBServer.cpp

    r200163 r200695  
    333333}
    334334
    335 void IDBServer::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)
    336 {
    337     LOG(IndexedDB, "IDBServer::didFinishHandlingVersionChangeTransaction");
    338 
    339     auto transaction = m_transactions.get(transactionIdentifier);
    340     if (!transaction)
    341         return;
    342 
    343     transaction->didFinishHandlingVersionChange();
     335void IDBServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
     336{
     337    LOG(IndexedDB, "IDBServer::didFinishHandlingVersionChangeTransaction - %s", transactionIdentifier.loggingString().utf8().data());
     338
     339    auto* connection = m_databaseConnections.get(databaseConnectionIdentifier);
     340    if (!connection)
     341        return;
     342
     343    connection->didFinishHandlingVersionChange(transactionIdentifier);
    344344}
    345345
    346346void IDBServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
    347347{
    348     LOG(IndexedDB, "IDBServer::databaseConnectionClosed");
     348    LOG(IndexedDB, "IDBServer::databaseConnectionClosed - %" PRIu64, databaseConnectionIdentifier);
    349349
    350350    auto databaseConnection = m_databaseConnections.get(databaseConnectionIdentifier);
     
    376376    if (auto databaseConnection = m_databaseConnections.get(databaseConnectionIdentifier))
    377377        databaseConnection->didFireVersionChangeEvent(requestIdentifier);
     378}
     379
     380void IDBServer::openDBRequestCancelled(const IDBRequestData& requestData)
     381{
     382    LOG(IndexedDB, "IDBServer::openDBRequestCancelled");
     383
     384    auto* uniqueIDBDatabase = m_uniqueIDBDatabaseMap.get(requestData.databaseIdentifier());
     385    if (!uniqueIDBDatabase)
     386        return;
     387
     388    uniqueIDBDatabase->openDBRequestCancelled(requestData.requestIdentifier());
    378389}
    379390
  • trunk/Source/WebCore/Modules/indexeddb/server/IDBServer.h

    r200163 r200695  
    11/*
    2  * Copyright (C) 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2015, 2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2424 */
    2525
    26 #ifndef IDBServer_h
    27 #define IDBServer_h
     26#pragma once
    2827
    2928#if ENABLE(INDEXED_DATABASE)
     
    6564    WEBCORE_EXPORT void abortTransaction(const IDBResourceIdentifier&);
    6665    WEBCORE_EXPORT void commitTransaction(const IDBResourceIdentifier&);
    67     WEBCORE_EXPORT void didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier&);
     66    WEBCORE_EXPORT void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier&);
    6867    WEBCORE_EXPORT void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&);
    6968    WEBCORE_EXPORT void deleteObjectStore(const IDBRequestData&, const String& objectStoreName);
     
    8281    WEBCORE_EXPORT void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier);
    8382    WEBCORE_EXPORT void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier);
     83    WEBCORE_EXPORT void openDBRequestCancelled(const IDBRequestData&);
    8484
    8585    WEBCORE_EXPORT void getAllDatabaseNames(uint64_t serverConnectionIdentifier, const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID);
     
    132132
    133133#endif // ENABLE(INDEXED_DATABASE)
    134 #endif // IDBServer_h
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp

    r200603 r200695  
    7575void UniqueIDBDatabase::openDatabaseConnection(IDBConnectionToClient& connection, const IDBRequestData& requestData)
    7676{
    77     auto operation = ServerOpenDBRequest::create(connection, requestData);
    78     m_pendingOpenDBRequests.append(WTFMove(operation));
     77    m_pendingOpenDBRequests.add(ServerOpenDBRequest::create(connection, requestData));
    7978
    8079    // An open operation is already in progress, so we can't possibly handle this one yet.
     
    248247    LOG(IndexedDB, "(main) UniqueIDBDatabase::didDeleteBackingStore");
    249248
    250     ASSERT(m_currentOpenDBRequest);
    251     ASSERT(m_currentOpenDBRequest->isDeleteRequest());
    252249    ASSERT(!hasAnyPendingCallbacks());
    253250    ASSERT(!hasUnfinishedTransactions());
    254251    ASSERT(m_pendingTransactions.isEmpty());
    255252    ASSERT(m_openDatabaseConnections.isEmpty());
     253
     254    // It's possible that the openDBRequest was cancelled from client-side after the delete was already dispatched to the backingstore.
     255    // So it's okay if we don't have a currentOpenDBRequest, but if we do it has to be a deleteRequest.
     256    ASSERT(!m_currentOpenDBRequest || m_currentOpenDBRequest->isDeleteRequest());
    256257
    257258    if (m_databaseInfo)
     
    264265        m_mostRecentDeletedDatabaseInfo = std::make_unique<IDBDatabaseInfo>(m_identifier.databaseName(), deletedVersion);
    265266
    266     m_currentOpenDBRequest->notifyDidDeleteDatabase(*m_mostRecentDeletedDatabaseInfo);
    267     m_currentOpenDBRequest = nullptr;
     267    if (m_currentOpenDBRequest) {
     268        m_currentOpenDBRequest->notifyDidDeleteDatabase(*m_mostRecentDeletedDatabaseInfo);
     269        m_currentOpenDBRequest = nullptr;
     270    }
    268271
    269272    m_deleteBackingStoreInProgress = false;
    270273
    271     if (m_closePendingDatabaseConnections.isEmpty()) {
    272         if (m_pendingOpenDBRequests.isEmpty())
    273             m_server.closeUniqueIDBDatabase(*this);
    274         else
    275             invokeOperationAndTransactionTimer();
    276     }
     274    if (m_closePendingDatabaseConnections.isEmpty() && m_pendingOpenDBRequests.isEmpty()) {
     275        m_server.closeUniqueIDBDatabase(*this);
     276        return;
     277    }
     278
     279    invokeOperationAndTransactionTimer();
    277280}
    278281
     
    280283{
    281284    ASSERT(isMainThread());
    282     LOG(IndexedDB, "(main) UniqueIDBDatabase::handleDatabaseOperations - There are %zu pending", m_pendingOpenDBRequests.size());
     285    LOG(IndexedDB, "(main) UniqueIDBDatabase::handleDatabaseOperations - There are %u pending", m_pendingOpenDBRequests.size());
     286
     287    if (m_deleteBackingStoreInProgress)
     288        return;
    283289
    284290    if (m_versionChangeDatabaseConnection || m_versionChangeTransaction || m_currentOpenDBRequest) {
     
    298304
    299305    m_currentOpenDBRequest = m_pendingOpenDBRequests.takeFirst();
    300     LOG(IndexedDB, "UniqueIDBDatabase::handleDatabaseOperations - Popped an operation, now there are %zu pending", m_pendingOpenDBRequests.size());
     306    LOG(IndexedDB, "UniqueIDBDatabase::handleDatabaseOperations - Popped an operation, now there are %u pending", m_pendingOpenDBRequests.size());
    301307
    302308    handleCurrentOperation();
     
    305311void UniqueIDBDatabase::handleCurrentOperation()
    306312{
     313    LOG(IndexedDB, "(main) UniqueIDBDatabase::handleCurrentOperation");
     314
    307315    ASSERT(m_currentOpenDBRequest);
    308316
     
    368376    LOG(IndexedDB, "(main) UniqueIDBDatabase::handleDelete");
    369377
    370     m_pendingOpenDBRequests.append(ServerOpenDBRequest::create(connection, requestData));
     378    m_pendingOpenDBRequests.add(ServerOpenDBRequest::create(connection, requestData));
    371379    handleDatabaseOperations();
    372380}
     
    466474
    467475    notifyCurrentRequestConnectionClosedOrFiredVersionChangeEvent(connection.identifier());
     476}
     477
     478void UniqueIDBDatabase::openDBRequestCancelled(const IDBResourceIdentifier& requestIdentifier)
     479{
     480    LOG(IndexedDB, "UniqueIDBDatabase::openDBRequestCancelled - %s", requestIdentifier.loggingString().utf8().data());
     481
     482    if (m_currentOpenDBRequest && m_currentOpenDBRequest->requestData().requestIdentifier() == requestIdentifier)
     483        m_currentOpenDBRequest = nullptr;
     484
     485    if (m_versionChangeDatabaseConnection && m_versionChangeDatabaseConnection->openRequestIdentifier() == requestIdentifier) {
     486        ASSERT(!m_versionChangeTransaction || m_versionChangeTransaction->databaseConnection().openRequestIdentifier() == requestIdentifier);
     487        ASSERT(!m_versionChangeTransaction || &m_versionChangeTransaction->databaseConnection() == m_versionChangeDatabaseConnection);
     488
     489        connectionClosedFromClient(*m_versionChangeDatabaseConnection);
     490    }
     491
     492    for (auto& request : m_pendingOpenDBRequests) {
     493        if (request->requestData().requestIdentifier() == requestIdentifier) {
     494            m_pendingOpenDBRequests.remove(request);
     495            return;
     496        }
     497    }
    468498}
    469499
     
    9991029{
    10001030    ASSERT(isMainThread());
    1001     LOG(IndexedDB, "(main) UniqueIDBDatabase::commitTransaction");
     1031    LOG(IndexedDB, "(main) UniqueIDBDatabase::commitTransaction - %s", transaction.info().identifier().loggingString().utf8().data());
    10021032
    10031033    ASSERT(&transaction.databaseConnection().database() == this);
     
    10061036
    10071037    if (!prepareToFinishTransaction(transaction)) {
     1038        if (!m_openDatabaseConnections.contains(&transaction.databaseConnection())) {
     1039            // This database connection is closing or has already closed, so there is no point in messaging back to it about the commit failing.
     1040            forgetErrorCallback(callbackID);
     1041            return;
     1042        }
     1043
    10081044        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to commit transaction that is already finishing") });
    10091045        return;
     
    10161052{
    10171053    ASSERT(!isMainThread());
    1018     LOG(IndexedDB, "(db) UniqueIDBDatabase::performCommitTransaction");
     1054    LOG(IndexedDB, "(db) UniqueIDBDatabase::performCommitTransaction - %s", transactionIdentifier.loggingString().utf8().data());
    10191055
    10201056    IDBError error = m_backingStore->commitTransaction(transactionIdentifier);
     
    10251061{
    10261062    ASSERT(isMainThread());
    1027     LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformCommitTransaction");
     1063    LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformCommitTransaction - %s", transactionIdentifier.loggingString().utf8().data());
    10281064
    10291065    performErrorCallback(callbackIdentifier, error);
     
    10351071{
    10361072    ASSERT(isMainThread());
    1037     LOG(IndexedDB, "(main) UniqueIDBDatabase::abortTransaction");
     1073    LOG(IndexedDB, "(main) UniqueIDBDatabase::abortTransaction - %s", transaction.info().identifier().loggingString().utf8().data());
    10381074
    10391075    ASSERT(&transaction.databaseConnection().database() == this);
     
    10421078
    10431079    if (!prepareToFinishTransaction(transaction)) {
     1080        if (!m_openDatabaseConnections.contains(&transaction.databaseConnection())) {
     1081            // This database connection is closing or has already closed, so there is no point in messaging back to it about the abort failing.
     1082            forgetErrorCallback(callbackID);
     1083            return;
     1084        }
     1085
    10441086        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to abort transaction that is already finishing") });
    10451087        return;
     
    10491091}
    10501092
    1051 void UniqueIDBDatabase::didFinishHandlingVersionChange(UniqueIDBDatabaseTransaction& transaction)
     1093void UniqueIDBDatabase::didFinishHandlingVersionChange(UniqueIDBDatabaseConnection& connection, const IDBResourceIdentifier& transactionIdentifier)
    10521094{
    10531095    ASSERT(isMainThread());
    10541096    LOG(IndexedDB, "(main) UniqueIDBDatabase::didFinishHandlingVersionChange");
    10551097
    1056     ASSERT(m_versionChangeTransaction);
    1057     ASSERT_UNUSED(transaction, m_versionChangeTransaction == &transaction);
     1098    ASSERT_UNUSED(transactionIdentifier, !m_versionChangeTransaction || m_versionChangeTransaction->info().identifier() == transactionIdentifier);
     1099    ASSERT_UNUSED(connection, !m_versionChangeDatabaseConnection || m_versionChangeDatabaseConnection.get() == &connection);
    10581100
    10591101    m_versionChangeTransaction = nullptr;
     
    10661108{
    10671109    ASSERT(!isMainThread());
    1068     LOG(IndexedDB, "(db) UniqueIDBDatabase::performAbortTransaction");
     1110    LOG(IndexedDB, "(db) UniqueIDBDatabase::performAbortTransaction - %s", transactionIdentifier.loggingString().utf8().data());
    10691111
    10701112    IDBError error = m_backingStore->abortTransaction(transactionIdentifier);
     
    10751117{
    10761118    ASSERT(isMainThread());
    1077     LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformAbortTransaction");
     1119    LOG(IndexedDB, "(main) UniqueIDBDatabase::didPerformAbortTransaction - %s", transactionIdentifier.loggingString().utf8().data());
    10781120
    10791121    auto transaction = m_finishingTransactions.take(transactionIdentifier);
     
    11011143{
    11021144    ASSERT(isMainThread());
    1103     LOG(IndexedDB, "(main) UniqueIDBDatabase::connectionClosedFromClient");
    1104 
    1105     if (m_versionChangeDatabaseConnection == &connection)
     1145    LOG(IndexedDB, "(main) UniqueIDBDatabase::connectionClosedFromClient - %s (%" PRIu64 ")", connection.openRequestIdentifier().loggingString().utf8().data(), connection.identifier());
     1146
     1147    Ref<UniqueIDBDatabaseConnection> protectedConnection(connection);
     1148    m_openDatabaseConnections.remove(&connection);
     1149
     1150    if (m_versionChangeDatabaseConnection == &connection) {
     1151        if (m_versionChangeTransaction) {
     1152            m_closePendingDatabaseConnections.add(WTFMove(m_versionChangeDatabaseConnection));
     1153
     1154            auto transactionIdentifier = m_versionChangeTransaction->info().identifier();
     1155            if (m_inProgressTransactions.contains(transactionIdentifier)) {
     1156                ASSERT(!m_finishingTransactions.contains(transactionIdentifier));
     1157                connection.abortTransactionWithoutCallback(*m_versionChangeTransaction);
     1158            }
     1159
     1160            return;
     1161        }
     1162
    11061163        m_versionChangeDatabaseConnection = nullptr;
    1107 
    1108     ASSERT(m_openDatabaseConnections.contains(&connection));
     1164    }
    11091165
    11101166    Deque<RefPtr<UniqueIDBDatabaseTransaction>> pendingTransactions;
     
    11181174        m_pendingTransactions.swap(pendingTransactions);
    11191175
    1120     RefPtr<UniqueIDBDatabaseConnection> refConnection(&connection);
    1121     m_openDatabaseConnections.remove(&connection);
    1122 
    11231176    if (m_currentOpenDBRequest)
    11241177        notifyCurrentRequestConnectionClosedOrFiredVersionChangeEvent(connection.identifier());
    11251178
    11261179    if (connection.hasNonFinishedTransactions()) {
    1127         m_closePendingDatabaseConnections.add(WTFMove(refConnection));
     1180        m_closePendingDatabaseConnections.add(WTFMove(protectedConnection));
    11281181        return;
    11291182    }
     
    13231376        m_closePendingDatabaseConnections.remove(&transaction->databaseConnection());
    13241377
     1378    if (m_versionChangeTransaction == transaction)
     1379        m_versionChangeTransaction = nullptr;
     1380
    13251381    // It's possible that this database had its backing store deleted but there were a few outstanding asynchronous operations.
    13261382    // If this transaction completing was the last of those operations, we can finally delete this UniqueIDBDatabase.
     
    13621418}
    13631419
     1420void UniqueIDBDatabase::forgetErrorCallback(uint64_t callbackIdentifier)
     1421{
     1422    ASSERT(m_errorCallbacks.contains(callbackIdentifier));
     1423    m_errorCallbacks.remove(callbackIdentifier);
     1424}
     1425
    13641426} // namespace IDBServer
    13651427} // namespace WebCore
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h

    r200598 r200695  
    9797    void commitTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
    9898    void abortTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);
    99     void didFinishHandlingVersionChange(UniqueIDBDatabaseTransaction&);
     99    void didFinishHandlingVersionChange(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& transactionIdentifier);
    100100    void transactionDestroyed(UniqueIDBDatabaseTransaction&);
    101101    void connectionClosedFromClient(UniqueIDBDatabaseConnection&);
    102102    void didFireVersionChangeEvent(UniqueIDBDatabaseConnection&, const IDBResourceIdentifier& requestIdentifier);
     103    void openDBRequestCancelled(const IDBResourceIdentifier& requestIdentifier);
    103104
    104105    void enqueueTransaction(Ref<UniqueIDBDatabaseTransaction>&&);
     
    175176    void performCountCallback(uint64_t callbackIdentifier, const IDBError&, uint64_t);
    176177
     178    void forgetErrorCallback(uint64_t callbackIdentifier);
     179
    177180    bool hasAnyPendingCallbacks() const;
    178181    bool isCurrentlyInUse() const;
     
    188191    IDBDatabaseIdentifier m_identifier;
    189192   
    190     Deque<Ref<ServerOpenDBRequest>> m_pendingOpenDBRequests;
     193    ListHashSet<RefPtr<ServerOpenDBRequest>> m_pendingOpenDBRequests;
    191194    RefPtr<ServerOpenDBRequest> m_currentOpenDBRequest;
    192195
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.cpp

    r200603 r200695  
    3333#include "IDBTransactionInfo.h"
    3434#include "Logging.h"
     35#include "ServerOpenDBRequest.h"
    3536#include "UniqueIDBDatabase.h"
    3637
     
    7172{
    7273    ASSERT(m_transactionMap.contains(transaction.info().identifier()));
    73     auto takenTransaction = m_transactionMap.take(transaction.info().identifier());
    74 
    75     m_database.abortTransaction(*takenTransaction, [](const IDBError&) { });
     74
     75    const auto& transactionIdentifier = transaction.info().identifier();
     76    RefPtr<UniqueIDBDatabaseConnection> protector(this);
     77
     78    m_database.abortTransaction(transaction, [this, protector, transactionIdentifier](const IDBError&) {
     79        ASSERT(m_transactionMap.contains(transactionIdentifier));
     80        m_transactionMap.remove(transactionIdentifier);
     81    });
    7682}
    7783
     
    8995
    9096    m_database.didFireVersionChangeEvent(*this, requestIdentifier);
     97}
     98
     99void UniqueIDBDatabaseConnection::didFinishHandlingVersionChange(const IDBResourceIdentifier& transactionIdentifier)
     100{
     101    LOG(IndexedDB, "UniqueIDBDatabaseConnection::didFinishHandlingVersionChange - %s - %" PRIu64, transactionIdentifier.loggingString().utf8().data(), m_identifier);
     102
     103    m_database.didFinishHandlingVersionChange(*this, transactionIdentifier);
    91104}
    92105
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseConnection.h

    r200603 r200695  
    2424 */
    2525
    26 #ifndef UniqueIDBDatabaseConnection_h
    27 #define UniqueIDBDatabaseConnection_h
     26#pragma once
    2827
    2928#if ENABLE(INDEXED_DATABASE)
     
    7574    void didDeleteIndex(const IDBResultData&);
    7675    void didFireVersionChangeEvent(const IDBResourceIdentifier& requestIdentifier);
     76    void didFinishHandlingVersionChange(const IDBResourceIdentifier& transactionIdentifier);
    7777
    7878    void abortTransactionWithoutCallback(UniqueIDBDatabaseTransaction&);
     
    9595
    9696#endif // ENABLE(INDEXED_DATABASE)
    97 #endif // UniqueIDBDatabaseConnection_h
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp

    r199072 r200695  
    317317}
    318318
    319 void UniqueIDBDatabaseTransaction::didFinishHandlingVersionChange()
    320 {
    321     LOG(IndexedDB, "UniqueIDBDatabaseTransaction::didFinishHandlingVersionChange");
    322     ASSERT(isVersionChange());
    323 
    324     m_databaseConnection->database().didFinishHandlingVersionChange(*this);
    325 }
    326 
    327319} // namespace IDBServer
    328320} // namespace WebCore
  • trunk/Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h

    r199072 r200695  
    2424 */
    2525
    26 #ifndef UniqueIDBDatabaseTransaction_h
    27 #define UniqueIDBDatabaseTransaction_h
     26#pragma once
    2827
    2928#if ENABLE(INDEXED_DATABASE)
     
    8180
    8281    void didActivateInBackingStore(const IDBError&);
    83     void didFinishHandlingVersionChange();
    8482
    8583    const Vector<uint64_t>& objectStoreIdentifiers();
     
    10098
    10199#endif // ENABLE(INDEXED_DATABASE)
    102 #endif // UniqueIDBDatabaseTransaction_h
  • trunk/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.cpp

    r200503 r200695  
    242242}
    243243
    244 void InProcessIDBServer::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)
    245 {
    246     RefPtr<InProcessIDBServer> self(this);
    247     RunLoop::current().dispatch([this, self, transactionIdentifier] {
    248         m_server->didFinishHandlingVersionChangeTransaction(transactionIdentifier);
     244void InProcessIDBServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
     245{
     246    RefPtr<InProcessIDBServer> self(this);
     247    RunLoop::current().dispatch([this, self, databaseConnectionIdentifier, transactionIdentifier] {
     248        m_server->didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
    249249    });
    250250}
     
    400400}
    401401
     402void InProcessIDBServer::openDBRequestCancelled(const IDBRequestData& requestData)
     403{
     404    RefPtr<InProcessIDBServer> self(this);
     405    RunLoop::current().dispatch([this, self, requestData] {
     406        m_server->openDBRequestCancelled(requestData);
     407    });
     408}
     409
    402410void InProcessIDBServer::getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID)
    403411{
  • trunk/Source/WebCore/Modules/indexeddb/shared/InProcessIDBServer.h

    r200503 r200695  
    2424 */
    2525
    26 #ifndef InProcessIDBServer_h
    27 #define InProcessIDBServer_h
     26#pragma once
    2827
    2928#if ENABLE(INDEXED_DATABASE)
     
    6059    void abortTransaction(const IDBResourceIdentifier&) final;
    6160    void commitTransaction(const IDBResourceIdentifier&) final;
    62     void didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier&) final;
     61    void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier&) final;
    6362    void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&) final;
    6463    void deleteObjectStore(const IDBRequestData&, const String& objectStoreName) final;
     
    7675    void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier) final;
    7776    void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier) final;
     77    void openDBRequestCancelled(const IDBRequestData&) final;
    7878    void getAllDatabaseNames(const SecurityOriginData& mainFrameOrigin, const SecurityOriginData& openingOrigin, uint64_t callbackID) final;
    7979
     
    118118
    119119#endif // ENABLE(INDEXED_DATABASE)
    120 #endif // InProcessIDBServer_h
  • trunk/Source/WebKit2/ChangeLog

    r200692 r200695  
     12016-05-11  Brady Eidson  <beidson@apple.com>
     2
     3        Modern IDB: IDBOpenDBRequests that are stop()'ed don't notify the IDBServer of that fact.
     4        https://bugs.webkit.org/show_bug.cgi?id=157448
     5
     6        Reviewed by Alex Christensen.
     7
     8        * DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp:
     9        (WebKit::WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction):
     10        (WebKit::WebIDBConnectionToClient::openDBRequestCancelled):
     11        * DatabaseProcess/IndexedDB/WebIDBConnectionToClient.h:
     12        * DatabaseProcess/IndexedDB/WebIDBConnectionToClient.messages.in:
     13
     14        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
     15        (WebKit::WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
     16        (WebKit::WebIDBConnectionToServer::openDBRequestCancelled):
     17        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h:
     18
    1192016-05-11  Myles C. Maxfield  <mmaxfield@apple.com>
    220
  • trunk/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp

    r200163 r200695  
    200200}
    201201
    202 void WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)
    203 {
    204     DatabaseProcess::singleton().idbServer().didFinishHandlingVersionChangeTransaction(transactionIdentifier);
     202void WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
     203{
     204    DatabaseProcess::singleton().idbServer().didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier);
    205205}
    206206
     
    290290}
    291291
     292void WebIDBConnectionToClient::openDBRequestCancelled(const IDBRequestData& requestData)
     293{
     294    DatabaseProcess::singleton().idbServer().openDBRequestCancelled(requestData);
     295}
     296
    292297void WebIDBConnectionToClient::getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID)
    293298{
  • trunk/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.h

    r200163 r200695  
    8989    void abortTransaction(const WebCore::IDBResourceIdentifier&);
    9090    void commitTransaction(const WebCore::IDBResourceIdentifier&);
    91     void didFinishHandlingVersionChangeTransaction(const WebCore::IDBResourceIdentifier&);
     91    void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier&);
    9292    void createObjectStore(const WebCore::IDBRequestData&, const WebCore::IDBObjectStoreInfo&);
    9393    void deleteObjectStore(const WebCore::IDBRequestData&, const String& objectStoreName);
     
    106106    void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier);
    107107    void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier);
     108    void openDBRequestCancelled(const WebCore::IDBRequestData&);
    108109
    109110    void getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID);
  • trunk/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.messages.in

    r200163 r200695  
    2828    AbortTransaction(WebCore::IDBResourceIdentifier transactionIdentifier);
    2929    CommitTransaction(WebCore::IDBResourceIdentifier transactionIdentifier);
    30     DidFinishHandlingVersionChangeTransaction(WebCore::IDBResourceIdentifier transactionIdentifier);
     30    DidFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier);
    3131    CreateObjectStore(WebCore::IDBRequestData requestData, WebCore::IDBObjectStoreInfo info);
    3232    DeleteObjectStore(WebCore::IDBRequestData requestData, String objectStoreName);
     
    4545    AbortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier);
    4646    DidFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier requestIdentifier);
     47    OpenDBRequestCancelled(WebCore::IDBRequestData requestData);
    4748
    4849    GetAllDatabaseNames(uint64_t serverConnectionIdentifier, struct WebCore::SecurityOriginData topOrigin, struct WebCore::SecurityOriginData openingOrigin, uint64_t callbackID);
  • trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp

    r200503 r200695  
    102102}
    103103
    104 void WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)
    105 {
    106     send(Messages::WebIDBConnectionToClient::DidFinishHandlingVersionChangeTransaction(transactionIdentifier));
     104void WebIDBConnectionToServer::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
     105{
     106    send(Messages::WebIDBConnectionToClient::DidFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier));
    107107}
    108108
     
    182182}
    183183
     184void WebIDBConnectionToServer::openDBRequestCancelled(const IDBRequestData& requestData)
     185{
     186    send(Messages::WebIDBConnectionToClient::OpenDBRequestCancelled(requestData));
     187}
     188
    184189void WebIDBConnectionToServer::getAllDatabaseNames(const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID)
    185190{
  • trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h

    r200503 r200695  
    5050    void abortTransaction(const WebCore::IDBResourceIdentifier&) final;
    5151    void commitTransaction(const WebCore::IDBResourceIdentifier&) final;
    52     void didFinishHandlingVersionChangeTransaction(const WebCore::IDBResourceIdentifier&) final;
     52    void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier&) final;
    5353    void createObjectStore(const WebCore::IDBRequestData&, const WebCore::IDBObjectStoreInfo&) final;
    5454    void deleteObjectStore(const WebCore::IDBRequestData&, const String& objectStoreName) final;
     
    6666    void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier) final;
    6767    void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier) final;
     68    void openDBRequestCancelled(const WebCore::IDBRequestData&) final;
     69
    6870    void getAllDatabaseNames(const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID) final;
    6971
Note: See TracChangeset for help on using the changeset viewer.