1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
* Copyright (C) 2015 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.
*/
#ifndef IDBTransactionImpl_h
#define IDBTransactionImpl_h
#if ENABLE(INDEXED_DATABASE)
#include "IDBDatabaseInfo.h"
#include "IDBError.h"
#include "IDBIndexImpl.h"
#include "IDBObjectStoreImpl.h"
#include "IDBTransaction.h"
#include "IDBTransactionInfo.h"
#include "IndexedDB.h"
#include "Timer.h"
#include <wtf/Deque.h>
#include <wtf/HashMap.h>
namespace WebCore {
class IDBCursorInfo;
class IDBIndexInfo;
class IDBKeyData;
class IDBObjectStoreInfo;
class IDBResultData;
struct IDBKeyRangeData;
namespace IDBClient {
class IDBCursor;
class IDBDatabase;
class IDBIndex;
class IDBOpenDBRequest;
class TransactionOperation;
class IDBTransaction : public WebCore::IDBTransaction {
public:
static Ref<IDBTransaction> create(IDBDatabase&, const IDBTransactionInfo&);
static Ref<IDBTransaction> create(IDBDatabase&, const IDBTransactionInfo&, IDBOpenDBRequest&);
virtual ~IDBTransaction() override final;
// IDBTransaction IDL
virtual const String& mode() const override final;
virtual WebCore::IDBDatabase* db() override final;
virtual RefPtr<DOMError> error() const override final;
virtual RefPtr<WebCore::IDBObjectStore> objectStore(const String& name, ExceptionCodeWithMessage&) override final;
virtual void abort(ExceptionCodeWithMessage&) override final;
virtual EventTargetInterface eventTargetInterface() const override final { return IDBTransactionEventTargetInterfaceType; }
virtual ScriptExecutionContext* scriptExecutionContext() const override final { return ActiveDOMObject::scriptExecutionContext(); }
virtual void refEventTarget() override final { ref(); }
virtual void derefEventTarget() override final { deref(); }
using EventTarget::dispatchEvent;
virtual bool dispatchEvent(Event&) override final;
virtual const char* activeDOMObjectName() const override final;
virtual bool canSuspendForDocumentSuspension() const override final;
virtual bool hasPendingActivity() const override final;
virtual void stop() override final;
const IDBTransactionInfo& info() const { return m_info; }
IDBDatabase& database() { return m_database.get(); }
const IDBDatabase& database() const { return m_database.get(); }
IDBDatabaseInfo* originalDatabaseInfo() const { return m_info.originalDatabaseInfo(); }
void didStart(const IDBError&);
void didAbort(const IDBError&);
void didCommit(const IDBError&);
bool isVersionChange() const { return m_info.mode() == IndexedDB::TransactionMode::VersionChange; }
bool isReadOnly() const { return m_info.mode() == IndexedDB::TransactionMode::ReadOnly; }
bool isActive() const;
Ref<IDBObjectStore> createObjectStore(const IDBObjectStoreInfo&);
std::unique_ptr<IDBIndex> createIndex(IDBObjectStore&, const IDBIndexInfo&);
Ref<IDBRequest> requestPutOrAdd(ScriptExecutionContext&, IDBObjectStore&, IDBKey*, SerializedScriptValue&, IndexedDB::ObjectStoreOverwriteMode);
Ref<IDBRequest> requestGetRecord(ScriptExecutionContext&, IDBObjectStore&, const IDBKeyRangeData&);
Ref<IDBRequest> requestDeleteRecord(ScriptExecutionContext&, IDBObjectStore&, const IDBKeyRangeData&);
Ref<IDBRequest> requestClearObjectStore(ScriptExecutionContext&, IDBObjectStore&);
Ref<IDBRequest> requestCount(ScriptExecutionContext&, IDBObjectStore&, const IDBKeyRangeData&);
Ref<IDBRequest> requestCount(ScriptExecutionContext&, IDBIndex&, const IDBKeyRangeData&);
Ref<IDBRequest> requestGetValue(ScriptExecutionContext&, IDBIndex&, const IDBKeyRangeData&);
Ref<IDBRequest> requestGetKey(ScriptExecutionContext&, IDBIndex&, const IDBKeyRangeData&);
Ref<IDBRequest> requestOpenCursor(ScriptExecutionContext&, IDBObjectStore&, const IDBCursorInfo&);
Ref<IDBRequest> requestOpenCursor(ScriptExecutionContext&, IDBIndex&, const IDBCursorInfo&);
void iterateCursor(IDBCursor&, const IDBKeyData&, unsigned long count);
void deleteObjectStore(const String& objectStoreName);
void deleteIndex(uint64_t objectStoreIdentifier, const String& indexName);
void addRequest(IDBRequest&);
void removeRequest(IDBRequest&);
void abortDueToFailedRequest(DOMError&);
IDBConnectionToServer& serverConnection();
void activate();
void deactivate();
void operationDidComplete(TransactionOperation&);
bool isFinishedOrFinishing() const;
bool isFinished() const { return m_state == IndexedDB::TransactionState::Finished; }
private:
IDBTransaction(IDBDatabase&, const IDBTransactionInfo&, IDBOpenDBRequest*);
void commit();
void notifyDidAbort(const IDBError&);
void finishAbortOrCommit();
void scheduleOperation(RefPtr<TransactionOperation>&&);
void operationTimerFired();
void fireOnComplete();
void fireOnAbort();
void enqueueEvent(Ref<Event>&&);
Ref<IDBRequest> requestIndexRecord(ScriptExecutionContext&, IDBIndex&, IndexedDB::IndexRecordType, const IDBKeyRangeData&);
void commitOnServer(TransactionOperation&);
void abortOnServerAndCancelRequests(TransactionOperation&);
void createObjectStoreOnServer(TransactionOperation&, const IDBObjectStoreInfo&);
void didCreateObjectStoreOnServer(const IDBResultData&);
void createIndexOnServer(TransactionOperation&, const IDBIndexInfo&);
void didCreateIndexOnServer(const IDBResultData&);
void clearObjectStoreOnServer(TransactionOperation&, const uint64_t& objectStoreIdentifier);
void didClearObjectStoreOnServer(IDBRequest&, const IDBResultData&);
void putOrAddOnServer(TransactionOperation&, RefPtr<IDBKey>, RefPtr<SerializedScriptValue>, const IndexedDB::ObjectStoreOverwriteMode&);
void didPutOrAddOnServer(IDBRequest&, const IDBResultData&);
void getRecordOnServer(TransactionOperation&, const IDBKeyRangeData&);
void didGetRecordOnServer(IDBRequest&, const IDBResultData&);
void getCountOnServer(TransactionOperation&, const IDBKeyRangeData&);
void didGetCountOnServer(IDBRequest&, const IDBResultData&);
void deleteRecordOnServer(TransactionOperation&, const IDBKeyRangeData&);
void didDeleteRecordOnServer(IDBRequest&, const IDBResultData&);
void deleteObjectStoreOnServer(TransactionOperation&, const String& objectStoreName);
void didDeleteObjectStoreOnServer(const IDBResultData&);
void deleteIndexOnServer(TransactionOperation&, const uint64_t& objectStoreIdentifier, const String& indexName);
void didDeleteIndexOnServer(const IDBResultData&);
Ref<IDBRequest> doRequestOpenCursor(ScriptExecutionContext&, Ref<IDBCursor>&&);
void openCursorOnServer(TransactionOperation&, const IDBCursorInfo&);
void didOpenCursorOnServer(IDBRequest&, const IDBResultData&);
void iterateCursorOnServer(TransactionOperation&, const IDBKeyData&, const unsigned long& count);
void didIterateCursorOnServer(IDBRequest&, const IDBResultData&);
void transitionedToFinishing(IndexedDB::TransactionState);
void establishOnServer();
void scheduleOperationTimer();
Ref<IDBDatabase> m_database;
IDBTransactionInfo m_info;
IndexedDB::TransactionState m_state { IndexedDB::TransactionState::Inactive };
bool m_startedOnServer { false };
IDBError m_idbError;
RefPtr<DOMError> m_domError;
Timer m_operationTimer;
std::unique_ptr<Timer> m_activationTimer;
RefPtr<IDBOpenDBRequest> m_openDBRequest;
Deque<RefPtr<TransactionOperation>> m_transactionOperationQueue;
Deque<RefPtr<TransactionOperation>> m_abortQueue;
HashMap<IDBResourceIdentifier, RefPtr<TransactionOperation>> m_transactionOperationMap;
HashMap<String, RefPtr<IDBObjectStore>> m_referencedObjectStores;
HashSet<RefPtr<IDBRequest>> m_openRequests;
bool m_contextStopped { false };
};
class TransactionActivator {
WTF_MAKE_NONCOPYABLE(TransactionActivator);
public:
TransactionActivator(IDBTransaction* transaction)
: m_transaction(transaction)
{
if (m_transaction)
m_transaction->activate();
}
~TransactionActivator()
{
if (m_transaction)
m_transaction->deactivate();
}
private:
IDBTransaction* m_transaction;
};
} // namespace IDBClient
} // namespace WebCore
#endif // ENABLE(INDEXED_DATABASE)
#endif // IDBTransactionImpl_h
|
