Changeset 200503 in webkit


Ignore:
Timestamp:
May 5, 2016 7:33:20 PM (8 years ago)
Author:
beidson@apple.com
Message:

Modern IDB (Workers): Get everything to the right threads.
​https://bugs.webkit.org/show_bug.cgi?id=157398

Reviewed by Alex Christensen.

Source/WebCore:

No new tests (No current change in behavior, will be tested as bug 149953 is resolved, enabling IDB in workers).

  • dom/ScriptExecutionContext.h:

(WebCore::ScriptExecutionContext::postCrossThreadTask): Add a helper to post a CrossThreadTask to a context.

  • Modules/indexeddb/client/IDBConnectionProxy.cpp:

(WebCore::IDBClient::performCallbackOnCorrectThread): Helper to perform an IDB callback on either the main thread

or Worker thread as necessary.

(WebCore::IDBClient::IDBConnectionProxy::openDatabase):
(WebCore::IDBClient::IDBConnectionProxy::deleteDatabase):
(WebCore::IDBClient::IDBConnectionProxy::completeOpenDBRequest):
(WebCore::IDBClient::IDBConnectionProxy::createObjectStore):
(WebCore::IDBClient::IDBConnectionProxy::deleteObjectStore):
(WebCore::IDBClient::IDBConnectionProxy::clearObjectStore):
(WebCore::IDBClient::IDBConnectionProxy::createIndex):
(WebCore::IDBClient::IDBConnectionProxy::deleteIndex):
(WebCore::IDBClient::IDBConnectionProxy::putOrAdd):
(WebCore::IDBClient::IDBConnectionProxy::getRecord):
(WebCore::IDBClient::IDBConnectionProxy::getCount):
(WebCore::IDBClient::IDBConnectionProxy::deleteRecord):
(WebCore::IDBClient::IDBConnectionProxy::openCursor):
(WebCore::IDBClient::IDBConnectionProxy::iterateCursor):
(WebCore::IDBClient::IDBConnectionProxy::completeOperation):
(WebCore::IDBClient::IDBConnectionProxy::abortOpenAndUpgradeNeeded):
(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::didFinishHandlingVersionChangeTransaction):
(WebCore::IDBClient::IDBConnectionProxy::databaseConnectionClosed):
(WebCore::IDBClient::IDBConnectionProxy::scheduleMainThreadTasks):
(WebCore::IDBClient::IDBConnectionProxy::handleMainThreadTasks):

  • Modules/indexeddb/client/IDBConnectionProxy.h:

(WebCore::IDBClient::IDBConnectionProxy::callConnectionOnMainThread): Helper to marshall IDB operations from the

Worker thread to the main thread.

(WebCore::IDBClient::IDBConnectionProxy::postMainThreadTask):

  • Modules/indexeddb/IDBTransaction.cpp:

(WebCore::IDBTransaction::originThreadID):

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

(WebCore::IDBClient::IDBConnectionToServer::putOrAdd):

  • Modules/indexeddb/client/IDBConnectionToServer.h:
  • Modules/indexeddb/client/IDBConnectionToServerDelegate.h:
  • Modules/indexeddb/client/TransactionOperation.cpp:

(WebCore::IDBClient::TransactionOperation::scriptExecutionContext):

  • Modules/indexeddb/client/TransactionOperation.h:
  • Modules/indexeddb/shared/IDBResourceIdentifier.cpp:

(WebCore::nextClientResourceNumber):

  • Modules/indexeddb/shared/InProcessIDBServer.cpp:

(WebCore::InProcessIDBServer::putOrAdd):

  • Modules/indexeddb/shared/InProcessIDBServer.h:

Source/WebKit2:

  • WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:

(WebKit::WebIDBConnectionToServer::putOrAdd):

  • WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h:
