OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/child/indexed_db/indexed_db_callbacks_impl.h" | 5 #include "content/child/indexed_db/indexed_db_callbacks_impl.h" |
6 | 6 |
7 #include "content/child/indexed_db/indexed_db_dispatcher.h" | 7 #include "content/child/indexed_db/indexed_db_dispatcher.h" |
8 #include "content/child/indexed_db/indexed_db_key_builders.h" | 8 #include "content/child/indexed_db/indexed_db_key_builders.h" |
9 #include "content/child/indexed_db/webidbcursor_impl.h" | 9 #include "content/child/indexed_db/webidbcursor_impl.h" |
10 #include "content/child/indexed_db/webidbdatabase_impl.h" | 10 #include "content/child/indexed_db/webidbdatabase_impl.h" |
11 #include "content/child/thread_safe_sender.h" | |
12 #include "content/common/indexed_db/indexed_db_constants.h" | 11 #include "content/common/indexed_db/indexed_db_constants.h" |
13 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBCallbacks.h
" | 12 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBCallbacks.h
" |
14 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseErr
or.h" | 13 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseErr
or.h" |
15 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h" | 14 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h" |
16 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBValue.h" | 15 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBValue.h" |
17 | 16 |
18 using blink::WebBlobInfo; | 17 using blink::WebBlobInfo; |
19 using blink::WebIDBCallbacks; | 18 using blink::WebIDBCallbacks; |
20 using blink::WebIDBDatabase; | 19 using blink::WebIDBDatabase; |
21 using blink::WebIDBMetadata; | 20 using blink::WebIDBMetadata; |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 ConvertValue(value->value, web_value); | 92 ConvertValue(value->value, web_value); |
94 web_value->primaryKey = WebIDBKeyBuilder::Build(value->primary_key); | 93 web_value->primaryKey = WebIDBKeyBuilder::Build(value->primary_key); |
95 web_value->keyPath = WebIDBKeyPathBuilder::Build(value->key_path); | 94 web_value->keyPath = WebIDBKeyPathBuilder::Build(value->key_path); |
96 } | 95 } |
97 | 96 |
98 } // namespace | 97 } // namespace |
99 | 98 |
100 IndexedDBCallbacksImpl::IndexedDBCallbacksImpl( | 99 IndexedDBCallbacksImpl::IndexedDBCallbacksImpl( |
101 std::unique_ptr<WebIDBCallbacks> callbacks, | 100 std::unique_ptr<WebIDBCallbacks> callbacks, |
102 int64_t transaction_id, | 101 int64_t transaction_id, |
103 scoped_refptr<base::SingleThreadTaskRunner> io_runner, | 102 base::WeakPtr<WebIDBCursorImpl> cursor, |
104 scoped_refptr<ThreadSafeSender> thread_safe_sender) | 103 scoped_refptr<base::SingleThreadTaskRunner> io_runner) |
105 : internal_state_(new InternalState(std::move(callbacks), | 104 : internal_state_(new InternalState(std::move(callbacks), |
106 transaction_id, | 105 transaction_id, |
107 std::move(io_runner), | 106 cursor, |
108 std::move(thread_safe_sender))), | 107 std::move(io_runner))), |
109 callback_runner_(base::ThreadTaskRunnerHandle::Get()) {} | 108 callback_runner_(base::ThreadTaskRunnerHandle::Get()) {} |
110 | 109 |
111 IndexedDBCallbacksImpl::~IndexedDBCallbacksImpl() { | 110 IndexedDBCallbacksImpl::~IndexedDBCallbacksImpl() { |
112 callback_runner_->DeleteSoon(FROM_HERE, internal_state_); | 111 callback_runner_->DeleteSoon(FROM_HERE, internal_state_); |
113 } | 112 } |
114 | 113 |
115 void IndexedDBCallbacksImpl::Error(int32_t code, | 114 void IndexedDBCallbacksImpl::Error(int32_t code, |
116 const base::string16& message) { | 115 const base::string16& message) { |
117 callback_runner_->PostTask( | 116 callback_runner_->PostTask( |
118 FROM_HERE, base::Bind(&InternalState::Error, | 117 FROM_HERE, base::Bind(&InternalState::Error, |
(...skipping 29 matching lines...) Expand all Loading... |
148 | 147 |
149 void IndexedDBCallbacksImpl::SuccessDatabase( | 148 void IndexedDBCallbacksImpl::SuccessDatabase( |
150 DatabaseAssociatedPtrInfo database, | 149 DatabaseAssociatedPtrInfo database, |
151 const content::IndexedDBDatabaseMetadata& metadata) { | 150 const content::IndexedDBDatabaseMetadata& metadata) { |
152 callback_runner_->PostTask(FROM_HERE, | 151 callback_runner_->PostTask(FROM_HERE, |
153 base::Bind(&InternalState::SuccessDatabase, | 152 base::Bind(&InternalState::SuccessDatabase, |
154 base::Unretained(internal_state_), | 153 base::Unretained(internal_state_), |
155 base::Passed(&database), metadata)); | 154 base::Passed(&database), metadata)); |
156 } | 155 } |
157 | 156 |
158 void IndexedDBCallbacksImpl::SuccessCursor(int32_t cursor_id, | 157 void IndexedDBCallbacksImpl::SuccessCursor( |
159 const IndexedDBKey& key, | 158 indexed_db::mojom::CursorAssociatedPtrInfo cursor, |
160 const IndexedDBKey& primary_key, | 159 const IndexedDBKey& key, |
161 indexed_db::mojom::ValuePtr value) { | 160 const IndexedDBKey& primary_key, |
| 161 indexed_db::mojom::ValuePtr value) { |
162 callback_runner_->PostTask( | 162 callback_runner_->PostTask( |
163 FROM_HERE, base::Bind(&InternalState::SuccessCursor, | 163 FROM_HERE, |
164 base::Unretained(internal_state_), cursor_id, key, | 164 base::Bind(&InternalState::SuccessCursor, |
165 primary_key, base::Passed(&value))); | 165 base::Unretained(internal_state_), base::Passed(&cursor), key, |
| 166 primary_key, base::Passed(&value))); |
166 } | 167 } |
167 | 168 |
168 void IndexedDBCallbacksImpl::SuccessValue( | 169 void IndexedDBCallbacksImpl::SuccessValue( |
169 indexed_db::mojom::ReturnValuePtr value) { | 170 indexed_db::mojom::ReturnValuePtr value) { |
170 callback_runner_->PostTask( | 171 callback_runner_->PostTask( |
171 FROM_HERE, | 172 FROM_HERE, |
172 base::Bind(&InternalState::SuccessValue, | 173 base::Bind(&InternalState::SuccessValue, |
173 base::Unretained(internal_state_), base::Passed(&value))); | 174 base::Unretained(internal_state_), base::Passed(&value))); |
174 } | 175 } |
175 | 176 |
| 177 void IndexedDBCallbacksImpl::SuccessCursorContinue( |
| 178 const IndexedDBKey& key, |
| 179 const IndexedDBKey& primary_key, |
| 180 indexed_db::mojom::ValuePtr value) { |
| 181 callback_runner_->PostTask( |
| 182 FROM_HERE, base::Bind(&InternalState::SuccessCursorContinue, |
| 183 base::Unretained(internal_state_), key, primary_key, |
| 184 base::Passed(&value))); |
| 185 } |
| 186 |
| 187 void IndexedDBCallbacksImpl::SuccessCursorPrefetch( |
| 188 const std::vector<IndexedDBKey>& keys, |
| 189 const std::vector<IndexedDBKey>& primary_keys, |
| 190 std::vector<indexed_db::mojom::ValuePtr> values) { |
| 191 callback_runner_->PostTask(FROM_HERE, |
| 192 base::Bind(&InternalState::SuccessCursorPrefetch, |
| 193 base::Unretained(internal_state_), keys, |
| 194 primary_keys, base::Passed(&values))); |
| 195 } |
| 196 |
176 void IndexedDBCallbacksImpl::SuccessArray( | 197 void IndexedDBCallbacksImpl::SuccessArray( |
177 std::vector<indexed_db::mojom::ReturnValuePtr> values) { | 198 std::vector<indexed_db::mojom::ReturnValuePtr> values) { |
178 callback_runner_->PostTask( | 199 callback_runner_->PostTask( |
179 FROM_HERE, | 200 FROM_HERE, |
180 base::Bind(&InternalState::SuccessArray, | 201 base::Bind(&InternalState::SuccessArray, |
181 base::Unretained(internal_state_), base::Passed(&values))); | 202 base::Unretained(internal_state_), base::Passed(&values))); |
182 } | 203 } |
183 | 204 |
184 void IndexedDBCallbacksImpl::SuccessKey(const IndexedDBKey& key) { | 205 void IndexedDBCallbacksImpl::SuccessKey(const IndexedDBKey& key) { |
185 callback_runner_->PostTask( | 206 callback_runner_->PostTask( |
186 FROM_HERE, base::Bind(&InternalState::SuccessKey, | 207 FROM_HERE, base::Bind(&InternalState::SuccessKey, |
187 base::Unretained(internal_state_), key)); | 208 base::Unretained(internal_state_), key)); |
188 } | 209 } |
189 | 210 |
190 void IndexedDBCallbacksImpl::SuccessInteger(int64_t value) { | 211 void IndexedDBCallbacksImpl::SuccessInteger(int64_t value) { |
191 callback_runner_->PostTask( | 212 callback_runner_->PostTask( |
192 FROM_HERE, base::Bind(&InternalState::SuccessInteger, | 213 FROM_HERE, base::Bind(&InternalState::SuccessInteger, |
193 base::Unretained(internal_state_), value)); | 214 base::Unretained(internal_state_), value)); |
194 } | 215 } |
195 | 216 |
196 void IndexedDBCallbacksImpl::Success() { | 217 void IndexedDBCallbacksImpl::Success() { |
197 callback_runner_->PostTask( | 218 callback_runner_->PostTask( |
198 FROM_HERE, | 219 FROM_HERE, |
199 base::Bind(&InternalState::Success, base::Unretained(internal_state_))); | 220 base::Bind(&InternalState::Success, base::Unretained(internal_state_))); |
200 } | 221 } |
201 | 222 |
202 IndexedDBCallbacksImpl::InternalState::InternalState( | 223 IndexedDBCallbacksImpl::InternalState::InternalState( |
203 std::unique_ptr<blink::WebIDBCallbacks> callbacks, | 224 std::unique_ptr<blink::WebIDBCallbacks> callbacks, |
204 int64_t transaction_id, | 225 int64_t transaction_id, |
205 scoped_refptr<base::SingleThreadTaskRunner> io_runner, | 226 base::WeakPtr<WebIDBCursorImpl> cursor, |
206 scoped_refptr<ThreadSafeSender> thread_safe_sender) | 227 scoped_refptr<base::SingleThreadTaskRunner> io_runner) |
207 : callbacks_(std::move(callbacks)), | 228 : callbacks_(std::move(callbacks)), |
208 transaction_id_(transaction_id), | 229 transaction_id_(transaction_id), |
209 io_runner_(std::move(io_runner)), | 230 cursor_(cursor), |
210 thread_safe_sender_(std::move(thread_safe_sender)) { | 231 io_runner_(std::move(io_runner)) { |
211 IndexedDBDispatcher* dispatcher = | 232 IndexedDBDispatcher::ThreadSpecificInstance()->RegisterMojoOwnedCallbacks( |
212 IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get()); | 233 this); |
213 dispatcher->RegisterMojoOwnedCallbacks(this); | |
214 } | 234 } |
215 | 235 |
216 IndexedDBCallbacksImpl::InternalState::~InternalState() { | 236 IndexedDBCallbacksImpl::InternalState::~InternalState() { |
217 IndexedDBDispatcher* dispatcher = | 237 IndexedDBDispatcher::ThreadSpecificInstance()->UnregisterMojoOwnedCallbacks( |
218 IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get()); | 238 this); |
219 dispatcher->UnregisterMojoOwnedCallbacks(this); | |
220 } | 239 } |
221 | 240 |
222 void IndexedDBCallbacksImpl::InternalState::Error( | 241 void IndexedDBCallbacksImpl::InternalState::Error( |
223 int32_t code, | 242 int32_t code, |
224 const base::string16& message) { | 243 const base::string16& message) { |
225 callbacks_->onError(blink::WebIDBDatabaseError(code, message)); | 244 callbacks_->onError(blink::WebIDBDatabaseError(code, message)); |
226 callbacks_.reset(); | 245 callbacks_.reset(); |
227 } | 246 } |
228 | 247 |
229 void IndexedDBCallbacksImpl::InternalState::SuccessStringList( | 248 void IndexedDBCallbacksImpl::InternalState::SuccessStringList( |
230 const std::vector<base::string16>& value) { | 249 const std::vector<base::string16>& value) { |
231 callbacks_->onSuccess(WebVector<WebString>(value)); | 250 callbacks_->onSuccess(WebVector<WebString>(value)); |
232 callbacks_.reset(); | 251 callbacks_.reset(); |
233 } | 252 } |
234 | 253 |
235 void IndexedDBCallbacksImpl::InternalState::Blocked(int64_t existing_version) { | 254 void IndexedDBCallbacksImpl::InternalState::Blocked(int64_t existing_version) { |
236 callbacks_->onBlocked(existing_version); | 255 callbacks_->onBlocked(existing_version); |
237 // Not resetting |callbacks_|. | 256 // Not resetting |callbacks_|. |
238 } | 257 } |
239 | 258 |
240 void IndexedDBCallbacksImpl::InternalState::UpgradeNeeded( | 259 void IndexedDBCallbacksImpl::InternalState::UpgradeNeeded( |
241 DatabaseAssociatedPtrInfo database_info, | 260 DatabaseAssociatedPtrInfo database_info, |
242 int64_t old_version, | 261 int64_t old_version, |
243 blink::WebIDBDataLoss data_loss, | 262 blink::WebIDBDataLoss data_loss, |
244 const std::string& data_loss_message, | 263 const std::string& data_loss_message, |
245 const content::IndexedDBDatabaseMetadata& metadata) { | 264 const content::IndexedDBDatabaseMetadata& metadata) { |
246 WebIDBDatabase* database = new WebIDBDatabaseImpl( | 265 WebIDBDatabase* database = |
247 std::move(database_info), io_runner_, thread_safe_sender_); | 266 new WebIDBDatabaseImpl(std::move(database_info), io_runner_); |
248 WebIDBMetadata web_metadata; | 267 WebIDBMetadata web_metadata; |
249 ConvertDatabaseMetadata(metadata, &web_metadata); | 268 ConvertDatabaseMetadata(metadata, &web_metadata); |
250 callbacks_->onUpgradeNeeded(old_version, database, web_metadata, data_loss, | 269 callbacks_->onUpgradeNeeded(old_version, database, web_metadata, data_loss, |
251 WebString::fromUTF8(data_loss_message)); | 270 WebString::fromUTF8(data_loss_message)); |
252 // Not resetting |callbacks_|. | 271 // Not resetting |callbacks_|. |
253 } | 272 } |
254 | 273 |
255 void IndexedDBCallbacksImpl::InternalState::SuccessDatabase( | 274 void IndexedDBCallbacksImpl::InternalState::SuccessDatabase( |
256 DatabaseAssociatedPtrInfo database_info, | 275 DatabaseAssociatedPtrInfo database_info, |
257 const content::IndexedDBDatabaseMetadata& metadata) { | 276 const content::IndexedDBDatabaseMetadata& metadata) { |
258 WebIDBDatabase* database = nullptr; | 277 WebIDBDatabase* database = nullptr; |
259 if (database_info.is_valid()) { | 278 if (database_info.is_valid()) |
260 database = new WebIDBDatabaseImpl(std::move(database_info), io_runner_, | 279 database = new WebIDBDatabaseImpl(std::move(database_info), io_runner_); |
261 thread_safe_sender_); | 280 |
262 } | |
263 WebIDBMetadata web_metadata; | 281 WebIDBMetadata web_metadata; |
264 ConvertDatabaseMetadata(metadata, &web_metadata); | 282 ConvertDatabaseMetadata(metadata, &web_metadata); |
265 callbacks_->onSuccess(database, web_metadata); | 283 callbacks_->onSuccess(database, web_metadata); |
266 callbacks_.reset(); | 284 callbacks_.reset(); |
267 } | 285 } |
268 | 286 |
269 void IndexedDBCallbacksImpl::InternalState::SuccessCursor( | 287 void IndexedDBCallbacksImpl::InternalState::SuccessCursor( |
270 int32_t cursor_id, | 288 indexed_db::mojom::CursorAssociatedPtrInfo cursor_info, |
271 const IndexedDBKey& key, | 289 const IndexedDBKey& key, |
272 const IndexedDBKey& primary_key, | 290 const IndexedDBKey& primary_key, |
273 indexed_db::mojom::ValuePtr value) { | 291 indexed_db::mojom::ValuePtr value) { |
274 WebIDBValue web_value; | 292 WebIDBValue web_value; |
275 if (value) | 293 if (value) |
276 ConvertValue(value, &web_value); | 294 ConvertValue(value, &web_value); |
277 | 295 |
278 WebIDBCursorImpl* cursor = new WebIDBCursorImpl(cursor_id, transaction_id_, | 296 WebIDBCursorImpl* cursor = |
279 thread_safe_sender_.get()); | 297 new WebIDBCursorImpl(std::move(cursor_info), transaction_id_, io_runner_); |
280 IndexedDBDispatcher* dispatcher = | |
281 IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get()); | |
282 dispatcher->RegisterCursor(cursor_id, cursor); | |
283 callbacks_->onSuccess(cursor, WebIDBKeyBuilder::Build(key), | 298 callbacks_->onSuccess(cursor, WebIDBKeyBuilder::Build(key), |
284 WebIDBKeyBuilder::Build(primary_key), web_value); | 299 WebIDBKeyBuilder::Build(primary_key), web_value); |
285 callbacks_.reset(); | 300 callbacks_.reset(); |
286 } | 301 } |
287 | 302 |
288 void IndexedDBCallbacksImpl::InternalState::SuccessKey( | 303 void IndexedDBCallbacksImpl::InternalState::SuccessKey( |
289 const IndexedDBKey& key) { | 304 const IndexedDBKey& key) { |
290 callbacks_->onSuccess(WebIDBKeyBuilder::Build(key)); | 305 callbacks_->onSuccess(WebIDBKeyBuilder::Build(key)); |
291 callbacks_.reset(); | 306 callbacks_.reset(); |
292 } | 307 } |
293 | 308 |
294 void IndexedDBCallbacksImpl::InternalState::SuccessValue( | 309 void IndexedDBCallbacksImpl::InternalState::SuccessValue( |
295 indexed_db::mojom::ReturnValuePtr value) { | 310 indexed_db::mojom::ReturnValuePtr value) { |
296 WebIDBValue web_value; | 311 WebIDBValue web_value; |
297 if (value) | 312 if (value) |
298 ConvertReturnValue(value, &web_value); | 313 ConvertReturnValue(value, &web_value); |
299 callbacks_->onSuccess(web_value); | 314 callbacks_->onSuccess(web_value); |
300 callbacks_.reset(); | 315 callbacks_.reset(); |
301 } | 316 } |
302 | 317 |
| 318 void IndexedDBCallbacksImpl::InternalState::SuccessCursorContinue( |
| 319 const IndexedDBKey& key, |
| 320 const IndexedDBKey& primary_key, |
| 321 indexed_db::mojom::ValuePtr value) { |
| 322 WebIDBValue web_value; |
| 323 if (value) |
| 324 ConvertValue(value, &web_value); |
| 325 callbacks_->onSuccess(WebIDBKeyBuilder::Build(key), |
| 326 WebIDBKeyBuilder::Build(primary_key), web_value); |
| 327 callbacks_.reset(); |
| 328 } |
| 329 |
| 330 void IndexedDBCallbacksImpl::InternalState::SuccessCursorPrefetch( |
| 331 const std::vector<IndexedDBKey>& keys, |
| 332 const std::vector<IndexedDBKey>& primary_keys, |
| 333 std::vector<indexed_db::mojom::ValuePtr> values) { |
| 334 std::vector<WebIDBValue> web_values(values.size()); |
| 335 for (size_t i = 0; i < values.size(); ++i) |
| 336 ConvertValue(values[i], &web_values[i]); |
| 337 |
| 338 if (cursor_) { |
| 339 cursor_->SetPrefetchData(keys, primary_keys, web_values); |
| 340 cursor_->CachedContinue(callbacks_.get()); |
| 341 } |
| 342 callbacks_.reset(); |
| 343 } |
| 344 |
303 void IndexedDBCallbacksImpl::InternalState::SuccessArray( | 345 void IndexedDBCallbacksImpl::InternalState::SuccessArray( |
304 std::vector<indexed_db::mojom::ReturnValuePtr> values) { | 346 std::vector<indexed_db::mojom::ReturnValuePtr> values) { |
305 blink::WebVector<WebIDBValue> web_values(values.size()); | 347 blink::WebVector<WebIDBValue> web_values(values.size()); |
306 for (size_t i = 0; i < values.size(); ++i) | 348 for (size_t i = 0; i < values.size(); ++i) |
307 ConvertReturnValue(values[i], &web_values[i]); | 349 ConvertReturnValue(values[i], &web_values[i]); |
308 callbacks_->onSuccess(web_values); | 350 callbacks_->onSuccess(web_values); |
309 callbacks_.reset(); | 351 callbacks_.reset(); |
310 } | 352 } |
311 | 353 |
312 void IndexedDBCallbacksImpl::InternalState::SuccessInteger(int64_t value) { | 354 void IndexedDBCallbacksImpl::InternalState::SuccessInteger(int64_t value) { |
313 callbacks_->onSuccess(value); | 355 callbacks_->onSuccess(value); |
314 callbacks_.reset(); | 356 callbacks_.reset(); |
315 } | 357 } |
316 | 358 |
317 void IndexedDBCallbacksImpl::InternalState::Success() { | 359 void IndexedDBCallbacksImpl::InternalState::Success() { |
318 callbacks_->onSuccess(); | 360 callbacks_->onSuccess(); |
319 callbacks_.reset(); | 361 callbacks_.reset(); |
320 } | 362 } |
321 | 363 |
322 } // namespace content | 364 } // namespace content |
OLD | NEW |