Changeset 129076 in webkit


Ignore:
Timestamp:
Sep 19, 2012 5:12:51 PM (12 years ago)
Author:
jsbell@chromium.org
Message:

IndexedDB: Pending call cleanup
https://bugs.webkit.org/show_bug.cgi?id=96952

Reviewed by Tony Chang.

Replace RefPtr usage with OwnPtr for PendingXXXCalls (since they're never referenced twice)
and replace queue of "second half open" calls with a single item.

No new tests - no functional changes.

  • Modules/indexeddb/IDBDatabaseBackendImpl.cpp:

(WebCore::IDBDatabaseBackendImpl::PendingOpenCall::create):
(WebCore::IDBDatabaseBackendImpl::PendingOpenWithVersionCall::create):
(WebCore::IDBDatabaseBackendImpl::PendingDeleteCall::create):
(WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::create):
(WebCore::IDBDatabaseBackendImpl::setVersion):
(WebCore::IDBDatabaseBackendImpl::transactionFinishedAndAbortFired):
(WebCore::IDBDatabaseBackendImpl::processPendingCalls):
(WebCore::IDBDatabaseBackendImpl::runIntVersionChangeTransaction):
(WebCore::IDBDatabaseBackendImpl::close):

  • Modules/indexeddb/IDBDatabaseBackendImpl.h:

(IDBDatabaseBackendImpl):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r129074 r129076  
     12012-09-19  Joshua Bell  <jsbell@chromium.org>
     2
     3        IndexedDB: Pending call cleanup
     4        https://bugs.webkit.org/show_bug.cgi?id=96952
     5
     6        Reviewed by Tony Chang.
     7
     8        Replace RefPtr usage with OwnPtr for PendingXXXCalls (since they're never referenced twice)
     9        and replace queue of "second half open" calls with a single item.
     10
     11        No new tests - no functional changes.
     12
     13        * Modules/indexeddb/IDBDatabaseBackendImpl.cpp:
     14        (WebCore::IDBDatabaseBackendImpl::PendingOpenCall::create):
     15        (WebCore::IDBDatabaseBackendImpl::PendingOpenWithVersionCall::create):
     16        (WebCore::IDBDatabaseBackendImpl::PendingDeleteCall::create):
     17        (WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::create):
     18        (WebCore::IDBDatabaseBackendImpl::setVersion):
     19        (WebCore::IDBDatabaseBackendImpl::transactionFinishedAndAbortFired):
     20        (WebCore::IDBDatabaseBackendImpl::processPendingCalls):
     21        (WebCore::IDBDatabaseBackendImpl::runIntVersionChangeTransaction):
     22        (WebCore::IDBDatabaseBackendImpl::close):
     23        * Modules/indexeddb/IDBDatabaseBackendImpl.h:
     24        (IDBDatabaseBackendImpl):
     25
    1262012-09-19  Kenichi Ishibashi  <bashi@chromium.org>
    227
  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabaseBackendImpl.cpp

    r129066 r129076  
    4040namespace WebCore {
    4141
    42 class IDBDatabaseBackendImpl::PendingOpenCall : public RefCounted<PendingOpenCall> {
     42class IDBDatabaseBackendImpl::PendingOpenCall {
    4343public:
    44     static PassRefPtr<PendingOpenCall> create(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
    45     {
    46         return adoptRef(new PendingOpenCall(callbacks, databaseCallbacks));
     44    static PassOwnPtr<PendingOpenCall> create(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
     45    {
     46        return adoptPtr(new PendingOpenCall(callbacks, databaseCallbacks));
    4747    }
    4848    PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; }
     
    6060};
    6161
    62 class IDBDatabaseBackendImpl::PendingOpenWithVersionCall : public RefCounted<PendingOpenWithVersionCall> {
     62class IDBDatabaseBackendImpl::PendingOpenWithVersionCall {
    6363public:
    64     static PassRefPtr<PendingOpenWithVersionCall> create(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, int64_t version)
    65     {
    66         return adoptRef(new PendingOpenWithVersionCall(callbacks, databaseCallbacks, version));
     64    static PassOwnPtr<PendingOpenWithVersionCall> create(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, int64_t version)
     65    {
     66        return adoptPtr(new PendingOpenWithVersionCall(callbacks, databaseCallbacks, version));
    6767    }
    6868    PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; }
     
    8282};
    8383
    84 class IDBDatabaseBackendImpl::PendingDeleteCall : public RefCounted<PendingDeleteCall> {
     84class IDBDatabaseBackendImpl::PendingDeleteCall {
    8585public:
    86     static PassRefPtr<PendingDeleteCall> create(PassRefPtr<IDBCallbacks> callbacks)
    87     {
    88         return adoptRef(new PendingDeleteCall(callbacks));
     86    static PassOwnPtr<PendingDeleteCall> create(PassRefPtr<IDBCallbacks> callbacks)
     87    {
     88        return adoptPtr(new PendingDeleteCall(callbacks));
    8989    }
    9090    PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; }
     
    9898};
    9999
    100 class IDBDatabaseBackendImpl::PendingSetVersionCall : public RefCounted<PendingSetVersionCall> {
     100class IDBDatabaseBackendImpl::PendingSetVersionCall {
    101101public:
    102     static PassRefPtr<PendingSetVersionCall> create(const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
    103     {
    104         return adoptRef(new PendingSetVersionCall(version, callbacks, databaseCallbacks));
     102    static PassOwnPtr<PendingSetVersionCall> create(const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
     103    {
     104        return adoptPtr(new PendingSetVersionCall(version, callbacks, databaseCallbacks));
    105105    }
    106106    String version() { return m_version; }
     
    255255    if (connectionCount() > 1) {
    256256        callbacks->onBlocked();
    257         RefPtr<PendingSetVersionCall> pendingSetVersionCall = PendingSetVersionCall::create(version, callbacks, databaseCallbacks);
    258         m_pendingSetVersionCalls.append(pendingSetVersionCall);
     257        OwnPtr<PendingSetVersionCall> pendingSetVersionCall = PendingSetVersionCall::create(version, callbacks, databaseCallbacks);
     258        m_pendingSetVersionCalls.append(pendingSetVersionCall.release());
    259259        return;
    260260    }
    261261    if (m_runningVersionChangeTransaction) {
    262         RefPtr<PendingSetVersionCall> pendingSetVersionCall = PendingSetVersionCall::create(version, callbacks, databaseCallbacks);
    263         m_pendingSetVersionCalls.append(pendingSetVersionCall);
     262        OwnPtr<PendingSetVersionCall> pendingSetVersionCall = PendingSetVersionCall::create(version, callbacks, databaseCallbacks);
     263        m_pendingSetVersionCalls.append(pendingSetVersionCall.release());
    264264        return;
    265265    }
     
    335335        // half" open call waiting for us in processPendingCalls.
    336336        // FIXME: When we no longer support setVersion, assert such a thing.
    337         if (m_pendingSecondHalfOpenWithVersionCalls.size() == 1) {
    338             RefPtr<PendingOpenWithVersionCall> pendingOpenWithVersionCall = m_pendingSecondHalfOpenWithVersionCalls.takeFirst();
    339             pendingOpenWithVersionCall->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::IDB_ABORT_ERR, "Version change transaction was aborted in upgradeneeded event handler."));
     337        if (m_pendingSecondHalfOpenWithVersion) {
     338            m_pendingSecondHalfOpenWithVersion->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::IDB_ABORT_ERR, "Version change transaction was aborted in upgradeneeded event handler."));
     339            m_pendingSecondHalfOpenWithVersion.release();
    340340        }
    341341        processPendingCalls();
     
    358358void IDBDatabaseBackendImpl::processPendingCalls()
    359359{
    360     // FIXME: Change from queue to just a single place holder.
    361     ASSERT(m_pendingSecondHalfOpenWithVersionCalls.size() <= 1);
    362     while (!m_pendingSecondHalfOpenWithVersionCalls.isEmpty()) {
    363         RefPtr<PendingOpenWithVersionCall> pendingOpenWithVersionCall = m_pendingSecondHalfOpenWithVersionCalls.takeFirst();
    364         ASSERT(pendingOpenWithVersionCall->version() == m_intVersion);
     360    if (m_pendingSecondHalfOpenWithVersion) {
     361        ASSERT(m_pendingSecondHalfOpenWithVersion->version() == m_intVersion);
    365362        ASSERT(m_id != InvalidId);
    366         pendingOpenWithVersionCall->callbacks()->onSuccess(this);
     363        m_pendingSecondHalfOpenWithVersion->callbacks()->onSuccess(this);
     364        m_pendingSecondHalfOpenWithVersion.release();
    367365        // Fall through when complete, as pending deletes may be (partially) unblocked.
    368366    }
    369367
    370368    // Pending calls may be requeued or aborted
    371     Deque<RefPtr<PendingSetVersionCall> > pendingSetVersionCalls;
     369    Deque<OwnPtr<PendingSetVersionCall> > pendingSetVersionCalls;
    372370    m_pendingSetVersionCalls.swap(pendingSetVersionCalls);
    373371    while (!pendingSetVersionCalls.isEmpty()) {
    374372        ExceptionCode ec = 0;
    375         RefPtr<PendingSetVersionCall> pendingSetVersionCall = pendingSetVersionCalls.takeFirst();
     373        OwnPtr<PendingSetVersionCall> pendingSetVersionCall = pendingSetVersionCalls.takeFirst();
    376374        setVersion(pendingSetVersionCall->version(), pendingSetVersionCall->callbacks(), pendingSetVersionCall->databaseCallbacks(), ec);
    377375        ASSERT(!ec);
     
    393391
    394392    // Pending calls may be requeued.
    395     Deque<RefPtr<PendingDeleteCall> > pendingDeleteCalls;
     393    Deque<OwnPtr<PendingDeleteCall> > pendingDeleteCalls;
    396394    m_pendingDeleteCalls.swap(pendingDeleteCalls);
    397395    while (!pendingDeleteCalls.isEmpty()) {
    398         RefPtr<PendingDeleteCall> pendingDeleteCall = pendingDeleteCalls.takeFirst();
     396        OwnPtr<PendingDeleteCall> pendingDeleteCall = pendingDeleteCalls.takeFirst();
    399397        deleteDatabase(pendingDeleteCall->callbacks());
    400398    }
     
    404402        return;
    405403
    406     Deque<RefPtr<PendingOpenWithVersionCall> > pendingOpenWithVersionCalls;
     404    Deque<OwnPtr<PendingOpenWithVersionCall> > pendingOpenWithVersionCalls;
    407405    m_pendingOpenWithVersionCalls.swap(pendingOpenWithVersionCalls);
    408406    while (!pendingOpenWithVersionCalls.isEmpty()) {
    409         RefPtr<PendingOpenWithVersionCall> pendingOpenWithVersionCall = pendingOpenWithVersionCalls.takeFirst();
     407        OwnPtr<PendingOpenWithVersionCall> pendingOpenWithVersionCall = pendingOpenWithVersionCalls.takeFirst();
    410408        openConnectionWithVersion(pendingOpenWithVersionCall->callbacks(), pendingOpenWithVersionCall->databaseCallbacks(), pendingOpenWithVersionCall->version());
    411409    }
     
    413411    // Given the check above, it appears that calls cannot be requeued by
    414412    // openConnection, but use a different queue for iteration to be safe.
    415     Deque<RefPtr<PendingOpenCall> > pendingOpenCalls;
     413    Deque<OwnPtr<PendingOpenCall> > pendingOpenCalls;
    416414    m_pendingOpenCalls.swap(pendingOpenCalls);
    417415    while (!pendingOpenCalls.isEmpty()) {
    418         RefPtr<PendingOpenCall> pendingOpenCall = pendingOpenCalls.takeFirst();
     416        OwnPtr<PendingOpenCall> pendingOpenCall = pendingOpenCalls.takeFirst();
    419417        openConnection(pendingOpenCall->callbacks(), pendingOpenCall->databaseCallbacks());
    420418    }
     
    497495        ec = IDBDatabaseException::TRANSACTION_INACTIVE_ERR;
    498496    }
    499     ASSERT_WITH_MESSAGE(!m_pendingSecondHalfOpenWithVersionCalls.size(), "m_pendingSecondHalfOpenWithVersionCalls.size = %zu", m_pendingSecondHalfOpenWithVersionCalls.size());
    500     m_pendingSecondHalfOpenWithVersionCalls.append(PendingOpenWithVersionCall::create(callbacks, databaseCallbacks, requestedVersion));
     497    ASSERT(!m_pendingSecondHalfOpenWithVersion);
     498    m_pendingSecondHalfOpenWithVersion = PendingOpenWithVersionCall::create(callbacks, databaseCallbacks, requestedVersion);
    501499    m_databaseCallbacksSet.add(databaseCallbacks);
    502500}
     
    568566
    569567    m_databaseCallbacksSet.remove(callbacks);
    570     for (Deque<RefPtr<PendingOpenWithVersionCall> >::iterator it = m_pendingSecondHalfOpenWithVersionCalls.begin(); it != m_pendingSecondHalfOpenWithVersionCalls.end(); ++it) {
    571         if ((*it)->databaseCallbacks() == callbacks) {
    572             (*it)->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::IDB_ABORT_ERR, "The connection was closed."));
    573             m_pendingSecondHalfOpenWithVersionCalls.remove(it);
    574             break;
    575         }
     568    if (m_pendingSecondHalfOpenWithVersion && m_pendingSecondHalfOpenWithVersion->databaseCallbacks() == callbacks) {
     569        m_pendingSecondHalfOpenWithVersion->callbacks()->onError(IDBDatabaseError::create(IDBDatabaseException::IDB_ABORT_ERR, "The connection was closed."));
     570        m_pendingSecondHalfOpenWithVersion.release();
    576571    }
    577572
  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabaseBackendImpl.h

    r129066 r129076  
    114114
    115115    class PendingSetVersionCall;
    116     Deque<RefPtr<PendingSetVersionCall> > m_pendingSetVersionCalls;
     116    Deque<OwnPtr<PendingSetVersionCall> > m_pendingSetVersionCalls;
    117117
    118118    class PendingOpenCall;
    119     Deque<RefPtr<PendingOpenCall> > m_pendingOpenCalls;
     119    Deque<OwnPtr<PendingOpenCall> > m_pendingOpenCalls;
    120120
    121121    class PendingOpenWithVersionCall;
    122     Deque<RefPtr<PendingOpenWithVersionCall> > m_pendingOpenWithVersionCalls;
    123     Deque<RefPtr<PendingOpenWithVersionCall> > m_pendingSecondHalfOpenWithVersionCalls;
     122    Deque<OwnPtr<PendingOpenWithVersionCall> > m_pendingOpenWithVersionCalls;
     123    OwnPtr<PendingOpenWithVersionCall> m_pendingSecondHalfOpenWithVersion;
    124124
    125125    class PendingDeleteCall;
    126     Deque<RefPtr<PendingDeleteCall> > m_pendingDeleteCalls;
     126    Deque<OwnPtr<PendingDeleteCall> > m_pendingDeleteCalls;
    127127
    128128    typedef ListHashSet<RefPtr<IDBDatabaseCallbacks> > DatabaseCallbacksSet;
Note: See TracChangeset for help on using the changeset viewer.