Changeset 200485 in webkit


Ignore:
Timestamp:
May 5, 2016, 3:14:08 PM (9 years ago)
Author:
beidson@apple.com
Message:

Modern IDB: Move all IDB DOM object management from IDBConnectionToServer to IDBConnectionProxy.
​https://bugs.webkit.org/show_bug.cgi?id=157348

Reviewed by Alex Christensen.

No new tests (Refactor, no change in behavior yet).

This is in-progress IDB-in-Workers code that is isolated enough to land right now.

The goal is to have IDBConnectionToServer be a main-thread-only object, leaving IDBConnectionProxy
as the threading bridge between the worker thread and the main thread.

As such, IDBConnectionToServer no longer maintains maps of IDB DOM objects, but instead the proxy
does and guards that access with locks.

No threading changes takes place in this patch but it does scatter some isMainThread() checks and FIXMEs
accurately representing where threading changes will take place once I can return to this.

  • Modules/indexeddb/IDBDatabase.cpp:

(WebCore::IDBDatabase::IDBDatabase):
(WebCore::IDBDatabase::~IDBDatabase):
(WebCore::IDBDatabase::maybeCloseInServer):

  • Modules/indexeddb/IDBOpenDBRequest.cpp:

(WebCore::IDBOpenDBRequest::dispatchEvent):

  • Modules/indexeddb/IDBTransaction.cpp:

(WebCore::IDBTransaction::abortOnServerAndCancelRequests):
(WebCore::IDBTransaction::commitOnServer):
(WebCore::IDBTransaction::establishOnServer):

  • Modules/indexeddb/client/IDBConnectionProxy.cpp:

(WebCore::IDBClient::IDBConnectionProxy::openDatabase):
(WebCore::IDBClient::IDBConnectionProxy::deleteDatabase):
(WebCore::IDBClient::IDBConnectionProxy::didOpenDatabase):
(WebCore::IDBClient::IDBConnectionProxy::didDeleteDatabase):
(WebCore::IDBClient::IDBConnectionProxy::completeOpenDBRequest):
(WebCore::IDBClient::IDBConnectionProxy::fireVersionChangeEvent):
(WebCore::IDBClient::IDBConnectionProxy::didFireVersionChangeEvent):
(WebCore::IDBClient::IDBConnectionProxy::notifyOpenDBRequestBlocked):
(WebCore::IDBClient::IDBConnectionProxy::establishTransaction):
(WebCore::IDBClient::IDBConnectionProxy::didStartTransaction):
(WebCore::IDBClient::IDBConnectionProxy::commitTransaction):
(WebCore::IDBClient::IDBConnectionProxy::didCommitTransaction):
(WebCore::IDBClient::IDBConnectionProxy::abortTransaction):
(WebCore::IDBClient::IDBConnectionProxy::didAbortTransaction):
(WebCore::IDBClient::IDBConnectionProxy::hasRecordOfTransaction):
(WebCore::IDBClient::IDBConnectionProxy::didFinishHandlingVersionChangeTransaction):
(WebCore::IDBClient::IDBConnectionProxy::databaseConnectionClosed):
(WebCore::IDBClient::IDBConnectionProxy::registerDatabaseConnection):
(WebCore::IDBClient::IDBConnectionProxy::unregisterDatabaseConnection):

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

