LayoutTests/ChangeLog

2015-12-20  Brady Eidson  <beidson@apple.com>

        Modern IDB: Don't open any new connections until after version change transactions are completely handled.

        https://bugs.webkit.org/show_bug.cgi?id=152441

        Reviewed by NOBODY (OOPS!).

        * platform/mac-wk1/TestExpectations: Enable 4 now-passing tests.

2015-12-20  Commit Queue  <commit-queue@webkit.org>

        Unreviewed, rolling out r194033 and r194267.

LayoutTests/platform/mac-wk1/TestExpectations

@@storage/indexeddb/unblocked-version-changes.html [ Skip ]

storage/indexeddb/database-deletepending-flag.html [ Failure ]

storage/indexeddb/delete-closed-database-object.html [ Failure ]

storage/indexeddb/intversion-gated-on-delete.html [ Failure ]

storage/indexeddb/intversion-open-in-upgradeneeded.html [ Failure ]

storage/indexeddb/intversion-pending-version-changes-descending.html [ Failure ]

storage/indexeddb/intversion-pending-version-changes-same.html [ Failure ]

storage/indexeddb/intversion-two-opens-no-versions.html [ Failure ]

storage/indexeddb/odd-strings.html [ Failure ]

storage/indexeddb/open-db-private-browsing.html [ Failure ]

storage/indexeddb/properties-disabled-at-runtime.html [ Failure ]

Source/WebCore/ChangeLog

2015-12-20  Brady Eidson  <beidson@apple.com>

        Modern IDB: Don't open any new connections until after version change transactions are completely handled.

        https://bugs.webkit.org/show_bug.cgi?id=152441

        Reviewed by NOBODY (OOPS!).

        No new tests (At least 4 failing tests now pass).

        When a version change transaction is in progress for a database, the server should not open any new connections

        to that database until the version change transaction has been 100% completed.

        This means *all* events related to finishing the transaction must fire.

        To support this, a new message from client -> server is added.

        * Modules/indexeddb/client/IDBConnectionToServer.cpp:

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

        * Modules/indexeddb/client/IDBConnectionToServer.h:

        * Modules/indexeddb/client/IDBConnectionToServerDelegate.h:

        * Modules/indexeddb/client/IDBOpenDBRequestImpl.cpp:

        (WebCore::IDBClient::IDBOpenDBRequest::dispatchEvent):

        * Modules/indexeddb/client/IDBOpenDBRequestImpl.h:

        * Modules/indexeddb/client/IDBRequestImpl.h:

        * Modules/indexeddb/server/IDBServer.cpp:

        (WebCore::IDBServer::IDBServer::didFinishHandlingVersionChangeTransaction):

        * Modules/indexeddb/server/IDBServer.h:

        * Modules/indexeddb/server/UniqueIDBDatabase.cpp:

        (WebCore::IDBServer::UniqueIDBDatabase::handleDatabaseOperations):

        (WebCore::IDBServer::UniqueIDBDatabase::didFinishHandlingVersionChange):

        (WebCore::IDBServer::UniqueIDBDatabase::commitTransaction): Deleted.

        (WebCore::IDBServer::UniqueIDBDatabase::didPerformAbortTransaction): Deleted.

        (WebCore::IDBServer::UniqueIDBDatabase::inProgressTransactionCompleted): Deleted.

        * Modules/indexeddb/server/UniqueIDBDatabase.h:

        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp:

        (WebCore::IDBServer::UniqueIDBDatabaseTransaction::didFinishHandlingVersionChange):

        * Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h:

        * Modules/indexeddb/shared/IDBTransactionInfo.cpp:

        (WebCore::IDBTransactionInfo::loggingString):

        * Modules/indexeddb/shared/IDBTransactionInfo.h:

        * Modules/indexeddb/shared/InProcessIDBServer.cpp:

        (WebCore::InProcessIDBServer::didFinishHandlingVersionChangeTransaction):

        * Modules/indexeddb/shared/InProcessIDBServer.h:

2015-12-20  Dan Bernstein  <mitz@apple.com>

        Remove unused setToolbarHeight

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

@@void IDBConnectionToServer::didCommitTransaction(const IDBResourceIdentifier& tr

    transaction->didCommit(error);

}

