OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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/browser/indexed_db/indexed_db_callbacks.h" | 5 #include "content/browser/indexed_db/indexed_db_callbacks.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/guid.h" | |
10 #include "base/strings/utf_string_conversions.h" | |
11 #include "base/time/time.h" | |
12 #include "content/browser/child_process_security_policy_impl.h" | |
13 #include "content/browser/fileapi/fileapi_message_filter.h" | |
14 #include "content/browser/indexed_db/indexed_db_blob_info.h" | |
9 #include "content/browser/indexed_db/indexed_db_connection.h" | 15 #include "content/browser/indexed_db/indexed_db_connection.h" |
16 #include "content/browser/indexed_db/indexed_db_context_impl.h" | |
10 #include "content/browser/indexed_db/indexed_db_cursor.h" | 17 #include "content/browser/indexed_db/indexed_db_cursor.h" |
11 #include "content/browser/indexed_db/indexed_db_database_callbacks.h" | 18 #include "content/browser/indexed_db/indexed_db_database_callbacks.h" |
12 #include "content/browser/indexed_db/indexed_db_database_error.h" | 19 #include "content/browser/indexed_db/indexed_db_database_error.h" |
13 #include "content/browser/indexed_db/indexed_db_metadata.h" | 20 #include "content/browser/indexed_db/indexed_db_metadata.h" |
14 #include "content/browser/indexed_db/indexed_db_value.h" | 21 #include "content/browser/indexed_db/indexed_db_value.h" |
15 #include "content/common/indexed_db/indexed_db_constants.h" | 22 #include "content/common/indexed_db/indexed_db_constants.h" |
16 #include "content/common/indexed_db/indexed_db_messages.h" | 23 #include "content/common/indexed_db/indexed_db_messages.h" |
24 #include "webkit/browser/blob/blob_storage_context.h" | |
17 #include "webkit/browser/quota/quota_manager.h" | 25 #include "webkit/browser/quota/quota_manager.h" |
26 #include "webkit/common/blob/blob_data.h" | |
27 #include "webkit/common/blob/shareable_file_reference.h" | |
28 | |
29 using webkit_blob::ShareableFileReference; | |
18 | 30 |
19 namespace content { | 31 namespace content { |
20 | 32 |
21 namespace { | 33 namespace { |
22 const int32 kNoCursor = -1; | 34 const int32 kNoCursor = -1; |
23 const int32 kNoDatabaseCallbacks = -1; | 35 const int32 kNoDatabaseCallbacks = -1; |
24 const int64 kNoTransaction = -1; | 36 const int64 kNoTransaction = -1; |
25 } | 37 } |
26 | 38 |
27 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host, | 39 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host, |
(...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
162 | 174 |
163 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBDatabase( | 175 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBDatabase( |
164 ipc_thread_id_, | 176 ipc_thread_id_, |
165 ipc_callbacks_id_, | 177 ipc_callbacks_id_, |
166 ipc_database_callbacks_id_, | 178 ipc_database_callbacks_id_, |
167 ipc_object_id, | 179 ipc_object_id, |
168 IndexedDBDispatcherHost::ConvertMetadata(metadata))); | 180 IndexedDBDispatcherHost::ConvertMetadata(metadata))); |
169 dispatcher_host_ = NULL; | 181 dispatcher_host_ = NULL; |
170 } | 182 } |
171 | 183 |
184 static std::string CreateBlobData( | |
185 const IndexedDBBlobInfo& blob_info, | |
186 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, | |
187 webkit_blob::BlobStorageContext* blob_storage_context, | |
188 base::TaskRunner* task_runner) { | |
189 scoped_refptr<ShareableFileReference> shareable_file = | |
190 ShareableFileReference::Get(blob_info.file_path()); | |
cmumford
2014/04/17 18:07:57
Why do your own "Get" before calling "GetOrCreate"
ericu
2014/04/17 21:36:29
We only want the callback to get called once. If
| |
191 if (!shareable_file.get()) { | |
192 shareable_file = ShareableFileReference::GetOrCreate( | |
193 blob_info.file_path(), | |
194 ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE, | |
195 task_runner); | |
196 shareable_file->AddFinalReleaseCallback(blob_info.release_callback()); | |
197 } | |
198 | |
199 std::string uuid(base::GenerateGUID()); | |
200 scoped_refptr<webkit_blob::BlobData> blob_data = | |
201 new webkit_blob::BlobData(uuid); | |
202 blob_data->AppendFile( | |
203 blob_info.file_path(), 0, blob_info.size(), blob_info.last_modified()); | |
204 scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle( | |
205 blob_storage_context->AddFinishedBlob(blob_data.get())); | |
206 dispatcher_host->HoldBlobDataHandle(uuid, blob_data_handle); | |
207 | |
208 return uuid; | |
209 } | |
210 | |
211 static bool CreateAllBlobs( | |
212 const std::vector<IndexedDBBlobInfo>& blob_info, | |
213 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info, | |
214 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host) { | |
215 size_t i; | |
216 if (!dispatcher_host->blob_storage_context()) | |
217 return false; | |
218 for (i = 0; i < blob_info.size(); ++i) { | |
219 (*blob_or_file_info)[i].uuid = | |
cmumford
2014/04/17 18:07:57
I see below the contract is that blob_or_file_info
ericu
2014/04/17 21:36:29
Done.
| |
220 CreateBlobData(blob_info[i], | |
221 dispatcher_host, | |
222 dispatcher_host->blob_storage_context(), | |
223 dispatcher_host->Context()->TaskRunner()); | |
224 } | |
225 return true; | |
226 } | |
227 | |
228 static void BlobLookupForIDBCursor( | |
jsbell
2014/04/17 18:22:22
Can this be made a template function on <ParamsTyp
ericu
2014/04/17 21:36:29
Done.
| |
229 IndexedDBMsg_CallbacksSuccessIDBCursor_Params* params, | |
cmumford
2014/04/17 18:07:57
Can we make this param reference type to simplify?
ericu
2014/04/17 21:36:29
I think that leads to an extra copy due to the bin
| |
230 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, | |
231 const std::vector<IndexedDBBlobInfo>& blob_info, | |
232 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { | |
233 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
234 if (CreateAllBlobs(blob_info, blob_or_file_info, dispatcher_host)) | |
235 dispatcher_host->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(*params)); | |
236 } | |
237 | |
238 static void BlobLookupForCursorContinue( | |
239 IndexedDBMsg_CallbacksSuccessCursorContinue_Params* params, | |
240 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, | |
241 const std::vector<IndexedDBBlobInfo>& blob_info, | |
242 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { | |
243 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
244 if (CreateAllBlobs(blob_info, blob_or_file_info, dispatcher_host)) | |
245 dispatcher_host->Send( | |
246 new IndexedDBMsg_CallbacksSuccessCursorContinue(*params)); | |
247 } | |
248 | |
249 static void BlobLookupForValueWithKey( | |
250 IndexedDBMsg_CallbacksSuccessValueWithKey_Params* params, | |
251 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, | |
252 const std::vector<IndexedDBBlobInfo>& blob_info, | |
253 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { | |
254 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
255 if (CreateAllBlobs(blob_info, blob_or_file_info, dispatcher_host)) | |
256 dispatcher_host->Send( | |
257 new IndexedDBMsg_CallbacksSuccessValueWithKey(*params)); | |
258 } | |
259 | |
260 static void BlobLookupForValue( | |
261 IndexedDBMsg_CallbacksSuccessValue_Params* params, | |
262 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, | |
263 const std::vector<IndexedDBBlobInfo>& blob_info, | |
264 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { | |
265 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
266 if (CreateAllBlobs(blob_info, blob_or_file_info, dispatcher_host)) | |
267 dispatcher_host->Send(new IndexedDBMsg_CallbacksSuccessValue(*params)); | |
268 } | |
269 | |
270 static void BlobLookupForCursorPrefetch( | |
271 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params* params, | |
272 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, | |
273 const std::vector<IndexedDBValue>& values, | |
274 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >* | |
275 blob_or_file_infos) { | |
276 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
277 DCHECK(values.size() == blob_or_file_infos->size()); | |
cmumford
2014/04/17 18:07:57
I'd dup/move this DCHECK to CreateAllBlobs. Also c
ericu
2014/04/17 21:36:29
CreateAllBlobs gets a single value at a time, not
| |
278 | |
279 std::vector<IndexedDBValue>::const_iterator value_iter; | |
280 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >::iterator blob_iter; | |
281 for (value_iter = values.begin(), blob_iter = blob_or_file_infos->begin(); | |
282 value_iter != values.end(); | |
283 ++value_iter, ++blob_iter) { | |
284 if (!CreateAllBlobs(value_iter->blob_info, &*blob_iter, dispatcher_host)) | |
285 return; | |
286 } | |
287 dispatcher_host->Send( | |
288 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params)); | |
289 } | |
290 | |
291 static void FillInBlobData( | |
292 const std::vector<IndexedDBBlobInfo>& blob_info, | |
293 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { | |
294 for (std::vector<IndexedDBBlobInfo>::const_iterator iter = blob_info.begin(); | |
295 iter != blob_info.end(); | |
296 ++iter) { | |
297 if (iter->is_file()) { | |
298 IndexedDBMsg_BlobOrFileInfo info; | |
cmumford
2014/04/17 18:07:57
Where is uuid initialized?
ericu
2014/04/17 21:36:29
In CreateAllBlobs, called from the closure that ge
| |
299 info.is_file = true; | |
300 info.mime_type = iter->type(); | |
301 info.file_name = iter->file_name(); | |
302 info.file_path = iter->file_path().AsUTF16Unsafe(); | |
303 DCHECK_NE(-1, iter->size()); | |
304 info.size = iter->size(); | |
305 info.last_modified = iter->last_modified().ToDoubleT(); | |
306 blob_or_file_info->push_back(info); | |
307 } else { | |
308 IndexedDBMsg_BlobOrFileInfo info; | |
309 info.mime_type = iter->type(); | |
310 info.size = iter->size(); | |
311 blob_or_file_info->push_back(info); | |
312 } | |
313 } | |
314 } | |
315 | |
316 void IndexedDBCallbacks::RegisterBlobsAndSend( | |
317 const std::vector<IndexedDBBlobInfo>& blob_info, | |
318 const base::Closure& callback) { | |
319 std::vector<IndexedDBBlobInfo>::const_iterator iter; | |
320 for (iter = blob_info.begin(); iter != blob_info.end(); ++iter) { | |
321 iter->mark_used_callback().Run(); | |
322 } | |
323 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO)); | |
324 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback); | |
325 } | |
326 | |
172 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor, | 327 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor, |
173 const IndexedDBKey& key, | 328 const IndexedDBKey& key, |
174 const IndexedDBKey& primary_key, | 329 const IndexedDBKey& primary_key, |
175 IndexedDBValue* value) { | 330 IndexedDBValue* value) { |
176 DCHECK(dispatcher_host_.get()); | 331 DCHECK(dispatcher_host_.get()); |
177 | 332 |
178 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 333 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
179 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 334 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
180 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 335 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
181 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 336 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
182 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 337 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
183 | 338 |
184 int32 ipc_object_id = dispatcher_host_->Add(cursor.get()); | 339 int32 ipc_object_id = dispatcher_host_->Add(cursor.get()); |
185 IndexedDBMsg_CallbacksSuccessIDBCursor_Params params; | 340 scoped_ptr<IndexedDBMsg_CallbacksSuccessIDBCursor_Params> params( |
186 params.ipc_thread_id = ipc_thread_id_; | 341 new IndexedDBMsg_CallbacksSuccessIDBCursor_Params()); |
187 params.ipc_callbacks_id = ipc_callbacks_id_; | 342 params->ipc_thread_id = ipc_thread_id_; |
188 params.ipc_cursor_id = ipc_object_id; | 343 params->ipc_callbacks_id = ipc_callbacks_id_; |
189 params.key = key; | 344 params->ipc_cursor_id = ipc_object_id; |
190 params.primary_key = primary_key; | 345 params->key = key; |
346 params->primary_key = primary_key; | |
191 if (value && !value->empty()) | 347 if (value && !value->empty()) |
192 std::swap(params.value, value->bits); | 348 std::swap(params->value, value->bits); |
193 // TODO(alecflett): Avoid a copy here: the whole params object is | 349 // TODO(alecflett): Avoid a copy here: the whole params object is |
194 // being copied into the message. | 350 // being copied into the message. |
195 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(params)); | 351 if (!value || value->blob_info.empty()) { |
jsbell
2014/04/17 18:22:22
Can callback messages ever end up re-ordered now?
ericu
2014/04/17 21:36:29
There's no extra hop. The new code jumps over ear
jsbell
2014/04/17 21:46:50
Groovy. I'd thought it was sent on the IO thread t
| |
196 | 352 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(*params)); |
353 } else { | |
354 IndexedDBMsg_CallbacksSuccessIDBCursor_Params* p = params.get(); | |
355 FillInBlobData(value->blob_info, &p->blob_or_file_info); | |
356 RegisterBlobsAndSend(value->blob_info, | |
357 base::Bind(BlobLookupForIDBCursor, | |
358 base::Owned(params.release()), | |
359 dispatcher_host_, | |
360 value->blob_info, | |
361 base::Unretained(&p->blob_or_file_info))); | |
362 } | |
197 dispatcher_host_ = NULL; | 363 dispatcher_host_ = NULL; |
198 } | 364 } |
199 | 365 |
200 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key, | 366 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key, |
201 const IndexedDBKey& primary_key, | 367 const IndexedDBKey& primary_key, |
202 IndexedDBValue* value) { | 368 IndexedDBValue* value) { |
203 DCHECK(dispatcher_host_.get()); | 369 DCHECK(dispatcher_host_.get()); |
204 | 370 |
205 DCHECK_NE(kNoCursor, ipc_cursor_id_); | 371 DCHECK_NE(kNoCursor, ipc_cursor_id_); |
206 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 372 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
207 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 373 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
208 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 374 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
209 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 375 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
210 | 376 |
211 IndexedDBCursor* idb_cursor = | 377 IndexedDBCursor* idb_cursor = |
212 dispatcher_host_->GetCursorFromId(ipc_cursor_id_); | 378 dispatcher_host_->GetCursorFromId(ipc_cursor_id_); |
213 | 379 |
214 DCHECK(idb_cursor); | 380 DCHECK(idb_cursor); |
215 if (!idb_cursor) | 381 if (!idb_cursor) |
216 return; | 382 return; |
217 IndexedDBMsg_CallbacksSuccessCursorContinue_Params params; | 383 |
218 params.ipc_thread_id = ipc_thread_id_; | 384 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorContinue_Params> params( |
219 params.ipc_callbacks_id = ipc_callbacks_id_; | 385 new IndexedDBMsg_CallbacksSuccessCursorContinue_Params()); |
220 params.ipc_cursor_id = ipc_cursor_id_; | 386 params->ipc_thread_id = ipc_thread_id_; |
221 params.key = key; | 387 params->ipc_callbacks_id = ipc_callbacks_id_; |
222 params.primary_key = primary_key; | 388 params->ipc_cursor_id = ipc_cursor_id_; |
389 params->key = key; | |
390 params->primary_key = primary_key; | |
223 if (value && !value->empty()) | 391 if (value && !value->empty()) |
224 std::swap(params.value, value->bits); | 392 std::swap(params->value, value->bits); |
225 // TODO(alecflett): Avoid a copy here: the whole params object is | 393 // TODO(alecflett): Avoid a copy here: the whole params object is |
226 // being copied into the message. | 394 // being copied into the message. |
227 dispatcher_host_->Send( | 395 if (!value || value->blob_info.empty()) { |
228 new IndexedDBMsg_CallbacksSuccessCursorContinue(params)); | 396 dispatcher_host_->Send( |
397 new IndexedDBMsg_CallbacksSuccessCursorContinue(*params)); | |
398 } else { | |
399 IndexedDBMsg_CallbacksSuccessCursorContinue_Params* p = params.get(); | |
400 FillInBlobData(value->blob_info, &p->blob_or_file_info); | |
401 RegisterBlobsAndSend(value->blob_info, | |
402 base::Bind(BlobLookupForCursorContinue, | |
403 base::Owned(params.release()), | |
404 dispatcher_host_, | |
405 value->blob_info, | |
406 base::Unretained(&p->blob_or_file_info))); | |
407 } | |
229 dispatcher_host_ = NULL; | 408 dispatcher_host_ = NULL; |
230 } | 409 } |
231 | 410 |
232 void IndexedDBCallbacks::OnSuccessWithPrefetch( | 411 void IndexedDBCallbacks::OnSuccessWithPrefetch( |
233 const std::vector<IndexedDBKey>& keys, | 412 const std::vector<IndexedDBKey>& keys, |
234 const std::vector<IndexedDBKey>& primary_keys, | 413 const std::vector<IndexedDBKey>& primary_keys, |
235 const std::vector<IndexedDBValue>& values) { | 414 std::vector<IndexedDBValue>& values) { |
236 DCHECK_EQ(keys.size(), primary_keys.size()); | 415 DCHECK_EQ(keys.size(), primary_keys.size()); |
237 DCHECK_EQ(keys.size(), values.size()); | 416 DCHECK_EQ(keys.size(), values.size()); |
238 | 417 |
239 DCHECK(dispatcher_host_.get()); | 418 DCHECK(dispatcher_host_.get()); |
240 | 419 |
241 DCHECK_NE(kNoCursor, ipc_cursor_id_); | 420 DCHECK_NE(kNoCursor, ipc_cursor_id_); |
242 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 421 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
243 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 422 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
244 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 423 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
245 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 424 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
246 | 425 |
247 std::vector<IndexedDBKey> msgKeys; | 426 std::vector<IndexedDBKey> msgKeys; |
248 std::vector<IndexedDBKey> msgPrimaryKeys; | 427 std::vector<IndexedDBKey> msgPrimaryKeys; |
249 | 428 |
250 for (size_t i = 0; i < keys.size(); ++i) { | 429 for (size_t i = 0; i < keys.size(); ++i) { |
251 msgKeys.push_back(keys[i]); | 430 msgKeys.push_back(keys[i]); |
252 msgPrimaryKeys.push_back(primary_keys[i]); | 431 msgPrimaryKeys.push_back(primary_keys[i]); |
253 } | 432 } |
254 | 433 |
255 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params params; | 434 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params> params( |
256 params.ipc_thread_id = ipc_thread_id_; | 435 new IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params()); |
257 params.ipc_callbacks_id = ipc_callbacks_id_; | 436 params->ipc_thread_id = ipc_thread_id_; |
258 params.ipc_cursor_id = ipc_cursor_id_; | 437 params->ipc_callbacks_id = ipc_callbacks_id_; |
259 params.keys = msgKeys; | 438 params->ipc_cursor_id = ipc_cursor_id_; |
260 params.primary_keys = msgPrimaryKeys; | 439 params->keys = msgKeys; |
261 std::vector<IndexedDBValue>::const_iterator iter; | 440 params->primary_keys = msgPrimaryKeys; |
262 for (iter = values.begin(); iter != values.end(); ++iter) | 441 std::vector<std::string>& values_bits = params->values; |
263 params.values.push_back(iter->bits); | 442 values_bits.resize(values.size()); |
264 dispatcher_host_->Send( | 443 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >& values_blob_infos = |
265 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(params)); | 444 params->blob_or_file_infos; |
445 values_blob_infos.resize(values.size()); | |
446 std::vector<IndexedDBValue>::iterator iter = values.begin(); | |
jsbell
2014/04/17 18:22:22
nit: can you move this to just before the for() lo
ericu
2014/04/17 21:36:29
Done.
| |
447 | |
448 bool found_blob_info = false; | |
449 for (size_t i = 0; iter != values.end(); ++iter, ++i) { | |
450 values_bits[i].swap(iter->bits); | |
451 if (iter->blob_info.size()) { | |
452 found_blob_info = true; | |
453 FillInBlobData(iter->blob_info, &values_blob_infos[i]); | |
454 std::vector<IndexedDBBlobInfo>::const_iterator blob_iter; | |
455 for (blob_iter = iter->blob_info.begin(); | |
456 blob_iter != iter->blob_info.end(); | |
457 ++blob_iter) { | |
458 blob_iter->mark_used_callback().Run(); | |
459 } | |
460 } | |
461 } | |
462 | |
463 if (found_blob_info) { | |
464 BrowserThread::PostTask( | |
cmumford
2014/04/17 18:07:57
Worthy of a DCHECK(!BrowserThread::CurrentlyOn(Bro
ericu
2014/04/17 21:36:29
All of the OnSuccess methods are called from the I
| |
465 BrowserThread::IO, | |
466 FROM_HERE, | |
467 base::Bind(BlobLookupForCursorPrefetch, | |
468 base::Owned(params.release()), | |
469 dispatcher_host_, | |
470 values, | |
471 base::Unretained(¶ms->blob_or_file_infos))); | |
472 } else { | |
473 dispatcher_host_->Send( | |
474 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params.get())); | |
475 } | |
266 dispatcher_host_ = NULL; | 476 dispatcher_host_ = NULL; |
267 } | 477 } |
268 | 478 |
269 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value, | 479 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value, |
270 const IndexedDBKey& key, | 480 const IndexedDBKey& key, |
271 const IndexedDBKeyPath& key_path) { | 481 const IndexedDBKeyPath& key_path) { |
272 DCHECK(dispatcher_host_.get()); | 482 DCHECK(dispatcher_host_.get()); |
273 | 483 |
274 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 484 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
275 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 485 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
276 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 486 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
277 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 487 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
278 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 488 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
279 | 489 |
280 IndexedDBMsg_CallbacksSuccessValueWithKey_Params params; | 490 scoped_ptr<IndexedDBMsg_CallbacksSuccessValueWithKey_Params> params( |
281 params.ipc_thread_id = ipc_thread_id_; | 491 new IndexedDBMsg_CallbacksSuccessValueWithKey_Params()); |
282 params.ipc_callbacks_id = ipc_callbacks_id_; | 492 params->ipc_thread_id = ipc_thread_id_; |
283 params.primary_key = key; | 493 params->ipc_callbacks_id = ipc_callbacks_id_; |
284 params.key_path = key_path; | 494 params->primary_key = key; |
495 params->key_path = key_path; | |
285 if (value && !value->empty()) | 496 if (value && !value->empty()) |
286 std::swap(params.value, value->bits); | 497 std::swap(params->value, value->bits); |
287 | 498 if (!value || value->blob_info.empty()) { |
288 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValueWithKey(params)); | 499 dispatcher_host_->Send( |
500 new IndexedDBMsg_CallbacksSuccessValueWithKey(*params)); | |
501 } else { | |
502 IndexedDBMsg_CallbacksSuccessValueWithKey_Params* p = params.get(); | |
503 FillInBlobData(value->blob_info, &p->blob_or_file_info); | |
504 RegisterBlobsAndSend(value->blob_info, | |
505 base::Bind(BlobLookupForValueWithKey, | |
506 base::Owned(params.release()), | |
507 dispatcher_host_, | |
508 value->blob_info, | |
509 base::Unretained(&p->blob_or_file_info))); | |
510 } | |
289 dispatcher_host_ = NULL; | 511 dispatcher_host_ = NULL; |
290 } | 512 } |
291 | 513 |
292 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value) { | 514 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value) { |
293 DCHECK(dispatcher_host_.get()); | 515 DCHECK(dispatcher_host_.get()); |
294 | |
295 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL); | 516 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL); |
296 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 517 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
297 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 518 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
298 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 519 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
299 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 520 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
300 | 521 |
301 IndexedDBMsg_CallbacksSuccessValue_Params params; | 522 scoped_ptr<IndexedDBMsg_CallbacksSuccessValue_Params> params( |
302 params.ipc_thread_id = ipc_thread_id_; | 523 new IndexedDBMsg_CallbacksSuccessValue_Params()); |
303 params.ipc_callbacks_id = ipc_callbacks_id_; | 524 params->ipc_thread_id = ipc_thread_id_; |
525 params->ipc_callbacks_id = ipc_callbacks_id_; | |
304 if (value && !value->empty()) | 526 if (value && !value->empty()) |
305 std::swap(params.value, value->bits); | 527 std::swap(params->value, value->bits); |
306 | 528 if (!value || value->blob_info.empty()) { |
307 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue(params)); | 529 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue(*params)); |
530 } else { | |
531 IndexedDBMsg_CallbacksSuccessValue_Params* p = params.get(); | |
532 FillInBlobData(value->blob_info, &p->blob_or_file_info); | |
533 RegisterBlobsAndSend(value->blob_info, | |
534 base::Bind(BlobLookupForValue, | |
535 base::Owned(params.release()), | |
536 dispatcher_host_, | |
537 value->blob_info, | |
538 base::Unretained(&p->blob_or_file_info))); | |
539 } | |
308 dispatcher_host_ = NULL; | 540 dispatcher_host_ = NULL; |
309 } | 541 } |
310 | 542 |
311 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) { | 543 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) { |
312 DCHECK(dispatcher_host_.get()); | 544 DCHECK(dispatcher_host_.get()); |
313 | 545 |
314 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 546 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
315 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 547 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
316 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 548 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
317 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 549 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
(...skipping 26 matching lines...) Expand all Loading... | |
344 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 576 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
345 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 577 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
346 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 578 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
347 | 579 |
348 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined( | 580 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined( |
349 ipc_thread_id_, ipc_callbacks_id_)); | 581 ipc_thread_id_, ipc_callbacks_id_)); |
350 dispatcher_host_ = NULL; | 582 dispatcher_host_ = NULL; |
351 } | 583 } |
352 | 584 |
353 } // namespace content | 585 } // namespace content |
OLD | NEW |