diff options
Diffstat (limited to 'Source/WebKit2/DatabaseProcess/IndexedDB')
3 files changed, 569 insertions, 0 deletions
diff --git a/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp b/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp new file mode 100644 index 000000000..274add5ea --- /dev/null +++ b/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.cpp @@ -0,0 +1,371 @@ +/* + * Copyright (C) 2016 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "WebIDBConnectionToClient.h" + +#if ENABLE(INDEXED_DATABASE) + +#include "DataReference.h" +#include "DatabaseProcess.h" +#include "WebCoreArgumentCoders.h" +#include "WebIDBConnectionToServerMessages.h" +#include "WebIDBResult.h" +#include <WebCore/IDBError.h> +#include <WebCore/IDBGetAllRecordsData.h> +#include <WebCore/IDBGetRecordData.h> +#include <WebCore/IDBResultData.h> +#include <WebCore/IDBValue.h> +#include <WebCore/ThreadSafeDataBuffer.h> +#include <WebCore/UniqueIDBDatabaseConnection.h> + +using namespace WebCore; + +namespace WebKit { + +Ref<WebIDBConnectionToClient> WebIDBConnectionToClient::create(DatabaseToWebProcessConnection& connection, uint64_t serverConnectionIdentifier) +{ + return adoptRef(*new WebIDBConnectionToClient(connection, serverConnectionIdentifier)); +} + +WebIDBConnectionToClient::WebIDBConnectionToClient(DatabaseToWebProcessConnection& connection, uint64_t serverConnectionIdentifier) + : m_connection(connection) + , m_identifier(serverConnectionIdentifier) +{ + relaxAdoptionRequirement(); + m_connectionToClient = IDBServer::IDBConnectionToClient::create(*this); + DatabaseProcess::singleton().idbServer().registerConnection(*m_connectionToClient); +} + +WebIDBConnectionToClient::~WebIDBConnectionToClient() +{ +} + +void WebIDBConnectionToClient::disconnectedFromWebProcess() +{ + DatabaseProcess::singleton().idbServer().unregisterConnection(*m_connectionToClient); +} + +IPC::Connection* WebIDBConnectionToClient::messageSenderConnection() +{ + return &m_connection->connection(); +} + +WebCore::IDBServer::IDBConnectionToClient& WebIDBConnectionToClient::connectionToClient() +{ + return *m_connectionToClient; +} + +void WebIDBConnectionToClient::didDeleteDatabase(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidDeleteDatabase(resultData)); +} + +void WebIDBConnectionToClient::didOpenDatabase(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidOpenDatabase(resultData)); +} + +void WebIDBConnectionToClient::didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error) +{ + send(Messages::WebIDBConnectionToServer::DidAbortTransaction(transactionIdentifier, error)); +} + +void WebIDBConnectionToClient::didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error) +{ + send(Messages::WebIDBConnectionToServer::DidCommitTransaction(transactionIdentifier, error)); +} + +void WebIDBConnectionToClient::didCreateObjectStore(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidCreateObjectStore(resultData)); +} + +void WebIDBConnectionToClient::didDeleteObjectStore(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidDeleteObjectStore(resultData)); +} + +void WebIDBConnectionToClient::didRenameObjectStore(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidRenameObjectStore(resultData)); +} + +void WebIDBConnectionToClient::didClearObjectStore(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidClearObjectStore(resultData)); +} + +void WebIDBConnectionToClient::didCreateIndex(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidCreateIndex(resultData)); +} + +void WebIDBConnectionToClient::didDeleteIndex(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidDeleteIndex(resultData)); +} + +void WebIDBConnectionToClient::didRenameIndex(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidRenameIndex(resultData)); +} + +void WebIDBConnectionToClient::didPutOrAdd(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidPutOrAdd(resultData)); +} + +template<class MessageType> void WebIDBConnectionToClient::handleGetResult(const WebCore::IDBResultData& resultData) +{ + if (resultData.type() == IDBResultType::Error) { + send(MessageType(resultData)); + return; + } + + if (resultData.type() == IDBResultType::GetAllRecordsSuccess && resultData.getAllResult().type() == IndexedDB::GetAllType::Keys) { + send(MessageType(resultData)); + return; + } + + auto blobFilePaths = resultData.type() == IDBResultType::GetAllRecordsSuccess ? resultData.getAllResult().allBlobFilePaths() : resultData.getResult().value().blobFilePaths(); + if (blobFilePaths.isEmpty()) { + send(MessageType(resultData)); + return; + } + +#if ENABLE(SANDBOX_EXTENSIONS) + RefPtr<WebIDBConnectionToClient> protector(this); + DatabaseProcess::singleton().getSandboxExtensionsForBlobFiles(blobFilePaths, [protector, this, resultData](SandboxExtension::HandleArray&& handles) { + send(MessageType({ resultData, WTFMove(handles) })); + }); +#else + send(MessageType(resultData)); +#endif +} + +void WebIDBConnectionToClient::didGetRecord(const WebCore::IDBResultData& resultData) +{ + handleGetResult<Messages::WebIDBConnectionToServer::DidGetRecord>(resultData); +} + +void WebIDBConnectionToClient::didGetAllRecords(const WebCore::IDBResultData& resultData) +{ + handleGetResult<Messages::WebIDBConnectionToServer::DidGetAllRecords>(resultData); +} + +void WebIDBConnectionToClient::didGetCount(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidGetCount(resultData)); +} + +void WebIDBConnectionToClient::didDeleteRecord(const WebCore::IDBResultData& resultData) +{ + send(Messages::WebIDBConnectionToServer::DidDeleteRecord(resultData)); +} + +void WebIDBConnectionToClient::didOpenCursor(const WebCore::IDBResultData& resultData) +{ + handleGetResult<Messages::WebIDBConnectionToServer::DidOpenCursor>(resultData); +} + +void WebIDBConnectionToClient::didIterateCursor(const WebCore::IDBResultData& resultData) +{ + handleGetResult<Messages::WebIDBConnectionToServer::DidIterateCursor>(resultData); +} + +void WebIDBConnectionToClient::fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion) +{ + send(Messages::WebIDBConnectionToServer::FireVersionChangeEvent(connection.identifier(), requestIdentifier, requestedVersion)); +} + +void WebIDBConnectionToClient::didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError& error) +{ + send(Messages::WebIDBConnectionToServer::DidStartTransaction(transactionIdentifier, error)); +} + +void WebIDBConnectionToClient::didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection& connection, const WebCore::IDBError& error) +{ + send(Messages::WebIDBConnectionToServer::DidCloseFromServer(connection.identifier(), error)); +} + +void WebIDBConnectionToClient::notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion) +{ + send(Messages::WebIDBConnectionToServer::NotifyOpenDBRequestBlocked(requestIdentifier, oldVersion, newVersion)); +} + +void WebIDBConnectionToClient::didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames) +{ + send(Messages::WebIDBConnectionToServer::DidGetAllDatabaseNames(callbackID, databaseNames)); +} + +void WebIDBConnectionToClient::deleteDatabase(const IDBRequestData& request) +{ + DatabaseProcess::singleton().idbServer().deleteDatabase(request); +} + +void WebIDBConnectionToClient::openDatabase(const IDBRequestData& request) +{ + DatabaseProcess::singleton().idbServer().openDatabase(request); +} + +void WebIDBConnectionToClient::abortTransaction(const IDBResourceIdentifier& transactionIdentifier) +{ + DatabaseProcess::singleton().idbServer().abortTransaction(transactionIdentifier); +} + +void WebIDBConnectionToClient::commitTransaction(const IDBResourceIdentifier& transactionIdentifier) +{ + DatabaseProcess::singleton().idbServer().commitTransaction(transactionIdentifier); +} + +void WebIDBConnectionToClient::didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier) +{ + DatabaseProcess::singleton().idbServer().didFinishHandlingVersionChangeTransaction(databaseConnectionIdentifier, transactionIdentifier); +} + +void WebIDBConnectionToClient::createObjectStore(const IDBRequestData& request, const IDBObjectStoreInfo& info) +{ + DatabaseProcess::singleton().idbServer().createObjectStore(request, info); +} + +void WebIDBConnectionToClient::deleteObjectStore(const IDBRequestData& request, const String& name) +{ + DatabaseProcess::singleton().idbServer().deleteObjectStore(request, name); +} + +void WebIDBConnectionToClient::renameObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& newName) +{ + DatabaseProcess::singleton().idbServer().renameObjectStore(request, objectStoreIdentifier, newName); +} + +void WebIDBConnectionToClient::clearObjectStore(const IDBRequestData& request, uint64_t objectStoreIdentifier) +{ + DatabaseProcess::singleton().idbServer().clearObjectStore(request, objectStoreIdentifier); +} + +void WebIDBConnectionToClient::createIndex(const IDBRequestData& request, const IDBIndexInfo& info) +{ + DatabaseProcess::singleton().idbServer().createIndex(request, info); +} + +void WebIDBConnectionToClient::deleteIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, const String& name) +{ + DatabaseProcess::singleton().idbServer().deleteIndex(request, objectStoreIdentifier, name); +} + +void WebIDBConnectionToClient::renameIndex(const IDBRequestData& request, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName) +{ + DatabaseProcess::singleton().idbServer().renameIndex(request, objectStoreIdentifier, indexIdentifier, newName); +} + +void WebIDBConnectionToClient::putOrAdd(const IDBRequestData& request, const IDBKeyData& key, const IDBValue& value, unsigned overwriteMode) +{ + if (overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::NoOverwrite) + && overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::Overwrite) + && overwriteMode != static_cast<unsigned>(IndexedDB::ObjectStoreOverwriteMode::OverwriteForCursor)) { + // FIXME: This message from the WebProcess is corrupt. + // The DatabaseProcess should return early at this point, but can we also kill the bad WebProcess? + return; + } + + IndexedDB::ObjectStoreOverwriteMode mode = static_cast<IndexedDB::ObjectStoreOverwriteMode>(overwriteMode); + + DatabaseProcess::singleton().idbServer().putOrAdd(request, key, value, mode); +} + +void WebIDBConnectionToClient::getRecord(const IDBRequestData& request, const IDBGetRecordData& getRecordData) +{ + DatabaseProcess::singleton().idbServer().getRecord(request, getRecordData); +} + +void WebIDBConnectionToClient::getAllRecords(const IDBRequestData& request, const IDBGetAllRecordsData& getAllRecordsData) +{ + DatabaseProcess::singleton().idbServer().getAllRecords(request, getAllRecordsData); +} + +void WebIDBConnectionToClient::getCount(const IDBRequestData& request, const IDBKeyRangeData& range) +{ + DatabaseProcess::singleton().idbServer().getCount(request, range); +} + +void WebIDBConnectionToClient::deleteRecord(const IDBRequestData& request, const IDBKeyRangeData& range) +{ + DatabaseProcess::singleton().idbServer().deleteRecord(request, range); +} + +void WebIDBConnectionToClient::openCursor(const IDBRequestData& request, const IDBCursorInfo& info) +{ + DatabaseProcess::singleton().idbServer().openCursor(request, info); +} + +void WebIDBConnectionToClient::iterateCursor(const IDBRequestData& request, const IDBIterateCursorData& data) +{ + DatabaseProcess::singleton().idbServer().iterateCursor(request, data); +} + +void WebIDBConnectionToClient::establishTransaction(uint64_t databaseConnectionIdentifier, const IDBTransactionInfo& info) +{ + DatabaseProcess::singleton().idbServer().establishTransaction(databaseConnectionIdentifier, info); +} + +void WebIDBConnectionToClient::databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier) +{ + DatabaseProcess::singleton().idbServer().databaseConnectionPendingClose(databaseConnectionIdentifier); +} + +void WebIDBConnectionToClient::databaseConnectionClosed(uint64_t databaseConnectionIdentifier) +{ + DatabaseProcess::singleton().idbServer().databaseConnectionClosed(databaseConnectionIdentifier); +} + +void WebIDBConnectionToClient::abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier) +{ + DatabaseProcess::singleton().idbServer().abortOpenAndUpgradeNeeded(databaseConnectionIdentifier, transactionIdentifier); +} + +void WebIDBConnectionToClient::didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const IDBResourceIdentifier& transactionIdentifier) +{ + DatabaseProcess::singleton().idbServer().didFireVersionChangeEvent(databaseConnectionIdentifier, transactionIdentifier); +} + +void WebIDBConnectionToClient::openDBRequestCancelled(const IDBRequestData& requestData) +{ + DatabaseProcess::singleton().idbServer().openDBRequestCancelled(requestData); +} + +void WebIDBConnectionToClient::confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier) +{ + DatabaseProcess::singleton().idbServer().confirmDidCloseFromServer(databaseConnectionIdentifier); +} + +void WebIDBConnectionToClient::getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID) +{ + DatabaseProcess::singleton().idbServer().getAllDatabaseNames(serverConnectionIdentifier, topOrigin, openingOrigin, callbackID); +} + +} // namespace WebKit + +#endif // ENABLE(INDEXED_DATABASE) diff --git a/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.h b/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.h new file mode 100644 index 000000000..11c6cc1c1 --- /dev/null +++ b/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.h @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2016 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#if ENABLE(INDEXED_DATABASE) + +#include "DatabaseToWebProcessConnection.h" +#include "MessageSender.h" +#include <WebCore/IDBConnectionToClient.h> + +namespace WebCore { +class IDBCursorInfo; +class IDBIndexInfo; +class IDBKeyData; +class IDBObjectStoreInfo; +class IDBRequestData; +class IDBTransactionInfo; +class IDBValue; +class SerializedScriptValue; +struct IDBGetAllRecordsData; +struct IDBGetRecordData; +struct IDBIterateCursorData; +struct IDBKeyRangeData; +struct SecurityOriginData; +} + +namespace WebKit { + +class WebIDBConnectionToClient final : public WebCore::IDBServer::IDBConnectionToClientDelegate, public IPC::MessageSender, public RefCounted<WebIDBConnectionToClient> { +public: + static Ref<WebIDBConnectionToClient> create(DatabaseToWebProcessConnection&, uint64_t serverConnectionIdentifier); + + virtual ~WebIDBConnectionToClient(); + + WebCore::IDBServer::IDBConnectionToClient& connectionToClient(); + uint64_t identifier() const final { return m_identifier; } + uint64_t messageSenderDestinationID() final { return m_identifier; } + + // IDBConnectionToClientDelegate + void didDeleteDatabase(const WebCore::IDBResultData&) final; + void didOpenDatabase(const WebCore::IDBResultData&) final; + void didAbortTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final; + void didCommitTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final; + void didCreateObjectStore(const WebCore::IDBResultData&) final; + void didDeleteObjectStore(const WebCore::IDBResultData&) final; + void didRenameObjectStore(const WebCore::IDBResultData&) final; + void didClearObjectStore(const WebCore::IDBResultData&) final; + void didCreateIndex(const WebCore::IDBResultData&) final; + void didDeleteIndex(const WebCore::IDBResultData&) final; + void didRenameIndex(const WebCore::IDBResultData&) final; + void didPutOrAdd(const WebCore::IDBResultData&) final; + void didGetRecord(const WebCore::IDBResultData&) final; + void didGetAllRecords(const WebCore::IDBResultData&) final; + void didGetCount(const WebCore::IDBResultData&) final; + void didDeleteRecord(const WebCore::IDBResultData&) final; + void didOpenCursor(const WebCore::IDBResultData&) final; + void didIterateCursor(const WebCore::IDBResultData&) final; + + void fireVersionChangeEvent(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t requestedVersion) final; + void didStartTransaction(const WebCore::IDBResourceIdentifier& transactionIdentifier, const WebCore::IDBError&) final; + void didCloseFromServer(WebCore::IDBServer::UniqueIDBDatabaseConnection&, const WebCore::IDBError&) final; + void notifyOpenDBRequestBlocked(const WebCore::IDBResourceIdentifier& requestIdentifier, uint64_t oldVersion, uint64_t newVersion) final; + + void didGetAllDatabaseNames(uint64_t callbackID, const Vector<String>& databaseNames) final; + + void ref() override { RefCounted<WebIDBConnectionToClient>::ref(); } + void deref() override { RefCounted<WebIDBConnectionToClient>::deref(); } + + // Messages received from WebProcess + void deleteDatabase(const WebCore::IDBRequestData&); + void openDatabase(const WebCore::IDBRequestData&); + void abortTransaction(const WebCore::IDBResourceIdentifier&); + void commitTransaction(const WebCore::IDBResourceIdentifier&); + void didFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier&); + void createObjectStore(const WebCore::IDBRequestData&, const WebCore::IDBObjectStoreInfo&); + void deleteObjectStore(const WebCore::IDBRequestData&, const String& objectStoreName); + void renameObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& newName); + void clearObjectStore(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier); + void createIndex(const WebCore::IDBRequestData&, const WebCore::IDBIndexInfo&); + void deleteIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, const String& indexName); + void renameIndex(const WebCore::IDBRequestData&, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, const String& newName); + void putOrAdd(const WebCore::IDBRequestData&, const WebCore::IDBKeyData&, const WebCore::IDBValue&, unsigned overwriteMode); + void getRecord(const WebCore::IDBRequestData&, const WebCore::IDBGetRecordData&); + void getAllRecords(const WebCore::IDBRequestData&, const WebCore::IDBGetAllRecordsData&); + void getCount(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&); + void deleteRecord(const WebCore::IDBRequestData&, const WebCore::IDBKeyRangeData&); + void openCursor(const WebCore::IDBRequestData&, const WebCore::IDBCursorInfo&); + void iterateCursor(const WebCore::IDBRequestData&, const WebCore::IDBIterateCursorData&); + + void establishTransaction(uint64_t databaseConnectionIdentifier, const WebCore::IDBTransactionInfo&); + void databaseConnectionPendingClose(uint64_t databaseConnectionIdentifier); + void databaseConnectionClosed(uint64_t databaseConnectionIdentifier); + void abortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& transactionIdentifier); + void didFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, const WebCore::IDBResourceIdentifier& requestIdentifier); + void openDBRequestCancelled(const WebCore::IDBRequestData&); + void confirmDidCloseFromServer(uint64_t databaseConnectionIdentifier); + + void getAllDatabaseNames(uint64_t serverConnectionIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& openingOrigin, uint64_t callbackID); + + void disconnectedFromWebProcess(); + + void didReceiveMessage(IPC::Connection&, IPC::Decoder&); + +private: + WebIDBConnectionToClient(DatabaseToWebProcessConnection&, uint64_t serverConnectionIdentifier); + + IPC::Connection* messageSenderConnection() final; + + template<class MessageType> void handleGetResult(const WebCore::IDBResultData&); + + Ref<DatabaseToWebProcessConnection> m_connection; + + uint64_t m_identifier; + RefPtr<WebCore::IDBServer::IDBConnectionToClient> m_connectionToClient; +}; + +} // namespace WebKit + +#endif // ENABLE(INDEXED_DATABASE) diff --git a/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.messages.in b/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.messages.in new file mode 100644 index 000000000..d5a747b4f --- /dev/null +++ b/Source/WebKit2/DatabaseProcess/IndexedDB/WebIDBConnectionToClient.messages.in @@ -0,0 +1,56 @@ +# Copyright (C) 2016 Apple Inc. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS) + +messages -> WebIDBConnectionToClient { + DeleteDatabase(WebCore::IDBRequestData requestData) + OpenDatabase(WebCore::IDBRequestData requestData); + AbortTransaction(WebCore::IDBResourceIdentifier transactionIdentifier); + CommitTransaction(WebCore::IDBResourceIdentifier transactionIdentifier); + DidFinishHandlingVersionChangeTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier); + CreateObjectStore(WebCore::IDBRequestData requestData, WebCore::IDBObjectStoreInfo info); + DeleteObjectStore(WebCore::IDBRequestData requestData, String objectStoreName); + RenameObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String newName); + ClearObjectStore(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier); + CreateIndex(WebCore::IDBRequestData requestData, WebCore::IDBIndexInfo info); + DeleteIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, String indexName); + RenameIndex(WebCore::IDBRequestData requestData, uint64_t objectStoreIdentifier, uint64_t indexIdentifier, String newName); + PutOrAdd(WebCore::IDBRequestData requestData, WebCore::IDBKeyData key, WebCore::IDBValue value, unsigned overwriteMode); + GetRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBGetRecordData getRecordData); + GetAllRecords(WebCore::IDBRequestData requestData, struct WebCore::IDBGetAllRecordsData getAllRecordsData); + GetCount(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range); + DeleteRecord(WebCore::IDBRequestData requestData, struct WebCore::IDBKeyRangeData range); + OpenCursor(WebCore::IDBRequestData requestData, WebCore::IDBCursorInfo info); + IterateCursor(WebCore::IDBRequestData requestData, struct WebCore::IDBIterateCursorData data); + + EstablishTransaction(uint64_t databaseConnectionIdentifier, WebCore::IDBTransactionInfo info); + DatabaseConnectionPendingClose(uint64_t databaseConnectionIdentifier); + DatabaseConnectionClosed(uint64_t databaseConnectionIdentifier); + AbortOpenAndUpgradeNeeded(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier transactionIdentifier); + DidFireVersionChangeEvent(uint64_t databaseConnectionIdentifier, WebCore::IDBResourceIdentifier requestIdentifier); + OpenDBRequestCancelled(WebCore::IDBRequestData requestData); + ConfirmDidCloseFromServer(uint64_t databaseConnectionIdentifier); + + GetAllDatabaseNames(uint64_t serverConnectionIdentifier, struct WebCore::SecurityOriginData topOrigin, struct WebCore::SecurityOriginData openingOrigin, uint64_t callbackID); +} +#endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS) |