void IDBConnectionToServer::didFinishHandlingVersionChangeTransaction(IDBTransaction& transaction)

{

    LOG(IndexedDB, "IDBConnectionToServer::didFinishHandlingVersionChangeTransaction");

    auto identifier = transaction.info().identifier();

    m_delegate->didFinishHandlingVersionChangeTransaction(identifier);

}

void IDBConnectionToServer::abortTransaction(IDBTransaction& transaction)

{

    LOG(IndexedDB, "IDBConnectionToServer::abortTransaction");

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

@@public:

    void commitTransaction(IDBTransaction&);

    void didCommitTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);

101 void didFinishHandlingVersionChangeTransaction(IDBTransaction&);

102

    void abortTransaction(IDBTransaction&);

    void didAbortTransaction(const IDBResourceIdentifier& transactionIdentifier, const IDBError&);

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

@@public:

    virtual void openDatabase(IDBRequestData&) = 0;

    virtual void abortTransaction(IDBResourceIdentifier&) = 0;

    virtual void commitTransaction(IDBResourceIdentifier&) = 0;

62 virtual void didFinishHandlingVersionChangeTransaction(IDBResourceIdentifier&) = 0;

    virtual void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&) = 0;

    virtual void deleteObjectStore(const IDBRequestData&, const String& objectStoreName) = 0;

    virtual void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier) = 0;

Source/WebCore/Modules/indexeddb/client/IDBOpenDBRequestImpl.cpp

@@void IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion()

    enqueueEvent(Event::create(eventNames().errorEvent, true, true));

}

bool IDBOpenDBRequest::dispatchEvent(Event& event)

{

    bool result = IDBRequest::dispatchEvent(event);

    if (m_transaction && m_transaction->isVersionChange() && (event.type() == eventNames().errorEvent || event.type() == eventNames().successEvent))

        m_transaction->database().serverConnection().didFinishHandlingVersionChangeTransaction(*m_transaction);

    return result;

}

void IDBOpenDBRequest::onSuccess(const IDBResultData& resultData)

{

    LOG(IndexedDB, "IDBOpenDBRequest::onSuccess()");

Source/WebCore/Modules/indexeddb/client/IDBOpenDBRequestImpl.h

@@public:

    void fireSuccessAfterVersionChangeCommit();

    void fireErrorAfterVersionChangeCompletion();

60 virtual bool dispatchEvent(Event&) override final;

61

private:

    IDBOpenDBRequest(IDBConnectionToServer&, ScriptExecutionContext*, const IDBDatabaseIdentifier&, uint64_t version, IndexedDB::RequestType);

Source/WebCore/Modules/indexeddb/client/IDBRequestImpl.h

@@public:

    using RefCounted<IDBRequest>::deref;

    void enqueueEvent(Ref<Event>&&);

82 virtual bool dispatchEvent(Event&) override ~~final~~;

82 virtual bool dispatchEvent(Event&) override;

    IDBConnectionToServer& connection() { return m_connection; }

Source/WebCore/Modules/indexeddb/server/IDBServer.cpp

@@void IDBServer::commitTransaction(const IDBResourceIdentifier& transactionIdenti

    transaction->commit();

}

void IDBServer::didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier& transactionIdentifier)

{

    LOG(IndexedDB, "IDBServer::didFinishHandlingVersionChangeTransaction");

    auto transaction = m_transactions.get(transactionIdentifier);

    if (!transaction)

        return;

    transaction->didFinishHandlingVersionChange();

}

void IDBServer::databaseConnectionClosed(uint64_t databaseConnectionIdentifier)

{

    LOG(IndexedDB, "IDBServer::databaseConnectionClosed");

Source/WebCore/Modules/indexeddb/server/IDBServer.h

@@public:

    void deleteDatabase(const IDBRequestData&);

    void abortTransaction(const IDBResourceIdentifier&);

    void commitTransaction(const IDBResourceIdentifier&);

63 void didFinishHandlingVersionChangeTransaction(const IDBResourceIdentifier&);

    void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&);

    void deleteObjectStore(const IDBRequestData&, const String& objectStoreName);

    void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier);

Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp

