ab2db7659c96be5736295860d5c91f701b98bc00
[WebKit-https.git] / Source / WebKit2 / DatabaseProcess / IndexedDB / DatabaseProcessIDBConnection.cpp
1 /*
2  * Copyright (C) 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "DatabaseProcessIDBConnection.h"
28
29 #if ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)
30
31 #include "DataReference.h"
32 #include "DatabaseProcess.h"
33 #include "DatabaseToWebProcessConnection.h"
34 #include "IDBIdentifier.h"
35 #include "Logging.h"
36 #include "UniqueIDBDatabase.h"
37 #include "WebCoreArgumentCoders.h"
38 #include "WebIDBServerConnectionMessages.h"
39 #include <WebCore/IDBDatabaseMetadata.h>
40 #include <WebCore/IDBServerConnection.h>
41 #include <WebCore/IndexedDB.h>
42
43 using namespace WebCore;
44
45 namespace WebKit {
46
47 DatabaseProcessIDBConnection::DatabaseProcessIDBConnection(DatabaseToWebProcessConnection& connection, uint64_t serverConnectionIdentifier)
48     : m_connection(connection)
49     , m_serverConnectionIdentifier(serverConnectionIdentifier)
50 {
51 }
52
53 DatabaseProcessIDBConnection::~DatabaseProcessIDBConnection()
54 {
55     ASSERT(!m_uniqueIDBDatabase);
56 }
57
58 void DatabaseProcessIDBConnection::disconnectedFromWebProcess()
59 {
60     m_uniqueIDBDatabase->unregisterConnection(*this);
61     m_uniqueIDBDatabase.clear();
62 }
63
64 void DatabaseProcessIDBConnection::establishConnection(const String& databaseName, const SecurityOriginData& openingOrigin, const SecurityOriginData& mainFrameOrigin)
65 {
66     m_uniqueIDBDatabase = DatabaseProcess::shared().getOrCreateUniqueIDBDatabase(UniqueIDBDatabaseIdentifier(databaseName, openingOrigin, mainFrameOrigin));
67     m_uniqueIDBDatabase->registerConnection(*this);
68 }
69
70 void DatabaseProcessIDBConnection::getOrEstablishIDBDatabaseMetadata(uint64_t requestID)
71 {
72     ASSERT(m_uniqueIDBDatabase);
73
74     LOG(IDB, "DatabaseProcess getOrEstablishIDBDatabaseMetadata request ID %llu", requestID);
75
76     RefPtr<DatabaseProcessIDBConnection> connection(this);
77     m_uniqueIDBDatabase->getOrEstablishIDBDatabaseMetadata([connection, requestID](bool success, const IDBDatabaseMetadata& metadata) {
78         connection->send(Messages::WebIDBServerConnection::DidGetOrEstablishIDBDatabaseMetadata(requestID, success, metadata));
79     });
80 }
81
82 void DatabaseProcessIDBConnection::openTransaction(uint64_t requestID, int64_t transactionID, const Vector<int64_t>& objectStoreIDs, uint64_t intMode)
83 {
84     ASSERT(m_uniqueIDBDatabase);
85
86     LOG(IDB, "DatabaseProcess openTransaction request ID %llu", requestID);
87
88     if (intMode > IndexedDB::TransactionModeMaximum) {
89         send(Messages::WebIDBServerConnection::DidOpenTransaction(requestID, false));
90         return;
91     }
92
93     IndexedDB::TransactionMode mode = static_cast<IndexedDB::TransactionMode>(intMode);
94     RefPtr<DatabaseProcessIDBConnection> connection(this);
95     m_uniqueIDBDatabase->openTransaction(IDBIdentifier(*this, transactionID), objectStoreIDs, mode, [connection, requestID](bool success) {
96         connection->send(Messages::WebIDBServerConnection::DidOpenTransaction(requestID, success));
97     });
98 }
99
100 void DatabaseProcessIDBConnection::beginTransaction(uint64_t requestID, int64_t transactionID)
101 {
102     ASSERT(m_uniqueIDBDatabase);
103
104     LOG(IDB, "DatabaseProcess beginTransaction request ID %llu", requestID);
105
106     RefPtr<DatabaseProcessIDBConnection> connection(this);
107     m_uniqueIDBDatabase->beginTransaction(IDBIdentifier(*this, transactionID), [connection, requestID](bool success) {
108         connection->send(Messages::WebIDBServerConnection::DidBeginTransaction(requestID, success));
109     });
110 }
111
112 void DatabaseProcessIDBConnection::commitTransaction(uint64_t requestID, int64_t transactionID)
113 {
114     ASSERT(m_uniqueIDBDatabase);
115
116     LOG(IDB, "DatabaseProcess commitTransaction request ID %llu", requestID);
117
118     RefPtr<DatabaseProcessIDBConnection> connection(this);
119     m_uniqueIDBDatabase->commitTransaction(IDBIdentifier(*this, transactionID), [connection, requestID](bool success) {
120         connection->send(Messages::WebIDBServerConnection::DidCommitTransaction(requestID, success));
121     });
122 }
123
124 void DatabaseProcessIDBConnection::resetTransaction(uint64_t requestID, int64_t transactionID)
125 {
126     ASSERT(m_uniqueIDBDatabase);
127
128     LOG(IDB, "DatabaseProcess resetTransaction request ID %llu", requestID);
129
130     RefPtr<DatabaseProcessIDBConnection> connection(this);
131     m_uniqueIDBDatabase->resetTransaction(IDBIdentifier(*this, transactionID), [connection, requestID](bool success) {
132         connection->send(Messages::WebIDBServerConnection::DidResetTransaction(requestID, success));
133     });
134 }
135
136 void DatabaseProcessIDBConnection::rollbackTransaction(uint64_t requestID, int64_t transactionID)
137 {
138     ASSERT(m_uniqueIDBDatabase);
139
140     LOG(IDB, "DatabaseProcess rollbackTransaction request ID %llu", requestID);
141
142     RefPtr<DatabaseProcessIDBConnection> connection(this);
143     m_uniqueIDBDatabase->rollbackTransaction(IDBIdentifier(*this, transactionID), [connection, requestID](bool success) {
144         connection->send(Messages::WebIDBServerConnection::DidRollbackTransaction(requestID, success));
145     });
146 }
147
148 void DatabaseProcessIDBConnection::changeDatabaseVersion(uint64_t requestID, int64_t transactionID, uint64_t newVersion)
149 {
150     ASSERT(m_uniqueIDBDatabase);
151
152     LOG(IDB, "DatabaseProcess changeDatabaseVersion request ID %llu, new version %llu", requestID, newVersion);
153
154     RefPtr<DatabaseProcessIDBConnection> connection(this);
155     m_uniqueIDBDatabase->changeDatabaseVersion(IDBIdentifier(*this, transactionID), newVersion, [connection, requestID](bool success) {
156         connection->send(Messages::WebIDBServerConnection::DidChangeDatabaseVersion(requestID, success));
157     });
158 }
159
160 void DatabaseProcessIDBConnection::createObjectStore(uint64_t requestID, int64_t transactionID, WebCore::IDBObjectStoreMetadata metadata)
161 {
162     ASSERT(m_uniqueIDBDatabase);
163
164     LOG(IDB, "DatabaseProcess createObjectStore request ID %llu, object store name '%s'", requestID, metadata.name.utf8().data());
165     RefPtr<DatabaseProcessIDBConnection> connection(this);
166     m_uniqueIDBDatabase->createObjectStore(IDBIdentifier(*this, transactionID), metadata, [connection, requestID](bool success) {
167         connection->send(Messages::WebIDBServerConnection::DidCreateObjectStore(requestID, success));
168     });
169 }
170
171 void DatabaseProcessIDBConnection::deleteObjectStore(uint64_t requestID, int64_t transactionID, int64_t objectStoreID)
172 {
173     ASSERT(m_uniqueIDBDatabase);
174
175     LOG(IDB, "DatabaseProcess deleteObjectStore request ID %llu, object store id %lli", requestID, objectStoreID);
176     RefPtr<DatabaseProcessIDBConnection> connection(this);
177     m_uniqueIDBDatabase->deleteObjectStore(IDBIdentifier(*this, transactionID), objectStoreID, [connection, requestID](bool success) {
178         connection->send(Messages::WebIDBServerConnection::DidDeleteObjectStore(requestID, success));
179     });
180 }
181
182 void DatabaseProcessIDBConnection::clearObjectStore(uint64_t requestID, int64_t transactionID, int64_t objectStoreID)
183 {
184     ASSERT(m_uniqueIDBDatabase);
185
186     LOG(IDB, "DatabaseProcess clearObjectStore request ID %llu, object store id %lli", requestID, objectStoreID);
187     RefPtr<DatabaseProcessIDBConnection> connection(this);
188     m_uniqueIDBDatabase->clearObjectStore(IDBIdentifier(*this, transactionID), objectStoreID, [connection, requestID](bool success) {
189         connection->send(Messages::WebIDBServerConnection::DidClearObjectStore(requestID, success));
190     });
191 }
192
193 void DatabaseProcessIDBConnection::createIndex(uint64_t requestID, int64_t transactionID, int64_t objectStoreID, const WebCore::IDBIndexMetadata& metadata)
194 {
195     ASSERT(m_uniqueIDBDatabase);
196
197     LOG(IDB, "DatabaseProcess createIndex request ID %llu, object store id %lli", requestID, objectStoreID);
198     RefPtr<DatabaseProcessIDBConnection> connection(this);
199     m_uniqueIDBDatabase->createIndex(IDBIdentifier(*this, transactionID), objectStoreID, metadata, [connection, requestID](bool success) {
200         connection->send(Messages::WebIDBServerConnection::DidCreateIndex(requestID, success));
201     });
202 }
203
204 void DatabaseProcessIDBConnection::deleteIndex(uint64_t requestID, int64_t transactionID, int64_t objectStoreID, int64_t indexID)
205 {
206     ASSERT(m_uniqueIDBDatabase);
207
208     LOG(IDB, "DatabaseProcess deleteIndex request ID %llu, object store id %lli", requestID, objectStoreID);
209     RefPtr<DatabaseProcessIDBConnection> connection(this);
210     m_uniqueIDBDatabase->deleteIndex(IDBIdentifier(*this, transactionID), objectStoreID, indexID, [connection, requestID](bool success) {
211         connection->send(Messages::WebIDBServerConnection::DidDeleteIndex(requestID, success));
212     });
213 }
214
215 void DatabaseProcessIDBConnection::putRecord(uint64_t requestID, int64_t transactionID, int64_t objectStoreID, const WebCore::IDBKeyData& key, const IPC::DataReference& value, int64_t putMode, const Vector<int64_t>& indexIDs, const Vector<Vector<WebCore::IDBKeyData>>& indexKeys)
216 {
217     ASSERT(m_uniqueIDBDatabase);
218
219     LOG(IDB, "DatabaseProcess putRecord request ID %llu, object store id %lli", requestID, objectStoreID);
220     RefPtr<DatabaseProcessIDBConnection> connection(this);
221     m_uniqueIDBDatabase->putRecord(IDBIdentifier(*this, transactionID), objectStoreID, key, value, putMode, indexIDs, indexKeys, [connection, requestID](const IDBKeyData& keyData, uint32_t errorCode, const String& errorMessage) {
222         connection->send(Messages::WebIDBServerConnection::DidPutRecord(requestID, keyData, errorCode, errorMessage));
223     });
224 }
225
226 void DatabaseProcessIDBConnection::getRecord(uint64_t requestID, int64_t transactionID, int64_t objectStoreID, int64_t indexID, const IDBKeyRangeData& keyRange, int64_t cursorType)
227 {
228     ASSERT(m_uniqueIDBDatabase);
229
230     LOG(IDB, "DatabaseProcess getRecord request ID %llu, object store id %lli", requestID, objectStoreID);
231     RefPtr<DatabaseProcessIDBConnection> connection(this);
232     m_uniqueIDBDatabase->getRecord(IDBIdentifier(*this, transactionID), objectStoreID, indexID, keyRange, static_cast<IndexedDB::CursorType>(cursorType), [connection, requestID](const IDBGetResult& getResult, uint32_t errorCode, const String& errorMessage) {
233         connection->send(Messages::WebIDBServerConnection::DidGetRecord(requestID, getResult, errorCode, errorMessage));
234     });
235 }
236
237 void DatabaseProcessIDBConnection::openCursor(uint64_t requestID, int64_t transactionID, int64_t objectStoreID, int64_t indexID, int64_t cursorDirection, int64_t cursorType, int64_t taskType, const WebCore::IDBKeyRangeData& keyRangeData)
238 {
239     ASSERT(m_uniqueIDBDatabase);
240
241     LOG(IDB, "DatabaseProcess openCursor request ID %llu, object store id %lli", requestID, objectStoreID);
242     RefPtr<DatabaseProcessIDBConnection> connection(this);
243     m_uniqueIDBDatabase->openCursor(IDBIdentifier(*this, transactionID), objectStoreID, indexID, static_cast<IndexedDB::CursorDirection>(cursorDirection), static_cast<IndexedDB::CursorType>(cursorType), static_cast<IDBDatabaseBackend::TaskType>(taskType), keyRangeData, [connection, requestID](int64_t cursorID, uint32_t errorCode, const String& errorMessage) {
244         connection->send(Messages::WebIDBServerConnection::DidOpenCursor(requestID, cursorID, errorCode, errorMessage));
245     });
246 }
247
248 void DatabaseProcessIDBConnection::cursorAdvance(uint64_t requestID, int64_t cursorID, uint64_t count)
249 {
250     ASSERT(m_uniqueIDBDatabase);
251
252     LOG(IDB, "DatabaseProcess cursorAdvance request ID %llu, cursor id %lli", requestID, cursorID);
253     RefPtr<DatabaseProcessIDBConnection> connection(this);
254     m_uniqueIDBDatabase->cursorAdvance(IDBIdentifier(*this, cursorID), count, [connection, requestID](const IDBKeyData& resultKey, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
255         IPC::DataReference data = value ? IPC::DataReference(reinterpret_cast<const uint8_t*>(value->data()), value->size()) : IPC::DataReference();
256         connection->send(Messages::WebIDBServerConnection::DidAdvanceCursor(requestID, resultKey, primaryKey, data, errorCode, errorMessage));
257     });
258 }
259
260 void DatabaseProcessIDBConnection::cursorIterate(uint64_t requestID, int64_t cursorID, const IDBKeyData& key)
261 {
262     ASSERT(m_uniqueIDBDatabase);
263
264     LOG(IDB, "DatabaseProcess cursorIterate request ID %llu, cursor id %lli", requestID, cursorID);
265     RefPtr<DatabaseProcessIDBConnection> connection(this);
266     m_uniqueIDBDatabase->cursorIterate(IDBIdentifier(*this, cursorID), key, [connection, requestID](const IDBKeyData& resultKey, const IDBKeyData& primaryKey, PassRefPtr<SharedBuffer> value, uint32_t errorCode, const String& errorMessage) {
267         IPC::DataReference data = value ? IPC::DataReference(reinterpret_cast<const uint8_t*>(value->data()), value->size()) : IPC::DataReference();
268         connection->send(Messages::WebIDBServerConnection::DidIterateCursor(requestID, resultKey, primaryKey, data, errorCode, errorMessage));
269     });
270 }
271
272 IPC::Connection* DatabaseProcessIDBConnection::messageSenderConnection()
273 {
274     return m_connection->connection();
275 }
276
277 } // namespace WebKit
278
279 #endif // ENABLE(INDEXED_DATABASE) && ENABLE(DATABASE_PROCESS)