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
242
243
244
245
246
247
248
249
250
251
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_CHILD_INDEXED_DB_INDEXED_DB_DISPATCHER_H_
#define CONTENT_CHILD_INDEXED_DB_INDEXED_DB_DISPATCHER_H_
#include <map>
#include <vector>
#include "base/gtest_prod_util.h"
#include "base/id_map.h"
#include "base/memory/ref_counted.h"
#include "base/strings/nullable_string16.h"
#include "content/common/content_export.h"
#include "ipc/ipc_sync_message_filter.h"
#include "third_party/WebKit/public/platform/WebIDBCallbacks.h"
#include "third_party/WebKit/public/platform/WebIDBCursor.h"
#include "third_party/WebKit/public/platform/WebIDBDatabase.h"
#include "third_party/WebKit/public/platform/WebIDBDatabaseCallbacks.h"
#include "webkit/child/worker_task_runner.h"
struct IndexedDBDatabaseMetadata;
struct IndexedDBMsg_CallbacksSuccessCursorContinue_Params;
struct IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params;
struct IndexedDBMsg_CallbacksSuccessIDBCursor_Params;
struct IndexedDBMsg_CallbacksUpgradeNeeded_Params;
namespace blink {
class WebData;
}
namespace content {
class IndexedDBKey;
class IndexedDBKeyPath;
class IndexedDBKeyRange;
class WebIDBCursorImpl;
class WebIDBDatabaseImpl;
class ThreadSafeSender;
CONTENT_EXPORT extern const size_t kMaxIDBValueSizeInBytes;
// Handle the indexed db related communication for this context thread - the
// main thread and each worker thread have their own copies.
class CONTENT_EXPORT IndexedDBDispatcher
: public webkit_glue::WorkerTaskRunner::Observer {
public:
// Constructor made public to allow RenderThreadImpl to own a copy without
// failing a NOTREACHED in ThreadSpecificInstance in tests that instantiate
// two copies of RenderThreadImpl on the same thread. Everyone else probably
// wants to use ThreadSpecificInstance().
explicit IndexedDBDispatcher(ThreadSafeSender* thread_safe_sender);
virtual ~IndexedDBDispatcher();
// |thread_safe_sender| needs to be passed in because if the call leads to
// construction it will be needed.
static IndexedDBDispatcher* ThreadSpecificInstance(
ThreadSafeSender* thread_safe_sender);
// webkit_glue::WorkerTaskRunner::Observer implementation.
virtual void OnWorkerRunLoopStopped() OVERRIDE;
static blink::WebIDBMetadata ConvertMetadata(
const IndexedDBDatabaseMetadata& idb_metadata);
void OnMessageReceived(const IPC::Message& msg);
bool Send(IPC::Message* msg);
void RequestIDBFactoryGetDatabaseNames(
blink::WebIDBCallbacks* callbacks,
const std::string& database_identifier);
void RequestIDBFactoryOpen(
const base::string16& name,
int64 version,
int64 transaction_id,
blink::WebIDBCallbacks* callbacks,
blink::WebIDBDatabaseCallbacks* database_callbacks,
const std::string& database_identifier);
void RequestIDBFactoryDeleteDatabase(const base::string16& name,
blink::WebIDBCallbacks* callbacks,
const std::string& database_identifier);
void RequestIDBCursorAdvance(unsigned long count,
blink::WebIDBCallbacks* callbacks_ptr,
int32 ipc_cursor_id);
virtual void RequestIDBCursorContinue(const IndexedDBKey& key,
const IndexedDBKey& primary_key,
blink::WebIDBCallbacks* callbacks_ptr,
int32 ipc_cursor_id);
virtual void RequestIDBCursorPrefetch(int n,
blink::WebIDBCallbacks* callbacks_ptr,
int32 ipc_cursor_id);
void RequestIDBCursorPrefetchReset(int used_prefetches,
int unused_prefetches,
int32 ipc_cursor_id);
void RequestIDBDatabaseClose(int32 ipc_database_id,
int32 ipc_database_callbacks_id);
void RequestIDBDatabaseCreateTransaction(
int32 ipc_database_id,
int64 transaction_id,
blink::WebIDBDatabaseCallbacks* database_callbacks_ptr,
blink::WebVector<long long> object_store_ids,
unsigned short mode);
void RequestIDBDatabaseGet(int32 ipc_database_id,
int64 transaction_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKeyRange& key_range,
bool key_only,
blink::WebIDBCallbacks* callbacks);
void RequestIDBDatabasePut(
int32 ipc_database_id,
int64 transaction_id,
int64 object_store_id,
const blink::WebData& value,
const IndexedDBKey& key,
blink::WebIDBDatabase::PutMode put_mode,
blink::WebIDBCallbacks* callbacks,
const blink::WebVector<long long>& index_ids,
const blink::WebVector<blink::WebVector<blink::WebIDBKey> >&
index_keys);
void RequestIDBDatabaseOpenCursor(int32 ipc_database_id,
int64 transaction_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKeyRange& key_range,
unsigned short direction,
bool key_only,
blink::WebIDBDatabase::TaskType task_type,
blink::WebIDBCallbacks* callbacks);
void RequestIDBDatabaseCount(int32 ipc_database_id,
int64 transaction_id,
int64 object_store_id,
int64 index_id,
const IndexedDBKeyRange& key_range,
blink::WebIDBCallbacks* callbacks);
void RequestIDBDatabaseDeleteRange(int32 ipc_database_id,
int64 transaction_id,
int64 object_store_id,
const IndexedDBKeyRange& key_range,
blink::WebIDBCallbacks* callbacks);
void RequestIDBDatabaseClear(int32 ipc_database_id,
int64 transaction_id,
int64 object_store_id,
blink::WebIDBCallbacks* callbacks);
virtual void CursorDestroyed(int32 ipc_cursor_id);
void DatabaseDestroyed(int32 ipc_database_id);
private:
FRIEND_TEST_ALL_PREFIXES(IndexedDBDispatcherTest, ValueSizeTest);
static int32 CurrentWorkerId() {
return webkit_glue::WorkerTaskRunner::Instance()->CurrentWorkerId();
}
template <typename T>
void init_params(T& params, blink::WebIDBCallbacks* callbacks_ptr) {
scoped_ptr<blink::WebIDBCallbacks> callbacks(callbacks_ptr);
params.ipc_thread_id = CurrentWorkerId();
params.ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
}
// IDBCallback message handlers.
void OnSuccessIDBDatabase(int32 ipc_thread_id,
int32 ipc_callbacks_id,
int32 ipc_database_callbacks_id,
int32 ipc_object_id,
const IndexedDBDatabaseMetadata& idb_metadata);
void OnSuccessIndexedDBKey(int32 ipc_thread_id,
int32 ipc_callbacks_id,
const IndexedDBKey& key);
void OnSuccessOpenCursor(
const IndexedDBMsg_CallbacksSuccessIDBCursor_Params& p);
void OnSuccessCursorContinue(
const IndexedDBMsg_CallbacksSuccessCursorContinue_Params& p);
void OnSuccessCursorPrefetch(
const IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params& p);
void OnSuccessStringList(int32 ipc_thread_id,
int32 ipc_callbacks_id,
const std::vector<base::string16>& value);
void OnSuccessValue(int32 ipc_thread_id,
int32 ipc_callbacks_id,
const std::string& value);
void OnSuccessValueWithKey(int32 ipc_thread_id,
int32 ipc_callbacks_id,
const std::string& value,
const IndexedDBKey& primary_key,
const IndexedDBKeyPath& key_path);
void OnSuccessInteger(int32 ipc_thread_id,
int32 ipc_callbacks_id,
int64 value);
void OnSuccessUndefined(int32 ipc_thread_id, int32 ipc_callbacks_id);
void OnError(int32 ipc_thread_id,
int32 ipc_callbacks_id,
int code,
const base::string16& message);
void OnIntBlocked(int32 ipc_thread_id,
int32 ipc_callbacks_id,
int64 existing_version);
void OnUpgradeNeeded(const IndexedDBMsg_CallbacksUpgradeNeeded_Params& p);
void OnAbort(int32 ipc_thread_id,
int32 ipc_database_id,
int64 transaction_id,
int code,
const base::string16& message);
void OnComplete(int32 ipc_thread_id,
int32 ipc_database_id,
int64 transaction_id);
void OnForcedClose(int32 ipc_thread_id, int32 ipc_database_id);
void OnIntVersionChange(int32 ipc_thread_id,
int32 ipc_database_id,
int64 old_version,
int64 new_version);
// Reset cursor prefetch caches for all cursors except exception_cursor_id.
void ResetCursorPrefetchCaches(int32 ipc_exception_cursor_id = -1);
scoped_refptr<ThreadSafeSender> thread_safe_sender_;
// Careful! WebIDBCallbacks wraps non-threadsafe data types. It must be
// destroyed and used on the same thread it was created on.
IDMap<blink::WebIDBCallbacks, IDMapOwnPointer> pending_callbacks_;
IDMap<blink::WebIDBDatabaseCallbacks, IDMapOwnPointer>
pending_database_callbacks_;
// Map from cursor id to WebIDBCursorImpl.
std::map<int32, WebIDBCursorImpl*> cursors_;
std::map<int32, WebIDBDatabaseImpl*> databases_;
DISALLOW_COPY_AND_ASSIGN(IndexedDBDispatcher);
};
} // namespace content
#endif // CONTENT_CHILD_INDEXED_DB_INDEXED_DB_DISPATCHER_H_
|