@@void UniqueIDBDatabase::handleDatabaseOperations()

    ASSERT(isMainThread());

    LOG(IndexedDB, "(main) UniqueIDBDatabase::handleDatabaseOperations - There are %zu pending", m_pendingDatabaseOperations.size());

    if (m_versionChangeDatabaseConnection || m_currentOperation) {

        // We can't start the next database operation quite yet, but we might need to notify all open connections

        // about a pending delete.

        if (!m_pendingDatabaseOperations.isEmpty() && m_pendingDatabaseOperations.first()->isDeleteRequest() && !m_hasNotifiedConnectionsOfDelete) {

            m_hasNotifiedConnectionsOfDelete = true;

            notifyConnectionsOfVersionChange(0);

        }

    if (m_versionChangeDatabaseConnection || m_versionChangeTransaction || m_currentOperation) {

        // We can't start any new open-database operations right now, but we might be able to start handling a delete operation.

        if (!m_currentOperation && !m_pendingDatabaseOperations.isEmpty() && m_pendingDatabaseOperations.first()->isDeleteRequest())

            m_currentOperation = m_pendingDatabaseOperations.takeFirst();

        // Some operations (such as the first open operation after a delete) require multiple passes to completely handle

        if (m_currentOperation)

@@void UniqueIDBDatabase::commitTransaction(UniqueIDBDatabaseTransaction& transact

        ASSERT(&m_versionChangeTransaction->databaseConnection() == m_versionChangeDatabaseConnection);

        ASSERT(m_databaseInfo->version() == transaction.info().newVersion());

        m_versionChangeTransaction = nullptr;

        m_versionChangeDatabaseConnection = nullptr;

        invokeOperationAndTransactionTimer();

    }

@@void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transacti

    m_server.postDatabaseTask(createCrossThreadTask(*this, &UniqueIDBDatabase::performAbortTransaction, callbackID, transaction.info().identifier()));

}

void UniqueIDBDatabase::didFinishHandlingVersionChange(UniqueIDBDatabaseTransaction& transaction)

{

    ASSERT(isMainThread());

    LOG(IndexedDB, "(main) UniqueIDBDatabase::didFinishHandlingVersionChange");

    ASSERT(m_versionChangeTransaction);

    ASSERT_UNUSED(transaction, m_versionChangeTransaction == &transaction);

    m_versionChangeTransaction = nullptr;

    m_versionChangeDatabaseConnection = nullptr;

    invokeOperationAndTransactionTimer();

}

void UniqueIDBDatabase::performAbortTransaction(uint64_t callbackIdentifier, const IDBResourceIdentifier& transactionIdentifier)

{

    ASSERT(!isMainThread());

@@void UniqueIDBDatabase::didPerformAbortTransaction(uint64_t callbackIdentifier,

        ASSERT(&m_versionChangeTransaction->databaseConnection() == m_versionChangeDatabaseConnection);

        ASSERT(m_versionChangeTransaction->originalDatabaseInfo());

        m_databaseInfo = std::make_unique<IDBDatabaseInfo>(*m_versionChangeTransaction->originalDatabaseInfo());

        m_versionChangeTransaction = nullptr;

        m_versionChangeDatabaseConnection = nullptr;

    }

    inProgressTransactionCompleted(transactionIdentifier);

@@void UniqueIDBDatabase::inProgressTransactionCompleted(const IDBResourceIdentifi

    auto transaction = m_inProgressTransactions.take(transactionIdentifier);

    ASSERT(transaction);

    if (m_versionChangeTransaction == transaction)

        m_versionChangeTransaction = nullptr;

    for (auto objectStore : transaction->objectStoreIdentifiers())

        m_objectStoreTransactionCounts.remove(objectStore);

Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.h

@@public:

    void iterateCursor(const IDBRequestData&, const IDBKeyData&, unsigned long count, GetResultCallback);

    void commitTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);

    void abortTransaction(UniqueIDBDatabaseTransaction&, ErrorCallback);

95 void didFinishHandlingVersionChange(UniqueIDBDatabaseTransaction&);

    void transactionDestroyed(UniqueIDBDatabaseTransaction&);

    void connectionClosedFromClient(UniqueIDBDatabaseConnection&);

@@private:

    HashSet<RefPtr<UniqueIDBDatabaseConnection>> m_closePendingDatabaseConnections;

    RefPtr<UniqueIDBDatabaseConnection> m_versionChangeDatabaseConnection;

186 UniqueIDBDatabaseTransaction* m_versionChangeTransaction ~~{ nullptr }~~;

187 RefPtr<UniqueIDBDatabaseTransaction> m_versionChangeTransaction;

    bool m_isOpeningBackingStore { false };

    std::unique_ptr<IDBBackingStore> m_backingStore;

Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.cpp

@@void UniqueIDBDatabaseTransaction::didActivateInBackingStore(const IDBError& err

    m_databaseConnection->connectionToClient().didStartTransaction(m_transactionInfo.identifier(), error);

}

void UniqueIDBDatabaseTransaction::didFinishHandlingVersionChange()

{

    LOG(IndexedDB, "UniqueIDBDatabaseTransaction::didFinishHandlingVersionChange");

    ASSERT(isVersionChange());

    m_databaseConnection->database().didFinishHandlingVersionChange(*this);

}

} // namespace IDBServer

} // namespace WebCore

Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabaseTransaction.h