Location:
trunk/Source
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r200501 r200503  
     12016-05-05  Brady Eidson  <beidson@apple.com>
     2
     3        Modern IDB (Workers): Get everything to the right threads.
     4        https://bugs.webkit.org/show_bug.cgi?id=157398
     5
     6        Reviewed by Alex Christensen.
     7
     8        No new tests (No current change in behavior, will be tested as bug 149953 is resolved, enabling IDB in workers).
     9
     10        * dom/ScriptExecutionContext.h:
     11        (WebCore::ScriptExecutionContext::postCrossThreadTask): Add a helper to post a CrossThreadTask to a context.
     12               
     13        * Modules/indexeddb/client/IDBConnectionProxy.cpp:
     14        (WebCore::IDBClient::performCallbackOnCorrectThread): Helper to perform an IDB callback on either the main thread
     15          or Worker thread as necessary.
     16        (WebCore::IDBClient::IDBConnectionProxy::openDatabase):
     17        (WebCore::IDBClient::IDBConnectionProxy::deleteDatabase):
     18        (WebCore::IDBClient::IDBConnectionProxy::completeOpenDBRequest):
     19        (WebCore::IDBClient::IDBConnectionProxy::createObjectStore):
     20        (WebCore::IDBClient::IDBConnectionProxy::deleteObjectStore):
     21        (WebCore::IDBClient::IDBConnectionProxy::clearObjectStore):
     22        (WebCore::IDBClient::IDBConnectionProxy::createIndex):
     23        (WebCore::IDBClient::IDBConnectionProxy::deleteIndex):
     24        (WebCore::IDBClient::IDBConnectionProxy::putOrAdd):
     25        (WebCore::IDBClient::IDBConnectionProxy::getRecord):
     26        (WebCore::IDBClient::IDBConnectionProxy::getCount):
     27        (WebCore::IDBClient::IDBConnectionProxy::deleteRecord):
     28        (WebCore::IDBClient::IDBConnectionProxy::openCursor):
     29        (WebCore::IDBClient::IDBConnectionProxy::iterateCursor):
     30        (WebCore::IDBClient::IDBConnectionProxy::completeOperation):
     31        (WebCore::IDBClient::IDBConnectionProxy::abortOpenAndUpgradeNeeded):
     32        (WebCore::IDBClient::IDBConnectionProxy::fireVersionChangeEvent):
     33        (WebCore::IDBClient::IDBConnectionProxy::didFireVersionChangeEvent):
     34        (WebCore::IDBClient::IDBConnectionProxy::notifyOpenDBRequestBlocked):
     35        (WebCore::IDBClient::IDBConnectionProxy::establishTransaction):
     36        (WebCore::IDBClient::IDBConnectionProxy::didStartTransaction):
     37        (WebCore::IDBClient::IDBConnectionProxy::commitTransaction):
     38        (WebCore::IDBClient::IDBConnectionProxy::didCommitTransaction):
     39        (WebCore::IDBClient::IDBConnectionProxy::abortTransaction):
     40        (WebCore::IDBClient::IDBConnectionProxy::didAbortTransaction):
     41        (WebCore::IDBClient::IDBConnectionProxy::didFinishHandlingVersionChangeTransaction):
     42        (WebCore::IDBClient::IDBConnectionProxy::databaseConnectionClosed):
     43        (WebCore::IDBClient::IDBConnectionProxy::scheduleMainThreadTasks):
     44        (WebCore::IDBClient::IDBConnectionProxy::handleMainThreadTasks):
     45        * Modules/indexeddb/client/IDBConnectionProxy.h:
     46        (WebCore::IDBClient::IDBConnectionProxy::callConnectionOnMainThread): Helper to marshall IDB operations from the
     47          Worker thread to the main thread.
     48        (WebCore::IDBClient::IDBConnectionProxy::postMainThreadTask):
     49
     50        * Modules/indexeddb/IDBTransaction.cpp:
     51        (WebCore::IDBTransaction::originThreadID):
     52        * Modules/indexeddb/IDBTransaction.h:
     53       
     54        * Modules/indexeddb/client/IDBConnectionToServer.cpp:
     55        (WebCore::IDBClient::IDBConnectionToServer::putOrAdd):
     56        * Modules/indexeddb/client/IDBConnectionToServer.h:
     57
     58        * Modules/indexeddb/client/IDBConnectionToServerDelegate.h:
     59
     60        * Modules/indexeddb/client/TransactionOperation.cpp:
     61        (WebCore::IDBClient::TransactionOperation::scriptExecutionContext):
     62        * Modules/indexeddb/client/TransactionOperation.h:
     63
     64        * Modules/indexeddb/shared/IDBResourceIdentifier.cpp:
     65        (WebCore::nextClientResourceNumber):
     66
     67        * Modules/indexeddb/shared/InProcessIDBServer.cpp:
     68        (WebCore::InProcessIDBServer::putOrAdd):
     69        * Modules/indexeddb/shared/InProcessIDBServer.h:
     70
    1712016-05-05  Dean Jackson  <dino@apple.com>
    272

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

    r200495 r200503  
    10651065}
    10661066
     1067ThreadIdentifier IDBTransaction::originThreadID() const
     1068{
     1069    return m_database->originThreadID();
     1070}
     1071
    10671072} // namespace WebCore
    10681073

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

    r200495 r200503  
    144144    IDBClient::IDBConnectionProxy& connectionProxy();
    145145
     146    ThreadIdentifier originThreadID() const;
     147
    146148private:
    147149    IDBTransaction(IDBDatabase&, const IDBTransactionInfo&, IDBOpenDBRequest*);

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

    r200495 r200503  
    2929#if ENABLE(INDEXED_DATABASE)
    3030
     31#include "IDBCursorInfo.h"
    3132#include "IDBDatabase.h"
     33#include "IDBKeyRangeData.h"
    3234#include "IDBOpenDBRequest.h"
    3335#include "IDBRequestData.h"
    3436#include "IDBResultData.h"
     37#include "ScriptExecutionContext.h"
    3538#include "SecurityOrigin.h"
    3639#include <wtf/MainThread.h>
    … …  
    3841namespace WebCore {
    3942namespace IDBClient {
     43
     44template<typename T, typename... Parameters, typename... Arguments>
     45void performCallbackOnCorrectThread(T& object, void (T::*method)(Parameters...), Arguments&&... arguments)
     46{
     47    ASSERT(isMainThread());
     48
     49    if (object.originThreadID() == currentThread()) {
     50        (object.*method)(arguments...);
     51        return;
     52    }
     53
     54    ScriptExecutionContext* context = object.scriptExecutionContext();
     55    if (!context)
     56        return;
     57
     58    context->postCrossThreadTask(object, method, arguments...);
     59}
    4060
    4161IDBConnectionProxy::IDBConnectionProxy(IDBConnectionToServer& connection)
    … …  
    5878RefPtr<IDBOpenDBRequest> IDBConnectionProxy::openDatabase(ScriptExecutionContext& context, const IDBDatabaseIdentifier& databaseIdentifier, uint64_t version)
    5979{
    60     // FIXME: Handle Workers
    61     if (!isMainThread())
    62         return nullptr;
    63 
    6480    RefPtr<IDBOpenDBRequest> request;
    6581    {
    … …  
    7187    }
    7288
    73     IDBRequestData requestData(*this, *request);
    74 
    75     // FIXME: For workers, marshall this to the main thread if necessary.
    76     m_connectionToServer.openDatabase(requestData);
     89    callConnectionOnMainThread(&IDBConnectionToServer::openDatabase, IDBRequestData(*this, *request));
    7790
    7891    return request;
    … …  
    8194RefPtr<IDBOpenDBRequest> IDBConnectionProxy::deleteDatabase(ScriptExecutionContext& context, const IDBDatabaseIdentifier& databaseIdentifier)
    8295{
    83     // FIXME: Handle Workers
    84     if (!isMainThread())
    85         return nullptr;
    86 
    8796    RefPtr<IDBOpenDBRequest> request;
    8897    {
    … …  
    94103    }
    95104
    96     IDBRequestData requestData(*this, *request);
    97 
    98     // FIXME: For workers, marshall this to the main thread if necessary.
    99     m_connectionToServer.deleteDatabase(requestData);
     105    callConnectionOnMainThread(&IDBConnectionToServer::deleteDatabase, IDBRequestData(*this, *request));
    100106
    101107    return request;
    … …  
    119125    {
    120126        Locker<Lock> locker(m_openDBRequestMapLock);
    121         request = m_openDBRequestMap.get(resultData.requestIdentifier());
     127        request = m_openDBRequestMap.take(resultData.requestIdentifier());
    122128        ASSERT(request);
    123129    }
    124130
    125     request->requestCompleted(resultData);
     131    ASSERT(request);
     132
     133    performCallbackOnCorrectThread(*request, &IDBOpenDBRequest::requestCompleted, resultData);
    126134}
    127135
    128136void IDBConnectionProxy::createObjectStore(TransactionOperation& operation, const IDBObjectStoreInfo& info)
    129137{
    130     IDBRequestData requestData(operation);
    131     saveOperation(operation);
    132 
    133     // FIXME: Handle worker thread marshalling.
    134 
    135     m_connectionToServer.createObjectStore(requestData, info);
     138    const IDBRequestData requestData(operation);
     139    saveOperation(operation);
     140
     141    callConnectionOnMainThread(&IDBConnectionToServer::createObjectStore, requestData, info);
    136142}
    137143
    138144void IDBConnectionProxy::deleteObjectStore(TransactionOperation& operation, const String& objectStoreName)
    139145{
    140     IDBRequestData requestData(operation);
    141     saveOperation(operation);
    142 
    143     // FIXME: Handle worker thread marshalling.
    144 
    145     m_connectionToServer.deleteObjectStore(requestData, objectStoreName);
     146    const IDBRequestData requestData(operation);
     147    saveOperation(operation);
     148
     149    callConnectionOnMainThread(&IDBConnectionToServer::deleteObjectStore, requestData, objectStoreName);
    146150}
    147151
    148152void IDBConnectionProxy::clearObjectStore(TransactionOperation& operation, uint64_t objectStoreIdentifier)
    149153{
    150     IDBRequestData requestData(operation);
    151     saveOperation(operation);
    152 
    153     // FIXME: Handle worker thread marshalling.
    154 
    155     m_connectionToServer.clearObjectStore(requestData, objectStoreIdentifier);
     154    const IDBRequestData requestData(operation);
     155    saveOperation(operation);
     156
     157    callConnectionOnMainThread(&IDBConnectionToServer::clearObjectStore, requestData, objectStoreIdentifier);
    156158}
    157159
    158160void IDBConnectionProxy::createIndex(TransactionOperation& operation, const IDBIndexInfo& info)
    159161{
    160     IDBRequestData requestData(operation);
    161     saveOperation(operation);
    162 
    163     // FIXME: Handle worker thread marshalling.
    164 
    165     m_connectionToServer.createIndex(requestData, info);
     162    const IDBRequestData requestData(operation);
     163    saveOperation(operation);
     164
     165    callConnectionOnMainThread(&IDBConnectionToServer::createIndex, requestData, info);
    166166}
    167167
    168168void IDBConnectionProxy::deleteIndex(TransactionOperation& operation, uint64_t objectStoreIdentifier, const String& indexName)
    169169{
    170     IDBRequestData requestData(operation);
    171     saveOperation(operation);
    172 
    173     // FIXME: Handle worker thread marshalling.
    174 
    175     m_connectionToServer.deleteIndex(requestData, objectStoreIdentifier, indexName);
     170    const IDBRequestData requestData(operation);
     171    saveOperation(operation);
     172
     173    callConnectionOnMainThread(&IDBConnectionToServer::deleteIndex, requestData, WTFMove(objectStoreIdentifier), indexName);
    176174}
    177175
    178176void IDBConnectionProxy::putOrAdd(TransactionOperation& operation, IDBKey* key, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode mode)
    179177{
    180     IDBRequestData requestData(operation);
    181     saveOperation(operation);
    182 
    183     // FIXME: Handle worker thread marshalling.
    184 
    185     m_connectionToServer.putOrAdd(requestData, key, value, mode);
     178    const IDBRequestData requestData(operation);
     179    saveOperation(operation);
     180
     181    callConnectionOnMainThread(&IDBConnectionToServer::putOrAdd, requestData, IDBKeyData(key), value, mode);
    186182}
    187183
    188184void IDBConnectionProxy::getRecord(TransactionOperation& operation, const IDBKeyRangeData& keyRange)
    189185{
    190     IDBRequestData requestData(operation);
    191     saveOperation(operation);
    192 
    193     // FIXME: Handle worker thread marshalling.
    194 
    195     m_connectionToServer.getRecord(requestData, keyRange);
     186    const IDBRequestData requestData(operation);
     187    saveOperation(operation);
     188
     189    callConnectionOnMainThread(&IDBConnectionToServer::getRecord, requestData, keyRange);
    196190}
    197191
    198192void IDBConnectionProxy::getCount(TransactionOperation& operation, const IDBKeyRangeData& keyRange)
    199193{
    200     IDBRequestData requestData(operation);
    201     saveOperation(operation);
    202 
    203     // FIXME: Handle worker thread marshalling.
    204 
    205     m_connectionToServer.getCount(requestData, keyRange);
     194    const IDBRequestData requestData(operation);
     195    saveOperation(operation);
     196
     197    callConnectionOnMainThread(&IDBConnectionToServer::getCount, requestData, keyRange);
    206198}
    207199
    208200void IDBConnectionProxy::deleteRecord(TransactionOperation& operation, const IDBKeyRangeData& keyRange)
    209201{
    210     IDBRequestData requestData(operation);
    211     saveOperation(operation);
    212 
    213     // FIXME: Handle worker thread marshalling.
    214 
    215     m_connectionToServer.deleteRecord(requestData, keyRange);
     202    const IDBRequestData requestData(operation);
     203    saveOperation(operation);
     204
     205    callConnectionOnMainThread(&IDBConnectionToServer::deleteRecord, requestData, keyRange);
    216206}
    217207
    218208void IDBConnectionProxy::openCursor(TransactionOperation& operation, const IDBCursorInfo& info)
    219209{
    220     IDBRequestData requestData(operation);
    221     saveOperation(operation);
    222 
    223     // FIXME: Handle worker thread marshalling.
    224 
    225     m_connectionToServer.openCursor(requestData, info);
     210    const IDBRequestData requestData(operation);
     211    saveOperation(operation);
     212
     213    callConnectionOnMainThread(&IDBConnectionToServer::openCursor, requestData, info);
    226214}
    227215
    228216void IDBConnectionProxy::iterateCursor(TransactionOperation& operation, const IDBKeyData& key, unsigned long count)
    229217{
    230     IDBRequestData requestData(operation);
    231     saveOperation(operation);
    232 
    233     // FIXME: Handle worker thread marshalling.
    234 
    235     m_connectionToServer.iterateCursor(requestData, key, count);
     218    const IDBRequestData requestData(operation);
     219    saveOperation(operation);
     220
     221    callConnectionOnMainThread(&IDBConnectionToServer::iterateCursor, requestData, key, count);
    236222}
    237223
    … …  
    254240    ASSERT(operation);
    255241
    256     // FIXME: Handle getting operation->completed() onto the correct thread via the IDBTransaction.
    257    
    258     operation->completed(resultData);
     242    performCallbackOnCorrectThread(*operation, &TransactionOperation::completed, resultData);
    259243}
    260244
    261245void IDBConnectionProxy::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier)
    262246{
    263     // FIXME: Handle workers
    264     if (!isMainThread())
    265         return;
    266 
    267     m_connectionToServer.abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier);
     247    callConnectionOnMainThread(&IDBConnectionToServer::abortOpenAndUpgradeNeeded, databaseConnectionIdentifier, transactionIdentifier);
    268248}
    269249
    270250void IDBConnectionProxy::fireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion)
    271251{
    272     ASSERT(isMainThread());
    273 
    274252    RefPtr<IDBDatabase> database;
    275253    {
    … …  
    281259        return;
    282260
    283     database->fireVersionChangeEvent(requestIdentifier, requestedVersion);
     261    performCallbackOnCorrectThread(*database, &IDBDatabase::fireVersionChangeEvent, requestIdentifier, requestedVersion);
    284262}
    285263
    286264void IDBConnectionProxy::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& requestIdentifier)
    287265{
    288     // FIXME: Handle Workers
    289     if (!isMainThread())
    290         return;
    291 
    292     m_connectionToServer.didFireVersionChangeEvent(databaseConnectionIdentifier, requestIdentifier);
     266    callConnectionOnMainThread(&IDBConnectionToServer::didFireVersionChangeEvent, databaseConnectionIdentifier, requestIdentifier);
    293267}
    294268
    … …  
    305279    ASSERT(request);
    306280
    307     request->requestBlocked(oldVersion, newVersion);
     281    performCallbackOnCorrectThread(*request, &IDBOpenDBRequest::requestBlocked, oldVersion, newVersion);
    308282}
    309283
    … …  
    316290    }
    317291
    318     // FIXME: Handle Workers
    319     if (!isMainThread())
    320         return;
    321 
    322     m_connectionToServer.establishTransaction(transaction.database().databaseConnectionIdentifier(), transaction.info());
     292    callConnectionOnMainThread(&IDBConnectionToServer::establishTransaction, transaction.database().databaseConnectionIdentifier(), transaction.info());
    323293}
    324294
    … …  
    333303    ASSERT(transaction);
    334304
    335     // FIXME: Handle hopping to the Worker thread here if necessary.
    336 
    337     transaction->didStart(error);
     305    performCallbackOnCorrectThread(*transaction, &IDBTransaction::didStart, error);
    338306}
    339307
    … …  
    346314    }
    347315
    348     // FIXME: Handle Workers
    349     if (!isMainThread())
    350         return;
    351 
    352     m_connectionToServer.commitTransaction(transaction.info().identifier());
     316    callConnectionOnMainThread(&IDBConnectionToServer::commitTransaction, transaction.info().identifier());
    353317}
    354318
    … …  
    363327    ASSERT(transaction);
    364328
    365     // FIXME: Handle hopping to the Worker thread here if necessary.
    366 
    367     transaction->didCommit(error);
     329    performCallbackOnCorrectThread(*transaction, &IDBTransaction::didCommit, error);
    368330}
    369331
    … …  
    376338    }
    377339
    378     // FIXME: Handle Workers
    379     if (!isMainThread())
    380         return;
    381 
    382     m_connectionToServer.abortTransaction(transaction.info().identifier());
     340    callConnectionOnMainThread(&IDBConnectionToServer::abortTransaction, transaction.info().identifier());
    383341}
    384342
    … …  
    393351    ASSERT(transaction);
    394352
    395     // FIXME: Handle hopping to the Worker thread here if necessary.
    396 
    397     transaction->didAbort(error);
     353    performCallbackOnCorrectThread(*transaction, &IDBTransaction::didAbort, error);
    398354}
    399355
    … …  
    408364void IDBConnectionProxy::didFinishHandlingVersionChangeTransaction(IDBTransaction& transaction)
    409365{
    410     // FIXME: Handle Workers
    411     if (!isMainThread())
     366    callConnectionOnMainThread(&IDBConnectionToServer::didFinishHandlingVersionChangeTransaction, transaction.info().identifier());
     367}
     368
     369void IDBConnectionProxy::databaseConnectionClosed(IDBDatabase& database)
     370{
     371    callConnectionOnMainThread(&IDBConnectionToServer::databaseConnectionClosed, database.databaseConnectionIdentifier());
     372}
     373
     374void IDBConnectionProxy::scheduleMainThreadTasks()
     375{
     376    Locker<Lock> locker(m_mainThreadTaskLock);
     377    if (m_mainThreadProtector)
    412378        return;
    413379
    414     m_connectionToServer.didFinishHandlingVersionChangeTransaction(transaction.info().identifier());
    415 }
    416 
    417 void IDBConnectionProxy::databaseConnectionClosed(IDBDatabase& database)
    418 {
    419     // FIXME: Handle Workers
    420     if (!isMainThread())
    421         return;
    422 
    423     m_connectionToServer.databaseConnectionClosed(database.databaseConnectionIdentifier());
     380    m_mainThreadProtector = &m_connectionToServer;
     381    callOnMainThread([this] {
     382        handleMainThreadTasks();
     383    });
     384}
     385
     386void IDBConnectionProxy::handleMainThreadTasks()
     387{
     388    RefPtr<IDBConnectionToServer> protector;
     389    {
     390        Locker<Lock> locker(m_mainThreadTaskLock);
     391        ASSERT(m_mainThreadProtector);
     392        protector = WTFMove(m_mainThreadProtector);
     393    }
     394
     395    while (auto task = m_mainThreadQueue.tryGetMessage())
     396        task->performTask();
    424397}
    425398

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

    r200495 r200503  
    2828#if ENABLE(INDEXED_DATABASE)
    2929
     30#include "CrossThreadTask.h"
    3031#include "IDBConnectionToServer.h"
    3132#include "IDBResourceIdentifier.h"
    … …  
    3334#include <functional>
    3435#include <wtf/HashMap.h>
     36#include <wtf/MainThread.h>
     37#include <wtf/MessageQueue.h>
    3538#include <wtf/RefPtr.h>
    3639#include <wtf/Vector.h>
    … …  
    110113    void saveOperation(TransactionOperation&);
    111114
     115    template<typename... Parameters, typename... Arguments>
     116    void callConnectionOnMainThread(void (IDBConnectionToServer::*method)(Parameters...), Arguments&&... arguments)
     117    {
     118        if (isMainThread())
     119            (m_connectionToServer.*method)(arguments...);
     120        else
     121            postMainThreadTask(m_connectionToServer, method, arguments...);
     122    }
     123
     124    template<typename... Arguments>
     125    void postMainThreadTask(Arguments&&... arguments)
     126    {
     127        auto task = createCrossThreadTask(arguments...);
     128        m_mainThreadQueue.append(WTFMove(task));
     129
     130        scheduleMainThreadTasks();
     131    }
     132
     133    void scheduleMainThreadTasks();
     134    void handleMainThreadTasks();
     135
    112136    IDBConnectionToServer& m_connectionToServer;
    113137    uint64_t m_serverConnectionIdentifier;
    … …  
    126150    HashMap<IDBResourceIdentifier, RefPtr<TransactionOperation>> m_activeOperations;
    127151    Lock m_transactionOperationLock;
     152
     153    MessageQueue<CrossThreadTask> m_mainThreadQueue;
     154    Lock m_mainThreadTaskLock;
     155    RefPtr<IDBConnectionToServer> m_mainThreadProtector;
    128156};
    129157

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

    r200495 r200503  
    158158}
    159159
    160 void IDBConnectionToServer::putOrAdd(const IDBRequestData& requestData, IDBKey* key, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
     160void IDBConnectionToServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& key, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
    161161{
    162162    LOG(IndexedDB, "IDBConnectionToServer::putOrAdd");

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

    r200489 r200503  
    7777    WEBCORE_EXPORT void didDeleteIndex(const IDBResultData&);
    7878
    79     void putOrAdd(const IDBRequestData&, IDBKey*, const IDBValue&, const IndexedDB::ObjectStoreOverwriteMode);
     79    void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, const IndexedDB::ObjectStoreOverwriteMode);
    8080    WEBCORE_EXPORT void didPutOrAdd(const IDBResultData&);
    8181

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

    r200352 r200503  
    3535class IDBCursorInfo;
    3636class IDBIndexInfo;
    37 class IDBKey;
    3837class IDBKeyData;
    3938class IDBObjectStoreInfo;
    … …  
    6867    virtual void createIndex(const IDBRequestData&, const IDBIndexInfo&) = 0;
    6968    virtual void deleteIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName) = 0;
    70     virtual void putOrAdd(const IDBRequestData&, IDBKey*, const IDBValue&, const IndexedDB::ObjectStoreOverwriteMode) = 0;
     69    virtual void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, const IndexedDB::ObjectStoreOverwriteMode) = 0;
    7170    virtual void getRecord(const IDBRequestData&, const IDBKeyRangeData&) = 0;
    7271    virtual void getCount(const IDBRequestData&, const IDBKeyRangeData&) = 0;

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

    r198762 r200503  
    4545}
    4646
     47ScriptExecutionContext* TransactionOperation::scriptExecutionContext() const
     48{
     49    return m_transaction->scriptExecutionContext();
     50}
     51
    4752} // namespace IDBClient
    4853} // namespace WebCore

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

    r200495 r200503  
    7474    ThreadIdentifier originThreadID() const { return m_originThreadID; }
    7575
     76    ScriptExecutionContext* scriptExecutionContext() const;
     77
    7678protected:
    7779    TransactionOperation(IDBTransaction& transaction)

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

    r200495 r200503  
    3838static uint64_t nextClientResourceNumber()
    3939{
    40     ASSERT(isMainThread());
    41     static uint64_t currentNumber = 1;
     40    static std::atomic<uint64_t> currentNumber(1);
    4241    return currentNumber += 2;
    4342}

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

    r200352 r200503  
    290290}
    291291
    292 void InProcessIDBServer::putOrAdd(const IDBRequestData& requestData, IDBKey* key, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
    293 {
    294     RefPtr<InProcessIDBServer> self(this);
    295     IDBKeyData keyData(key);
    296 
     292void InProcessIDBServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode overwriteMode)
     293{
     294    RefPtr<InProcessIDBServer> self(this);
    297295    RunLoop::current().dispatch([this, self, requestData, keyData, value, overwriteMode] {
    298296        m_server->putOrAdd(requestData, keyData, value, overwriteMode);

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

    r200352 r200503  
    6666    void createIndex(const IDBRequestData&, const IDBIndexInfo&) final;
    6767    void deleteIndex(const IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName) final;
    68     void putOrAdd(const IDBRequestData&, IDBKey*, const IDBValue&, const IndexedDB::ObjectStoreOverwriteMode) final;
     68    void putOrAdd(const IDBRequestData&, const IDBKeyData&, const IDBValue&, const IndexedDB::ObjectStoreOverwriteMode) final;
    6969    void getRecord(const IDBRequestData&, const IDBKeyRangeData&) final;
    7070    void getCount(const IDBRequestData&, const IDBKeyRangeData&) final;

  • trunk/Source/WebCore/dom/ScriptExecutionContext.h

    r199797 r200503  
    2929
    3030#include "ActiveDOMObject.h"
     31#include "CrossThreadTask.h"
    3132#include "DOMTimer.h"
    3233#include "ResourceRequest.h"
    … …  
    168169    virtual void postTask(Task) = 0; // Executes the task on context's thread asynchronously.
    169170
     171    template<typename... Arguments>
     172    void postCrossThreadTask(Arguments&&... arguments)
     173    {
     174        auto crossThreadTask = createCrossThreadTask(arguments...);
     175        auto* rawTask = crossThreadTask.release();
     176        postTask([=](ScriptExecutionContext&) {
     177            std::unique_ptr<CrossThreadTask> task(rawTask);
     178            task->performTask();
     179        });
     180    }
     181
    170182    // Gets the next id in a circular sequence from 1 to 2^31-1.
    171183    int circularSequentialID();

  • trunk/Source/WebKit2/ChangeLog

    r200500 r200503  
     12016-05-05  Brady Eidson  <beidson@apple.com>
     2
     3        Modern IDB (Workers): Get everything to the right threads.
     4        https://bugs.webkit.org/show_bug.cgi?id=157398
     5
     6        Reviewed by Alex Christensen.
     7
     8        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
     9        (WebKit::WebIDBConnectionToServer::putOrAdd):
     10        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h:
     11
    1122016-05-05  Manuel Rego Casasnovas  <rego@igalia.com>
    213

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

    r200352 r200503  
    132132}
    133133
    134 void WebIDBConnectionToServer::putOrAdd(const IDBRequestData& requestData, IDBKey* key, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode mode)
    135 {
    136     IDBKeyData keyData(key);
     134void WebIDBConnectionToServer::putOrAdd(const IDBRequestData& requestData, const IDBKeyData& keyData, const IDBValue& value, const IndexedDB::ObjectStoreOverwriteMode mode)
     135{
    137136    send(Messages::WebIDBConnectionToClient::PutOrAdd(requestData, keyData, value, static_cast<unsigned>(mode)));
    138137}

  • trunk/Source/WebKit2/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.h

    r200352 r200503  
    5656    void createIndex(const WebCore::IDBRequestData&, const WebCore::IDBIndexInfo&) final;
    5757    void deleteIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName) final;
    58     void putOrAdd(const WebCore::IDBRequestData&, WebCore::IDBKey*, const WebCore::IDBValue&, const WebCore::IndexedDB::ObjectStoreOverwriteMode) final;
     58    void putOrAdd(const WebCore::IDBRequestData&, const WebCore::IDBKeyData&, const WebCore::IDBValue&, const WebCore::IndexedDB::ObjectStoreOverwriteMode) final;
    5959    void getRecord(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&) final;
    6060    void getCount(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&) final;
Note: See TracChangeset for help on using the changeset viewer.