(WebCore::IDBClient::IDBConnectionToServer::deleteDatabase):
(WebCore::IDBClient::IDBConnectionToServer::didDeleteDatabase):
(WebCore::IDBClient::IDBConnectionToServer::openDatabase):
(WebCore::IDBClient::IDBConnectionToServer::didOpenDatabase):
(WebCore::IDBClient::IDBConnectionToServer::establishTransaction):
(WebCore::IDBClient::IDBConnectionToServer::commitTransaction):
(WebCore::IDBClient::IDBConnectionToServer::didCommitTransaction):
(WebCore::IDBClient::IDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
(WebCore::IDBClient::IDBConnectionToServer::abortTransaction):
(WebCore::IDBClient::IDBConnectionToServer::didAbortTransaction):
(WebCore::IDBClient::IDBConnectionToServer::fireVersionChangeEvent):
(WebCore::IDBClient::IDBConnectionToServer::didFireVersionChangeEvent):
(WebCore::IDBClient::IDBConnectionToServer::didStartTransaction):
(WebCore::IDBClient::IDBConnectionToServer::notifyOpenDBRequestBlocked):
(WebCore::IDBClient::IDBConnectionToServer::databaseConnectionClosed):
(WebCore::IDBClient::IDBConnectionToServer::registerDatabaseConnection): Deleted.
(WebCore::IDBClient::IDBConnectionToServer::unregisterDatabaseConnection): Deleted.
(WebCore::IDBClient::IDBConnectionToServer::hasRecordOfTransaction): Deleted.

  • Modules/indexeddb/client/IDBConnectionToServer.h:
  • Modules/indexeddb/shared/IDBRequestData.cpp:

(WebCore::IDBRequestData::IDBRequestData):

  • Modules/indexeddb/shared/IDBRequestData.h:
  • Modules/indexeddb/shared/IDBResourceIdentifier.cpp:

(WebCore::IDBResourceIdentifier::IDBResourceIdentifier):

  • Modules/indexeddb/shared/IDBResourceIdentifier.h:
Location:
trunk/Source/WebCore
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r200484 r200485  
     12016-05-04  Brady Eidson  <beidson@apple.com>
     2
     3        Modern IDB: Move all IDB DOM object management from IDBConnectionToServer to IDBConnectionProxy.
     4        https://bugs.webkit.org/show_bug.cgi?id=157348
     5
     6        Reviewed by Alex Christensen.
     7
     8        No new tests (Refactor, no change in behavior yet).
     9
     10        This is in-progress IDB-in-Workers code that is isolated enough to land right now.
     11       
     12        The goal is to have IDBConnectionToServer be a main-thread-only object, leaving IDBConnectionProxy
     13        as the threading bridge between the worker thread and the main thread.
     14       
     15        As such, IDBConnectionToServer no longer maintains maps of IDB DOM objects, but instead the proxy
     16        does and guards that access with locks.
     17       
     18        No threading changes takes place in this patch but it does scatter some isMainThread() checks and FIXMEs
     19        accurately representing where threading changes will take place once I can return to this.
     20       
     21        * Modules/indexeddb/IDBDatabase.cpp:
     22        (WebCore::IDBDatabase::IDBDatabase):
     23        (WebCore::IDBDatabase::~IDBDatabase):
     24        (WebCore::IDBDatabase::maybeCloseInServer):
     25
     26        * Modules/indexeddb/IDBOpenDBRequest.cpp:
     27        (WebCore::IDBOpenDBRequest::dispatchEvent):
     28
     29        * Modules/indexeddb/IDBTransaction.cpp:
     30        (WebCore::IDBTransaction::abortOnServerAndCancelRequests):
     31        (WebCore::IDBTransaction::commitOnServer):
     32        (WebCore::IDBTransaction::establishOnServer):
     33
     34        * Modules/indexeddb/client/IDBConnectionProxy.cpp:
     35        (WebCore::IDBClient::IDBConnectionProxy::openDatabase):
     36        (WebCore::IDBClient::IDBConnectionProxy::deleteDatabase):
     37        (WebCore::IDBClient::IDBConnectionProxy::didOpenDatabase):
     38        (WebCore::IDBClient::IDBConnectionProxy::didDeleteDatabase):
     39        (WebCore::IDBClient::IDBConnectionProxy::completeOpenDBRequest):
     40        (WebCore::IDBClient::IDBConnectionProxy::fireVersionChangeEvent):
     41        (WebCore::IDBClient::IDBConnectionProxy::didFireVersionChangeEvent):
     42        (WebCore::IDBClient::IDBConnectionProxy::notifyOpenDBRequestBlocked):
     43        (WebCore::IDBClient::IDBConnectionProxy::establishTransaction):
     44        (WebCore::IDBClient::IDBConnectionProxy::didStartTransaction):
     45        (WebCore::IDBClient::IDBConnectionProxy::commitTransaction):
     46        (WebCore::IDBClient::IDBConnectionProxy::didCommitTransaction):
     47        (WebCore::IDBClient::IDBConnectionProxy::abortTransaction):
     48        (WebCore::IDBClient::IDBConnectionProxy::didAbortTransaction):
     49        (WebCore::IDBClient::IDBConnectionProxy::hasRecordOfTransaction):
     50        (WebCore::IDBClient::IDBConnectionProxy::didFinishHandlingVersionChangeTransaction):
     51        (WebCore::IDBClient::IDBConnectionProxy::databaseConnectionClosed):
     52        (WebCore::IDBClient::IDBConnectionProxy::registerDatabaseConnection):
     53        (WebCore::IDBClient::IDBConnectionProxy::unregisterDatabaseConnection):
     54        * Modules/indexeddb/client/IDBConnectionProxy.h:
     55       
     56        * Modules/indexeddb/client/IDBConnectionToServer.cpp:
     57        (WebCore::IDBClient::IDBConnectionToServer::deleteDatabase):
     58        (WebCore::IDBClient::IDBConnectionToServer::didDeleteDatabase):
     59        (WebCore::IDBClient::IDBConnectionToServer::openDatabase):
     60        (WebCore::IDBClient::IDBConnectionToServer::didOpenDatabase):
     61        (WebCore::IDBClient::IDBConnectionToServer::establishTransaction):
     62        (WebCore::IDBClient::IDBConnectionToServer::commitTransaction):
     63        (WebCore::IDBClient::IDBConnectionToServer::didCommitTransaction):
     64        (WebCore::IDBClient::IDBConnectionToServer::didFinishHandlingVersionChangeTransaction):
     65        (WebCore::IDBClient::IDBConnectionToServer::abortTransaction):
     66        (WebCore::IDBClient::IDBConnectionToServer::didAbortTransaction):
     67        (WebCore::IDBClient::IDBConnectionToServer::fireVersionChangeEvent):
     68        (WebCore::IDBClient::IDBConnectionToServer::didFireVersionChangeEvent):
     69        (WebCore::IDBClient::IDBConnectionToServer::didStartTransaction):
     70        (WebCore::IDBClient::IDBConnectionToServer::notifyOpenDBRequestBlocked):
     71        (WebCore::IDBClient::IDBConnectionToServer::databaseConnectionClosed):
     72        (WebCore::IDBClient::IDBConnectionToServer::registerDatabaseConnection): Deleted.
     73        (WebCore::IDBClient::IDBConnectionToServer::unregisterDatabaseConnection): Deleted.
     74        (WebCore::IDBClient::IDBConnectionToServer::hasRecordOfTransaction): Deleted.
     75        * Modules/indexeddb/client/IDBConnectionToServer.h:
     76       
     77        * Modules/indexeddb/shared/IDBRequestData.cpp:
     78        (WebCore::IDBRequestData::IDBRequestData):
     79        * Modules/indexeddb/shared/IDBRequestData.h:
     80       
     81        * Modules/indexeddb/shared/IDBResourceIdentifier.cpp:
     82        (WebCore::IDBResourceIdentifier::IDBResourceIdentifier):
     83        * Modules/indexeddb/shared/IDBResourceIdentifier.h:
     84
    1852016-05-04  Brady Eidson  <beidson@apple.com>
    286

  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.cpp

    r200483 r200485  
    5757    LOG(IndexedDB, "IDBDatabase::IDBDatabase - Creating database %s with version %" PRIu64 " connection %" PRIu64, m_info.name().utf8().data(), m_info.version(), m_databaseConnectionIdentifier);
    5858    suspendIfNeeded();
    59     relaxAdoptionRequirement();
    60     m_connectionProxy->connectionToServer().registerDatabaseConnection(*this);
     59    m_connectionProxy->registerDatabaseConnection(*this);
    6160}
    6261
    … …  
    6463{
    6564    ASSERT(currentThread() == m_originThreadID);
    66     m_connectionProxy->connectionToServer().unregisterDatabaseConnection(*this);
     65    m_connectionProxy->unregisterDatabaseConnection(*this);
    6766}
    6867
    … …  
    263262
    264263    m_closedInServer = true;
    265     m_connectionProxy->connectionToServer().databaseConnectionClosed(*this);
     264    m_connectionProxy->databaseConnectionClosed(*this);
    266265}
    267266

  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabase.h

    r200483 r200485  
    4444class IDBTransactionInfo;
    4545
    46 class IDBDatabase : public RefCounted<IDBDatabase>, public EventTargetWithInlineData, public ActiveDOMObject {
     46class IDBDatabase : public ThreadSafeRefCounted<IDBDatabase>, public EventTargetWithInlineData, public ActiveDOMObject {
    4747public:
    4848    static Ref<IDBDatabase> create(ScriptExecutionContext&, IDBClient::IDBConnectionProxy&, const IDBResultData&);
    … …  
    6565    EventTargetInterface eventTargetInterface() const final { return IDBDatabaseEventTargetInterfaceType; }
    6666    ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
    67     void refEventTarget() final { RefCounted<IDBDatabase>::ref(); }
    68     void derefEventTarget() final { RefCounted<IDBDatabase>::deref(); }
     67    void refEventTarget() final { ThreadSafeRefCounted<IDBDatabase>::ref(); }
     68    void derefEventTarget() final { ThreadSafeRefCounted<IDBDatabase>::deref(); }
    6969
    70     using RefCounted<IDBDatabase>::ref;
    71     using RefCounted<IDBDatabase>::deref;
     70    using ThreadSafeRefCounted<IDBDatabase>::ref;
     71    using ThreadSafeRefCounted<IDBDatabase>::deref;
    7272
    7373    const char* activeDOMObjectName() const final;

  • trunk/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp

    r200483 r200485  
    119119
    120120    if (m_transaction && m_transaction->isVersionChange() && (event.type() == eventNames().errorEvent || event.type() == eventNames().successEvent))
    121         m_transaction->database().serverConnection().didFinishHandlingVersionChangeTransaction(*m_transaction);
     121        m_transaction->database().connectionProxy().didFinishHandlingVersionChangeTransaction(*m_transaction);
    122122
    123123    return result;

  • trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp

    r200483 r200485  
    134134    ASSERT(currentThread() == m_database->originThreadID());
    135135
    136     relaxAdoptionRequirement();
    137 
    138136    if (m_info.mode() == IndexedDB::TransactionMode::VersionChange) {
    139137        ASSERT(m_openDBRequest);
    … …  
    296294    ASSERT(m_transactionOperationQueue.isEmpty());
    297295
    298     serverConnection().abortTransaction(*this);
     296    m_database->connectionProxy().abortTransaction(*this);
    299297
    300298    ASSERT(m_transactionOperationMap.contains(operation.identifier()));
    … …  
    433431    ASSERT(currentThread() == m_database->originThreadID());
    434432
    435     serverConnection().commitTransaction(*this);
     433    m_database->connectionProxy().commitTransaction(*this);
    436434
    437435    ASSERT(m_transactionOperationMap.contains(operation.identifier()));
    … …  
    10451043    ASSERT(currentThread() == m_database->originThreadID());
    10461044
    1047     serverConnection().establishTransaction(*this);
     1045    m_database->connectionProxy().establishTransaction(*this);
    10481046}
    10491047

  • trunk/Source/WebCore/Modules/indexeddb/IDBTransaction.h

    r199843 r200485  
    5959}
    6060
    61 class IDBTransaction : public RefCounted<IDBTransaction>, public EventTargetWithInlineData, private ActiveDOMObject {
     61class IDBTransaction : public ThreadSafeRefCounted<IDBTransaction>, public EventTargetWithInlineData, private ActiveDOMObject {
    6262public:
    6363    static const AtomicString& modeReadOnly();
    … …  
    8484    EventTargetInterface eventTargetInterface() const final { return IDBTransactionEventTargetInterfaceType; }
    8585    ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
    86     void refEventTarget() final { RefCounted::ref(); }
    87     void derefEventTarget() final { RefCounted::deref(); }
     86    void refEventTarget() final { ThreadSafeRefCounted::ref(); }
     87    void derefEventTarget() final { ThreadSafeRefCounted::deref(); }
    8888    using EventTarget::dispatchEvent;
    8989    bool dispatchEvent(Event&) final;
    9090
    91     using RefCounted<IDBTransaction>::ref;
    92     using RefCounted<IDBTransaction>::deref;
     91    using ThreadSafeRefCounted<IDBTransaction>::ref;
     92    using ThreadSafeRefCounted<IDBTransaction>::deref;
    9393
    9494    const char* activeDOMObjectName() const final;

  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.cpp

    r200163 r200485  
    2929#if ENABLE(INDEXED_DATABASE)
    3030
     31#include "IDBDatabase.h"
    3132#include "IDBOpenDBRequest.h"
     33#include "IDBRequestData.h"
     34#include "IDBResultData.h"
    3235#include <wtf/MainThread.h>
    3336
    … …  
    6770        return nullptr;
    6871
    69     auto request = IDBOpenDBRequest::createOpenRequest(context, *this, databaseIdentifier, version);
    70     m_connectionToServer.openDatabase(request.get());
    71     return WTFMove(request);
     72    RefPtr<IDBOpenDBRequest> request;
     73    {
     74        Locker<Lock> locker(m_openDBRequestMapLock);
     75
     76        request = IDBOpenDBRequest::createOpenRequest(context, *this, databaseIdentifier, version);
     77        ASSERT(!m_openDBRequestMap.contains(request->resourceIdentifier()));
     78        m_openDBRequestMap.set(request->resourceIdentifier(), request.get());
     79    }
     80
     81    IDBRequestData requestData(*this, *request);
     82
     83    // FIXME: For workers, marshall this to the main thread if necessary.
     84    m_connectionToServer.openDatabase(requestData);
     85
     86    return request;
    7287}
    7388
    … …  
    7893        return nullptr;
    7994
    80     auto request = IDBOpenDBRequest::createDeleteRequest(context, *this, databaseIdentifier);
    81     m_connectionToServer.deleteDatabase(request.get());
    82     return WTFMove(request);
     95    RefPtr<IDBOpenDBRequest> request;
     96    {
     97        Locker<Lock> locker(m_openDBRequestMapLock);
     98
     99        request = IDBOpenDBRequest::createDeleteRequest(context, *this, databaseIdentifier);
     100        ASSERT(!m_openDBRequestMap.contains(request->resourceIdentifier()));
     101        m_openDBRequestMap.set(request->resourceIdentifier(), request.get());
     102    }
     103
     104    IDBRequestData requestData(*this, *request);
     105
     106    // FIXME: For workers, marshall this to the main thread if necessary.
     107    m_connectionToServer.deleteDatabase(requestData);
     108
     109    return request;
     110}
     111
     112void IDBConnectionProxy::didOpenDatabase(const IDBResultData& resultData)
     113{
     114    completeOpenDBRequest(resultData);
     115}
     116
     117void IDBConnectionProxy::didDeleteDatabase(const IDBResultData& resultData)
     118{
     119    completeOpenDBRequest(resultData);
     120}
     121
     122void IDBConnectionProxy::completeOpenDBRequest(const IDBResultData& resultData)
     123{
     124    ASSERT(isMainThread());
     125
     126    RefPtr<IDBOpenDBRequest> request;
     127    {
     128        Locker<Lock> locker(m_openDBRequestMapLock);
     129        request = m_openDBRequestMap.get(resultData.requestIdentifier());
     130        ASSERT(request);
     131    }
     132
     133    request->requestCompleted(resultData);
     134}
     135
     136void IDBConnectionProxy::fireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
     137{
     138    ASSERT(isMainThread());
     139
     140    RefPtr<IDBDatabase> database;
     141    {
     142        Locker<Lock> locker(m_databaseConnectionMapLock);
     143        database = m_databaseConnectionMap.get(databaseConnectionIdentifier);
     144    }
     145
     146    if (!database)
     147        return;
     148
     149    database->fireVersionChangeEvent(requestIdentifier, requestedVersion);
     150}
     151
     152void IDBConnectionProxy::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier)
     153{
     154    // FIXME: Handle Workers
     155    if (!isMainThread())
     156        return;
     157
     158    m_connectionToServer.didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
     159}
     160
     161void IDBConnectionProxy::notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion)
     162{
     163    ASSERT(isMainThread());
     164
     165    RefPtr<IDBOpenDBRequest> request;
     166    {
     167        Locker<Lock> locker(m_openDBRequestMapLock);
     168        request = m_openDBRequestMap.get(requestIdentifier);
     169    }
     170
     171    ASSERT(request);
     172
     173    request->requestBlocked(oldVersion, newVersion);
     174}
     175
     176void IDBConnectionProxy::establishTransaction(IDBTransaction& transaction)
     177{
     178    {
     179        Locker<Lock> locker(m_transactionMapLock);
     180        ASSERT(!hasRecordOfTransaction(transaction));
     181        m_pendingTransactions.set(transaction.info().identifier(), &transaction);
     182    }
     183
     184    // FIXME: Handle Workers
     185    if (!isMainThread())
     186        return;
     187
     188    m_connectionToServer.establishTransaction(transaction.database().databaseConnectionIdentifier(), transaction.info());
     189}
     190
     191void IDBConnectionProxy::didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
     192{
     193    RefPtr<IDBTransaction> transaction;
     194    {
     195        Locker<Lock> locker(m_transactionMapLock);
     196        transaction = m_pendingTransactions.take(transactionIdentifier);
     197    }
     198
     199    ASSERT(transaction);
     200
     201    // FIXME: Handle hopping to the Worker thread here if necessary.
     202
     203    transaction->didStart(error);
     204}
     205
     206void IDBConnectionProxy::commitTransaction(IDBTransaction& transaction)
     207{
     208    {
     209        Locker<Lock> locker(m_transactionMapLock);
     210        ASSERT(!m_committingTransactions.contains(transaction.info().identifier()));
     211        m_committingTransactions.set(transaction.info().identifier(), &transaction);
     212    }
     213
     214    // FIXME: Handle Workers
     215    if (!isMainThread())
     216        return;
     217
     218    m_connectionToServer.commitTransaction(transaction.info().identifier());
     219}
     220
     221void IDBConnectionProxy::didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
     222{
     223    RefPtr<IDBTransaction> transaction;
     224    {
     225        Locker<Lock> locker(m_transactionMapLock);
     226        transaction = m_committingTransactions.take(transactionIdentifier);
     227    }
     228
     229    ASSERT(transaction);
     230
     231    // FIXME: Handle hopping to the Worker thread here if necessary.
     232
     233    transaction->didCommit(error);
     234}
     235
     236void IDBConnectionProxy::abortTransaction(IDBTransaction& transaction)
     237{
     238    {
     239        Locker<Lock> locker(m_transactionMapLock);
     240        ASSERT(!m_abortingTransactions.contains(transaction.info().identifier()));
     241        m_abortingTransactions.set(transaction.info().identifier(), &transaction);
     242    }
     243
     244    // FIXME: Handle Workers
     245    if (!isMainThread())
     246        return;
     247
     248    m_connectionToServer.abortTransaction(transaction.info().identifier());
     249}
     250
     251void IDBConnectionProxy::didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError& error)
     252{
     253    RefPtr<IDBTransaction> transaction;
     254    {
     255        Locker<Lock> locker(m_transactionMapLock);
     256        transaction = m_abortingTransactions.take(transactionIdentifier);
     257    }
     258
     259    ASSERT(transaction);
     260
     261    // FIXME: Handle hopping to the Worker thread here if necessary.
     262
     263    transaction->didAbort(error);
     264}
     265
     266bool IDBConnectionProxy::hasRecordOfTransaction(const IDBTransaction& transaction) const
     267{
     268    ASSERT(m_transactionMapLock.isLocked());
     269
     270    auto identifier = transaction.info().identifier();
     271    return m_pendingTransactions.contains(identifier) || m_committingTransactions.contains(identifier) || m_abortingTransactions.contains(identifier);
     272}
     273
     274void IDBConnectionProxy::didFinishHandlingVersionChangeTransaction(IDBTransaction& transaction)
     275{
     276    // FIXME: Handle Workers
     277    if (!isMainThread())
     278        return;
     279
     280    m_connectionToServer.didFinishHandlingVersionChangeTransaction(transaction.info().identifier());
     281}
     282
     283void IDBConnectionProxy::databaseConnectionClosed(IDBDatabase& database)
     284{
     285    // FIXME: Handle Workers
     286    if (!isMainThread())
     287        return;
     288
     289    m_connectionToServer.databaseConnectionClosed(database.databaseConnectionIdentifier());
    83290}
    84291
    … …  
    91298}
    92299
     300void IDBConnectionProxy::registerDatabaseConnection(IDBDatabase& database)
     301{
     302    Locker<Lock> locker(m_databaseConnectionMapLock);
     303
     304    ASSERT(!m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
     305    m_databaseConnectionMap.set(database.databaseConnectionIdentifier(), &database);
     306}
     307
     308void IDBConnectionProxy::unregisterDatabaseConnection(IDBDatabase& database)
     309{
     310    Locker<Lock> locker(m_databaseConnectionMapLock);
     311
     312    ASSERT(m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
     313    ASSERT(m_databaseConnectionMap.get(database.databaseConnectionIdentifier()) == &database);
     314    m_databaseConnectionMap.remove(database.databaseConnectionIdentifier());
     315}
    93316
    94317} // namesapce IDBClient

  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionProxy.h

    r200163 r200485  
    2929
    3030#include "IDBConnectionToServer.h"
     31#include "IDBResourceIdentifier.h"
    3132#include <functional>
     33#include <wtf/HashMap.h>
    3234#include <wtf/RefPtr.h>
    3335#include <wtf/Vector.h>
    … …  
    3638namespace WebCore {
    3739
     40class IDBDatabase;
    3841class IDBDatabaseIdentifier;
     42class IDBError;
    3943class IDBOpenDBRequest;
     44class IDBResultData;
     45class IDBTransaction;
    4046class ScriptExecutionContext;
    4147class SecurityOrigin;
    … …  
    5056
    5157    RefPtr<IDBOpenDBRequest> openDatabase(ScriptExecutionContext&, const IDBDatabaseIdentifier&, uint64_t version);
     58    void didOpenDatabase(const IDBResultData&);
     59
    5260    RefPtr<IDBOpenDBRequest> deleteDatabase(ScriptExecutionContext&, const IDBDatabaseIdentifier&);
     61    void didDeleteDatabase(const IDBResultData&);
     62
     63    void fireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion);
     64    void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier);
     65
     66    void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
     67
     68    void establishTransaction(IDBTransaction&);
     69    void commitTransaction(IDBTransaction&);
     70    void abortTransaction(IDBTransaction&);
     71
     72    void didStartTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
     73    void didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
     74    void didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
     75
     76    void didFinishHandlingVersionChangeTransaction(IDBTransaction&);
     77    void databaseConnectionClosed(IDBDatabase&);
    5378
    5479    uint64_t serverConnectionIdentifier() const { return m_serverConnectionIdentifier; }
    … …  
    6489    void getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, std::function<void (const Vector<String>&)>);
    6590
     91    void registerDatabaseConnection(IDBDatabase&);
     92    void unregisterDatabaseConnection(IDBDatabase&);
     93
    6694private:
     95    void completeOpenDBRequest(const IDBResultData&);
     96    bool hasRecordOfTransaction(const IDBTransaction&) const;
     97
    6798    IDBConnectionToServer& m_connectionToServer;
    6899    uint64_t m_serverConnectionIdentifier;
     100
     101    HashMap<uint64_t, IDBDatabase*> m_databaseConnectionMap;
     102    Lock m_databaseConnectionMapLock;
     103
     104    HashMap<IDBResourceIdentifier, RefPtr<IDBOpenDBRequest>> m_openDBRequestMap;
     105    Lock m_openDBRequestMapLock;
     106
     107    HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_pendingTransactions;
     108    HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_committingTransactions;
     109    HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_abortingTransactions;
     110    Lock m_transactionMapLock;
    69111};
    70112

  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.cpp

    r200163 r200485  
    3737#include "Logging.h"
    3838#include "TransactionOperation.h"
     39#include <wtf/MainThread.h>
    3940
    4041namespace WebCore {
    … …  
    6364}
    6465
    65 void IDBConnectionToServer::deleteDatabase(IDBOpenDBRequest& request)
     66void IDBConnectionToServer::deleteDatabase(const IDBRequestData& request)
    6667{
    6768    LOG(IndexedDB, "IDBConnectionToServer::deleteDatabase - %s", request.databaseIdentifier().debugString().utf8().data());
    68 
    69     ASSERT(!m_openDBRequestMap.contains(request.resourceIdentifier()));
    70     m_openDBRequestMap.set(request.resourceIdentifier(), &request);
    71 
    72     IDBRequestData requestData(*this, request);
    73     m_delegate->deleteDatabase(requestData);
     69    m_delegate->deleteDatabase(request);
    7470}
    7571
    … …  
    7773{
    7874    LOG(IndexedDB, "IDBConnectionToServer::didDeleteDatabase");
    79 
    80     auto request = m_openDBRequestMap.take(resultData.requestIdentifier());
    81     ASSERT(request);
    82 
    83     request->requestCompleted(resultData);
    84 }
    85 
    86 void IDBConnectionToServer::openDatabase(IDBOpenDBRequest& request)
    87 {
    88     LOG(IndexedDB, "IDBConnectionToServer::openDatabase - %s (%" PRIu64 ")", request.databaseIdentifier().debugString().utf8().data(), request.version());
    89 
    90     ASSERT(!m_openDBRequestMap.contains(request.resourceIdentifier()));
    91     m_openDBRequestMap.set(request.resourceIdentifier(), &request);
    92    
    93     IDBRequestData requestData(*this, request);
    94     m_delegate->openDatabase(requestData);
     75    m_proxy->didDeleteDatabase(resultData);
     76}
     77
     78void IDBConnectionToServer::openDatabase(const IDBRequestData& request)
     79{
     80    LOG(IndexedDB, "IDBConnectionToServer::openDatabase - %s (%" PRIu64 ")", request.databaseIdentifier().debugString().utf8().data(), request.requestedVersion());
     81    m_delegate->openDatabase(request);
    9582}
    9683
    … …  
    9885{
    9986    LOG(IndexedDB, "IDBConnectionToServer::didOpenDatabase");
    100 
    101     auto request = m_openDBRequestMap.take(resultData.requestIdentifier());
    102     ASSERT(request);
    103 
    104     request->requestCompleted(resultData);
     87    m_proxy->didOpenDatabase(resultData);
    10588}
    10689
    … …  
    270253}
    271254
    272 void IDBConnectionToServer::establishTransaction(IDBTransaction& transaction)
     255void IDBConnectionToServer::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info)
    273256{
    274257    LOG(IndexedDB, "IDBConnectionToServer::establishTransaction");
    275 
    276     ASSERT(!hasRecordOfTransaction(transaction));
    277     m_pendingTransactions.set(transaction.info().identifier(), &transaction);
    278 
    279     m_delegate->establishTransaction(transaction.database().databaseConnectionIdentifier(), transaction.info());
    280 }
    281 
    282 void IDBConnectionToServer::commitTransaction(IDBTransaction& transaction)
     258    ASSERT(isMainThread());
     259
     260    m_delegate->establishTransaction(databaseConnectionIdentifier, info);
     261}
     262
     263void IDBConnectionToServer::commitTransaction(const IDBResourceIdentifier& transactionIdentifier)
    283264{
    284265    LOG(IndexedDB, "IDBConnectionToServer::commitTransaction");
    285     ASSERT(!m_committingTransactions.contains(transaction.info().identifier()));
    286     m_committingTransactions.set(transaction.info().identifier(), &transaction);
    287 
    288     auto identifier = transaction.info().identifier();
    289     m_delegate->commitTransaction(identifier);
     266    ASSERT(isMainThread());
     267
     268    m_delegate->commitTransaction(transactionIdentifier);
    290269}
    291270
    … …  
    293272{
    294273    LOG(IndexedDB, "IDBConnectionToServer::didCommitTransaction");
    295 
    296     auto transaction = m_committingTransactions.take(transactionIdentifier);
    297     ASSERT(transaction);
    298 
    299     transaction->didCommit(error);
    300 }
    301 
    302 void IDBConnectionToServer::didFinishHandlingVersionChangeTransaction(IDBTransaction& transaction)
     274    ASSERT(isMainThread());
     275
     276    m_proxy->didCommitTransaction(transactionIdentifier, error);
     277}
     278
     279void IDBConnectionToServer::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)
    303280{
    304281    LOG(IndexedDB, "IDBConnectionToServer::didFinishHandlingVersionChangeTransaction");
    305     auto identifier = transaction.info().identifier();
    306     m_delegate->didFinishHandlingVersionChangeTransaction(identifier);
    307 }
    308 
    309 void IDBConnectionToServer::abortTransaction(IDBTransaction& transaction)
     282    ASSERT(isMainThread());
     283
     284    m_delegate->didFinishHandlingVersionChangeTransaction(transactionIdentifier);
     285}
     286
     287void IDBConnectionToServer::abortTransaction(const IDBResourceIdentifier& transactionIdentifier)
    310288{
    311289    LOG(IndexedDB, "IDBConnectionToServer::abortTransaction");
    312     ASSERT(!m_abortingTransactions.contains(transaction.info().identifier()));
    313     m_abortingTransactions.set(transaction.info().identifier(), &transaction);
    314 
    315     auto identifier = transaction.info().identifier();
    316     m_delegate->abortTransaction(identifier);
     290    ASSERT(isMainThread());
     291
     292    m_delegate->abortTransaction(transactionIdentifier);
    317293}
    318294
    … …  
    320296{
    321297    LOG(IndexedDB, "IDBConnectionToServer::didAbortTransaction");
    322 
    323     auto transaction = m_abortingTransactions.take(transactionIdentifier);
    324     ASSERT(transaction);
    325 
    326     transaction->didAbort(error);
     298    ASSERT(isMainThread());
     299
     300    m_proxy->didAbortTransaction(transactionIdentifier, error);
    327301}
    328302
    … …  
    330304{
    331305    LOG(IndexedDB, "IDBConnectionToServer::fireVersionChangeEvent");
    332 
    333     auto connection = m_databaseConnectionMap.get(databaseConnectionIdentifier);
    334     if (!connection)
    335         return;
    336 
    337     connection->fireVersionChangeEvent(requestIdentifier, requestedVersion);
     306    ASSERT(isMainThread());
     307
     308    m_proxy->fireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier, requestedVersion);
    338309}
    339310
    … …  
    341312{
    342313    LOG(IndexedDB, "IDBConnectionToServer::didFireVersionChangeEvent");
     314    ASSERT(isMainThread());
    343315
    344316    m_delegate->didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
    … …  
    348320{
    349321    LOG(IndexedDB, "IDBConnectionToServer::didStartTransaction");
    350 
    351     auto transaction = m_pendingTransactions.take(transactionIdentifier);
    352     ASSERT(transaction);
    353 
    354     transaction->didStart(error);
     322    ASSERT(isMainThread());
     323
     324    m_proxy->didStartTransaction(transactionIdentifier, error);
    355325}
    356326
    … …  
    358328{
    359329    LOG(IndexedDB, "IDBConnectionToServer::didStartTransaction");
    360 
    361     auto openDBRequest = m_openDBRequestMap.get(requestIdentifier);
    362     ASSERT(openDBRequest);
    363 
    364     openDBRequest->requestBlocked(oldVersion, newVersion);
    365 }
    366 
    367 void IDBConnectionToServer::databaseConnectionClosed(IDBDatabase& database)
     330    ASSERT(isMainThread());
     331
     332    m_proxy->notifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion);
     333}
     334
     335void IDBConnectionToServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)
    368336{
    369337    LOG(IndexedDB, "IDBConnectionToServer::databaseConnectionClosed");
    370 
    371     m_delegate->databaseConnectionClosed(database.databaseConnectionIdentifier());
     338    ASSERT(isMainThread());
     339
     340    m_delegate->databaseConnectionClosed(databaseConnectionIdentifier);
    372341}
    373342
    … …  
    377346
    378347    m_delegate->abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
    379 }
    380 
    381 void IDBConnectionToServer::registerDatabaseConnection(IDBDatabase& database)
    382 {
    383     ASSERT(!m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
    384     m_databaseConnectionMap.set(database.databaseConnectionIdentifier(), &database);
    385 }
    386 
    387 void IDBConnectionToServer::unregisterDatabaseConnection(IDBDatabase& database)
    388 {
    389     ASSERT(m_databaseConnectionMap.contains(database.databaseConnectionIdentifier()));
    390     ASSERT(m_databaseConnectionMap.get(database.databaseConnectionIdentifier()) == &database);
    391     m_databaseConnectionMap.remove(database.databaseConnectionIdentifier());
    392348}
    393349
    … …  
    406362}
    407363
    408 bool IDBConnectionToServer::hasRecordOfTransaction(const IDBTransaction& transaction) const
    409 {
    410     auto identifier = transaction.info().identifier();
    411     return m_pendingTransactions.contains(identifier) || m_committingTransactions.contains(identifier) || m_abortingTransactions.contains(identifier);
    412 }
    413 
    414364void IDBConnectionToServer::getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, std::function<void (const Vector<String>&)> callback)
    415365{

  • trunk/Source/WebCore/Modules/indexeddb/client/IDBConnectionToServer.h

    r200163 r200485  
    4343class IDBError;
    4444class IDBObjectStoreInfo;
    45 class IDBOpenDBRequest;
    4645class IDBResultData;
    47 class IDBTransaction;
    4846class IDBValue;
    4947
    … …  
    6058    IDBConnectionProxy& proxy();
    6159
    62     void deleteDatabase(IDBOpenDBRequest&);
     60    void deleteDatabase(const IDBRequestData&);
    6361    WEBCORE_EXPORT void didDeleteDatabase(const IDBResultData&);
    6462
    65     void openDatabase(IDBOpenDBRequest&);
     63    void openDatabase(const IDBRequestData&);
    6664    WEBCORE_EXPORT void didOpenDatabase(const IDBResultData&);
    6765
    … …  
    9997    WEBCORE_EXPORT void didIterateCursor(const IDBResultData&);
    10098
    101     void commitTransaction(IDBTransaction&);
     99    void commitTransaction(const IDBResourceIdentifier& transactionIdentifier);
    102100    WEBCORE_EXPORT void didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
    103101
    104     void didFinishHandlingVersionChangeTransaction(IDBTransaction&);
     102    void didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier&);
    105103
    106     void abortTransaction(IDBTransaction&);
     104    void abortTransaction(const IDBResourceIdentifier& transactionIdentifier);
    107105    WEBCORE_EXPORT void didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);
    108106
    … …  
    113111    WEBCORE_EXPORT void notifyOpenDBRequestBlocked(const IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion);
    114112
    115     void establishTransaction(IDBTransaction&);
     113    void establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo&);
    116114
    117     void databaseConnectionClosed(IDBDatabase&);
     115    void databaseConnectionClosed(uint64_t databaseConnectionIdentifier);
    118116
    119117    // To be used when an IDBOpenDBRequest gets a new database connection, optionally with a
    120118    // versionchange transaction, but the page is already torn down.
    121119    void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier);
    122    
    123     void registerDatabaseConnection(IDBDatabase&);
    124     void unregisterDatabaseConnection(IDBDatabase&);
    125120
    126121    void getAllDatabaseNames(const SecurityOrigin& mainFrameOrigin, const SecurityOrigin& openingOrigin, std::function<void (const Vector<String>&)>);
    … …  
    133128    void completeOperation(const IDBResultData&);
    134129
    135     bool hasRecordOfTransaction(const IDBTransaction&) const;
    136 
    137130    Ref<IDBConnectionToServerDelegate> m_delegate;
    138131
    139     HashMap<IDBResourceIdentifier, RefPtr<IDBOpenDBRequest>> m_openDBRequestMap;
    140     HashMap<uint64_t, IDBDatabase*> m_databaseConnectionMap;
    141     HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_pendingTransactions;
    142     HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_committingTransactions;
    143     HashMap<IDBResourceIdentifier, RefPtr<IDBTransaction>> m_abortingTransactions;
    144132    HashMap<IDBResourceIdentifier, RefPtr<TransactionOperation>> m_activeOperations;
    145133

  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.cpp

    r200484 r200485  
    3939}
    4040
    41 IDBRequestData::IDBRequestData(const IDBClient::IDBConnectionToServer& connection, const IDBOpenDBRequest& request)
    42     : m_serverConnectionIdentifier(connection.identifier())
    43     , m_requestIdentifier(std::make_unique<IDBResourceIdentifier>(connection, request))
     41IDBRequestData::IDBRequestData(const IDBClient::IDBConnectionProxy& connectionProxy, const IDBOpenDBRequest& request)
     42    : m_serverConnectionIdentifier(connectionProxy.serverConnectionIdentifier())
     43    , m_requestIdentifier(std::make_unique<IDBResourceIdentifier>(connectionProxy, request))
    4444    , m_databaseIdentifier(request.databaseIdentifier())
    4545    , m_requestedVersion(request.version())

  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBRequestData.h

    r200484 r200485  
    4343
    4444namespace IDBClient {
    45 class IDBConnectionToServer;
     45class IDBConnectionProxy;
    4646class TransactionOperation;
    4747}
    … …  
    4949class IDBRequestData {
    5050public:
    51     IDBRequestData(const IDBClient::IDBConnectionToServer&, const IDBOpenDBRequest&);
     51    IDBRequestData(const IDBClient::IDBConnectionProxy&, const IDBOpenDBRequest&);
    5252    explicit IDBRequestData(IDBClient::TransactionOperation&);
    5353    IDBRequestData(const IDBRequestData&);

  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.cpp

    r199804 r200485  
    7373}
    7474
    75 IDBResourceIdentifier::IDBResourceIdentifier(const IDBClient::IDBConnectionToServer& connection, const IDBRequest& request)
    76     : m_idbConnectionIdentifier(connection.identifier())
     75IDBResourceIdentifier::IDBResourceIdentifier(const IDBClient::IDBConnectionProxy& connectionProxy, const IDBRequest& request)
     76    : m_idbConnectionIdentifier(connectionProxy.serverConnectionIdentifier())
    7777    , m_resourceNumber(request.resourceIdentifier().m_resourceNumber)
    7878{

  • trunk/Source/WebCore/Modules/indexeddb/shared/IDBResourceIdentifier.h

    r199804 r200485  
    3535
    3636namespace IDBClient {
     37class IDBConnectionProxy;
    3738class IDBConnectionToServer;
    3839}
    … …  
    4546public:
    4647    explicit IDBResourceIdentifier(const IDBClient::IDBConnectionToServer&);
    47     IDBResourceIdentifier(const IDBClient::IDBConnectionToServer&, const IDBRequest&);
     48    IDBResourceIdentifier(const IDBClient::IDBConnectionProxy&, const IDBRequest&);
    4849    explicit IDBResourceIdentifier(const IDBServer::IDBConnectionToClient&);
    4950
Note: See TracChangeset for help on using the changeset viewer.