@@public:

    void iterateCursor(const IDBRequestData&, const IDBKeyData&, unsigned long count);

    void didActivateInBackingStore(const IDBError&);

82 void didFinishHandlingVersionChange();

    const Vector<uint64_t>& objectStoreIdentifiers();

Source/WebCore/Modules/indexeddb/shared/IDBTransactionInfo.cpp

#if ENABLE(INDEXED_DATABASE)

31#include "IDBTransactionImpl.h"

32

namespace WebCore {

IDBTransactionInfo::IDBTransactionInfo(const IDBResourceIdentifier& identifier)

@@IDBTransactionInfo IDBTransactionInfo::isolatedCopy() const

    return WTF::move(result);

}

#ifndef NDEBUG

String IDBTransactionInfo::loggingString() const

{

    String modeString;

    switch (m_mode) {

    case IndexedDB::TransactionMode::ReadOnly:

        modeString = IDBTransaction::modeReadOnly();

        break;

    case IndexedDB::TransactionMode::ReadWrite:

        modeString = IDBTransaction::modeReadWrite();

        break;

    case IndexedDB::TransactionMode::VersionChange:

        modeString = IDBTransaction::modeVersionChange();

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    return makeString("Transaction: ", m_identifier.loggingString(), " mode ", modeString, " newVersion ", String::number(m_newVersion));

}

#endif

} // namespace WebCore

#endif // ENABLE(INDEXED_DATABASE)

Source/WebCore/Modules/indexeddb/shared/IDBTransactionInfo.h

@@public:

    IDBDatabaseInfo* originalDatabaseInfo() const { return m_originalDatabaseInfo.get(); }

#ifndef NDEBUG

    String loggingString() const;

#endif

private:

    IDBTransactionInfo(const IDBResourceIdentifier&);

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

@@void InProcessIDBServer::commitTransaction(IDBResourceIdentifier& resourceIdenti

    });

}

void InProcessIDBServer::didFinishHandlingVersionChangeTransaction(IDBResourceIdentifier& transactionIdentifier)

{

    RefPtr<InProcessIDBServer> self(this);

    RunLoop::current().dispatch([this, self, transactionIdentifier] {

        m_server->didFinishHandlingVersionChangeTransaction(transactionIdentifier);

    });

}

void InProcessIDBServer::createObjectStore(const IDBRequestData& resultData, const IDBObjectStoreInfo& info)

{

    RefPtr<InProcessIDBServer> self(this);

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

@@public:

    virtual void openDatabase(IDBRequestData&) override final;

    virtual void abortTransaction(IDBResourceIdentifier&) override final;

    virtual void commitTransaction(IDBResourceIdentifier&) override final;

61 virtual void didFinishHandlingVersionChangeTransaction(IDBResourceIdentifier&) override final;

    virtual void createObjectStore(const IDBRequestData&, const IDBObjectStoreInfo&) override final;

    virtual void deleteObjectStore(const IDBRequestData&, const String& objectStoreName) override final;

    virtual void clearObjectStore(const IDBRequestData&, uint64_t objectStoreIdentifier) override final;