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()); |
| 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 DCHECK_EQ(blob_info.size(), blob_or_file_info->size()); |
| 216 size_t i; |
| 217 if (!dispatcher_host->blob_storage_context()) |
| 218 return false; |
| 219 for (i = 0; i < blob_info.size(); ++i) { |
| 220 (*blob_or_file_info)[i].uuid = |
| 221 CreateBlobData(blob_info[i], |
| 222 dispatcher_host, |
| 223 dispatcher_host->blob_storage_context(), |
| 224 dispatcher_host->Context()->TaskRunner()); |
| 225 } |
| 226 return true; |
| 227 } |
| 228 |
| 229 template <class ParamType, class MsgType> |
| 230 static void CreateBlobsAndSend( |
| 231 ParamType* params, |
| 232 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, |
| 233 const std::vector<IndexedDBBlobInfo>& blob_info, |
| 234 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { |
| 235 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| 236 if (CreateAllBlobs(blob_info, blob_or_file_info, dispatcher_host)) |
| 237 dispatcher_host->Send(new MsgType(*params)); |
| 238 } |
| 239 |
| 240 static void BlobLookupForCursorPrefetch( |
| 241 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params* params, |
| 242 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, |
| 243 const std::vector<IndexedDBValue>& values, |
| 244 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >* |
| 245 blob_or_file_infos) { |
| 246 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| 247 DCHECK_EQ(values.size(), blob_or_file_infos->size()); |
| 248 |
| 249 std::vector<IndexedDBValue>::const_iterator value_iter; |
| 250 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >::iterator blob_iter; |
| 251 for (value_iter = values.begin(), blob_iter = blob_or_file_infos->begin(); |
| 252 value_iter != values.end(); |
| 253 ++value_iter, ++blob_iter) { |
| 254 if (!CreateAllBlobs(value_iter->blob_info, &*blob_iter, dispatcher_host)) |
| 255 return; |
| 256 } |
| 257 dispatcher_host->Send( |
| 258 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params)); |
| 259 } |
| 260 |
| 261 static void FillInBlobData( |
| 262 const std::vector<IndexedDBBlobInfo>& blob_info, |
| 263 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { |
| 264 for (std::vector<IndexedDBBlobInfo>::const_iterator iter = blob_info.begin(); |
| 265 iter != blob_info.end(); |
| 266 ++iter) { |
| 267 if (iter->is_file()) { |
| 268 IndexedDBMsg_BlobOrFileInfo info; |
| 269 info.is_file = true; |
| 270 info.mime_type = iter->type(); |
| 271 info.file_name = iter->file_name(); |
| 272 info.file_path = iter->file_path().AsUTF16Unsafe(); |
| 273 DCHECK_NE(-1, iter->size()); |
| 274 info.size = iter->size(); |
| 275 info.last_modified = iter->last_modified().ToDoubleT(); |
| 276 blob_or_file_info->push_back(info); |
| 277 } else { |
| 278 IndexedDBMsg_BlobOrFileInfo info; |
| 279 info.mime_type = iter->type(); |
| 280 info.size = iter->size(); |
| 281 blob_or_file_info->push_back(info); |
| 282 } |
| 283 } |
| 284 } |
| 285 |
| 286 void IndexedDBCallbacks::RegisterBlobsAndSend( |
| 287 const std::vector<IndexedDBBlobInfo>& blob_info, |
| 288 const base::Closure& callback) { |
| 289 std::vector<IndexedDBBlobInfo>::const_iterator iter; |
| 290 for (iter = blob_info.begin(); iter != blob_info.end(); ++iter) { |
| 291 iter->mark_used_callback().Run(); |
| 292 } |
| 293 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| 294 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback); |
| 295 } |
| 296 |
172 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor, | 297 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor, |
173 const IndexedDBKey& key, | 298 const IndexedDBKey& key, |
174 const IndexedDBKey& primary_key, | 299 const IndexedDBKey& primary_key, |
175 IndexedDBValue* value) { | 300 IndexedDBValue* value) { |
176 DCHECK(dispatcher_host_.get()); | 301 DCHECK(dispatcher_host_.get()); |
177 | 302 |
178 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 303 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
179 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 304 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
180 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 305 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
181 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 306 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
182 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 307 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
183 | 308 |
184 int32 ipc_object_id = dispatcher_host_->Add(cursor.get()); | 309 int32 ipc_object_id = dispatcher_host_->Add(cursor.get()); |
185 IndexedDBMsg_CallbacksSuccessIDBCursor_Params params; | 310 scoped_ptr<IndexedDBMsg_CallbacksSuccessIDBCursor_Params> params( |
186 params.ipc_thread_id = ipc_thread_id_; | 311 new IndexedDBMsg_CallbacksSuccessIDBCursor_Params()); |
187 params.ipc_callbacks_id = ipc_callbacks_id_; | 312 params->ipc_thread_id = ipc_thread_id_; |
188 params.ipc_cursor_id = ipc_object_id; | 313 params->ipc_callbacks_id = ipc_callbacks_id_; |
189 params.key = key; | 314 params->ipc_cursor_id = ipc_object_id; |
190 params.primary_key = primary_key; | 315 params->key = key; |
| 316 params->primary_key = primary_key; |
191 if (value && !value->empty()) | 317 if (value && !value->empty()) |
192 std::swap(params.value, value->bits); | 318 std::swap(params->value, value->bits); |
193 // TODO(alecflett): Avoid a copy here: the whole params object is | 319 // TODO(alecflett): Avoid a copy here: the whole params object is |
194 // being copied into the message. | 320 // being copied into the message. |
195 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(params)); | 321 if (!value || value->blob_info.empty()) { |
196 | 322 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(*params)); |
| 323 } else { |
| 324 IndexedDBMsg_CallbacksSuccessIDBCursor_Params* p = params.get(); |
| 325 FillInBlobData(value->blob_info, &p->blob_or_file_info); |
| 326 RegisterBlobsAndSend( |
| 327 value->blob_info, |
| 328 base::Bind( |
| 329 CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessIDBCursor_Params, |
| 330 IndexedDBMsg_CallbacksSuccessIDBCursor>, |
| 331 base::Owned(params.release()), |
| 332 dispatcher_host_, |
| 333 value->blob_info, |
| 334 base::Unretained(&p->blob_or_file_info))); |
| 335 } |
197 dispatcher_host_ = NULL; | 336 dispatcher_host_ = NULL; |
198 } | 337 } |
199 | 338 |
200 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key, | 339 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key, |
201 const IndexedDBKey& primary_key, | 340 const IndexedDBKey& primary_key, |
202 IndexedDBValue* value) { | 341 IndexedDBValue* value) { |
203 DCHECK(dispatcher_host_.get()); | 342 DCHECK(dispatcher_host_.get()); |
204 | 343 |
205 DCHECK_NE(kNoCursor, ipc_cursor_id_); | 344 DCHECK_NE(kNoCursor, ipc_cursor_id_); |
206 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 345 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
207 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 346 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
208 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 347 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
209 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 348 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
210 | 349 |
211 IndexedDBCursor* idb_cursor = | 350 IndexedDBCursor* idb_cursor = |
212 dispatcher_host_->GetCursorFromId(ipc_cursor_id_); | 351 dispatcher_host_->GetCursorFromId(ipc_cursor_id_); |
213 | 352 |
214 DCHECK(idb_cursor); | 353 DCHECK(idb_cursor); |
215 if (!idb_cursor) | 354 if (!idb_cursor) |
216 return; | 355 return; |
217 IndexedDBMsg_CallbacksSuccessCursorContinue_Params params; | 356 |
218 params.ipc_thread_id = ipc_thread_id_; | 357 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorContinue_Params> params( |
219 params.ipc_callbacks_id = ipc_callbacks_id_; | 358 new IndexedDBMsg_CallbacksSuccessCursorContinue_Params()); |
220 params.ipc_cursor_id = ipc_cursor_id_; | 359 params->ipc_thread_id = ipc_thread_id_; |
221 params.key = key; | 360 params->ipc_callbacks_id = ipc_callbacks_id_; |
222 params.primary_key = primary_key; | 361 params->ipc_cursor_id = ipc_cursor_id_; |
| 362 params->key = key; |
| 363 params->primary_key = primary_key; |
223 if (value && !value->empty()) | 364 if (value && !value->empty()) |
224 std::swap(params.value, value->bits); | 365 std::swap(params->value, value->bits); |
225 // TODO(alecflett): Avoid a copy here: the whole params object is | 366 // TODO(alecflett): Avoid a copy here: the whole params object is |
226 // being copied into the message. | 367 // being copied into the message. |
227 dispatcher_host_->Send( | 368 if (!value || value->blob_info.empty()) { |
228 new IndexedDBMsg_CallbacksSuccessCursorContinue(params)); | 369 dispatcher_host_->Send( |
| 370 new IndexedDBMsg_CallbacksSuccessCursorContinue(*params)); |
| 371 } else { |
| 372 IndexedDBMsg_CallbacksSuccessCursorContinue_Params* p = params.get(); |
| 373 FillInBlobData(value->blob_info, &p->blob_or_file_info); |
| 374 RegisterBlobsAndSend( |
| 375 value->blob_info, |
| 376 base::Bind(CreateBlobsAndSend< |
| 377 IndexedDBMsg_CallbacksSuccessCursorContinue_Params, |
| 378 IndexedDBMsg_CallbacksSuccessCursorContinue>, |
| 379 base::Owned(params.release()), |
| 380 dispatcher_host_, |
| 381 value->blob_info, |
| 382 base::Unretained(&p->blob_or_file_info))); |
| 383 } |
229 dispatcher_host_ = NULL; | 384 dispatcher_host_ = NULL; |
230 } | 385 } |
231 | 386 |
232 void IndexedDBCallbacks::OnSuccessWithPrefetch( | 387 void IndexedDBCallbacks::OnSuccessWithPrefetch( |
233 const std::vector<IndexedDBKey>& keys, | 388 const std::vector<IndexedDBKey>& keys, |
234 const std::vector<IndexedDBKey>& primary_keys, | 389 const std::vector<IndexedDBKey>& primary_keys, |
235 const std::vector<IndexedDBValue>& values) { | 390 std::vector<IndexedDBValue>& values) { |
236 DCHECK_EQ(keys.size(), primary_keys.size()); | 391 DCHECK_EQ(keys.size(), primary_keys.size()); |
237 DCHECK_EQ(keys.size(), values.size()); | 392 DCHECK_EQ(keys.size(), values.size()); |
238 | 393 |
239 DCHECK(dispatcher_host_.get()); | 394 DCHECK(dispatcher_host_.get()); |
240 | 395 |
241 DCHECK_NE(kNoCursor, ipc_cursor_id_); | 396 DCHECK_NE(kNoCursor, ipc_cursor_id_); |
242 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 397 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
243 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 398 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
244 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 399 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
245 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 400 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
246 | 401 |
247 std::vector<IndexedDBKey> msgKeys; | 402 std::vector<IndexedDBKey> msgKeys; |
248 std::vector<IndexedDBKey> msgPrimaryKeys; | 403 std::vector<IndexedDBKey> msgPrimaryKeys; |
249 | 404 |
250 for (size_t i = 0; i < keys.size(); ++i) { | 405 for (size_t i = 0; i < keys.size(); ++i) { |
251 msgKeys.push_back(keys[i]); | 406 msgKeys.push_back(keys[i]); |
252 msgPrimaryKeys.push_back(primary_keys[i]); | 407 msgPrimaryKeys.push_back(primary_keys[i]); |
253 } | 408 } |
254 | 409 |
255 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params params; | 410 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params> params( |
256 params.ipc_thread_id = ipc_thread_id_; | 411 new IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params()); |
257 params.ipc_callbacks_id = ipc_callbacks_id_; | 412 params->ipc_thread_id = ipc_thread_id_; |
258 params.ipc_cursor_id = ipc_cursor_id_; | 413 params->ipc_callbacks_id = ipc_callbacks_id_; |
259 params.keys = msgKeys; | 414 params->ipc_cursor_id = ipc_cursor_id_; |
260 params.primary_keys = msgPrimaryKeys; | 415 params->keys = msgKeys; |
261 std::vector<IndexedDBValue>::const_iterator iter; | 416 params->primary_keys = msgPrimaryKeys; |
262 for (iter = values.begin(); iter != values.end(); ++iter) | 417 std::vector<std::string>& values_bits = params->values; |
263 params.values.push_back(iter->bits); | 418 values_bits.resize(values.size()); |
264 dispatcher_host_->Send( | 419 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >& values_blob_infos = |
265 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(params)); | 420 params->blob_or_file_infos; |
| 421 values_blob_infos.resize(values.size()); |
| 422 |
| 423 bool found_blob_info = false; |
| 424 std::vector<IndexedDBValue>::iterator iter = values.begin(); |
| 425 for (size_t i = 0; iter != values.end(); ++iter, ++i) { |
| 426 values_bits[i].swap(iter->bits); |
| 427 if (iter->blob_info.size()) { |
| 428 found_blob_info = true; |
| 429 FillInBlobData(iter->blob_info, &values_blob_infos[i]); |
| 430 std::vector<IndexedDBBlobInfo>::const_iterator blob_iter; |
| 431 for (blob_iter = iter->blob_info.begin(); |
| 432 blob_iter != iter->blob_info.end(); |
| 433 ++blob_iter) { |
| 434 blob_iter->mark_used_callback().Run(); |
| 435 } |
| 436 } |
| 437 } |
| 438 |
| 439 if (found_blob_info) { |
| 440 BrowserThread::PostTask( |
| 441 BrowserThread::IO, |
| 442 FROM_HERE, |
| 443 base::Bind(BlobLookupForCursorPrefetch, |
| 444 base::Owned(params.release()), |
| 445 dispatcher_host_, |
| 446 values, |
| 447 base::Unretained(¶ms->blob_or_file_infos))); |
| 448 } else { |
| 449 dispatcher_host_->Send( |
| 450 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params.get())); |
| 451 } |
266 dispatcher_host_ = NULL; | 452 dispatcher_host_ = NULL; |
267 } | 453 } |
268 | 454 |
269 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value, | 455 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value, |
270 const IndexedDBKey& key, | 456 const IndexedDBKey& key, |
271 const IndexedDBKeyPath& key_path) { | 457 const IndexedDBKeyPath& key_path) { |
272 DCHECK(dispatcher_host_.get()); | 458 DCHECK(dispatcher_host_.get()); |
273 | 459 |
274 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 460 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
275 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 461 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
276 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 462 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
277 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 463 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
278 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 464 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
279 | 465 |
280 IndexedDBMsg_CallbacksSuccessValueWithKey_Params params; | 466 scoped_ptr<IndexedDBMsg_CallbacksSuccessValueWithKey_Params> params( |
281 params.ipc_thread_id = ipc_thread_id_; | 467 new IndexedDBMsg_CallbacksSuccessValueWithKey_Params()); |
282 params.ipc_callbacks_id = ipc_callbacks_id_; | 468 params->ipc_thread_id = ipc_thread_id_; |
283 params.primary_key = key; | 469 params->ipc_callbacks_id = ipc_callbacks_id_; |
284 params.key_path = key_path; | 470 params->primary_key = key; |
| 471 params->key_path = key_path; |
285 if (value && !value->empty()) | 472 if (value && !value->empty()) |
286 std::swap(params.value, value->bits); | 473 std::swap(params->value, value->bits); |
287 | 474 if (!value || value->blob_info.empty()) { |
288 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValueWithKey(params)); | 475 dispatcher_host_->Send( |
| 476 new IndexedDBMsg_CallbacksSuccessValueWithKey(*params)); |
| 477 } else { |
| 478 IndexedDBMsg_CallbacksSuccessValueWithKey_Params* p = params.get(); |
| 479 FillInBlobData(value->blob_info, &p->blob_or_file_info); |
| 480 RegisterBlobsAndSend( |
| 481 value->blob_info, |
| 482 base::Bind( |
| 483 CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValueWithKey_Params, |
| 484 IndexedDBMsg_CallbacksSuccessValueWithKey>, |
| 485 base::Owned(params.release()), |
| 486 dispatcher_host_, |
| 487 value->blob_info, |
| 488 base::Unretained(&p->blob_or_file_info))); |
| 489 } |
289 dispatcher_host_ = NULL; | 490 dispatcher_host_ = NULL; |
290 } | 491 } |
291 | 492 |
292 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value) { | 493 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value) { |
293 DCHECK(dispatcher_host_.get()); | 494 DCHECK(dispatcher_host_.get()); |
294 | |
295 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL); | 495 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL); |
296 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 496 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
297 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 497 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
298 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 498 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
299 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 499 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
300 | 500 |
301 IndexedDBMsg_CallbacksSuccessValue_Params params; | 501 scoped_ptr<IndexedDBMsg_CallbacksSuccessValue_Params> params( |
302 params.ipc_thread_id = ipc_thread_id_; | 502 new IndexedDBMsg_CallbacksSuccessValue_Params()); |
303 params.ipc_callbacks_id = ipc_callbacks_id_; | 503 params->ipc_thread_id = ipc_thread_id_; |
| 504 params->ipc_callbacks_id = ipc_callbacks_id_; |
304 if (value && !value->empty()) | 505 if (value && !value->empty()) |
305 std::swap(params.value, value->bits); | 506 std::swap(params->value, value->bits); |
306 | 507 if (!value || value->blob_info.empty()) { |
307 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue(params)); | 508 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue(*params)); |
| 509 } else { |
| 510 IndexedDBMsg_CallbacksSuccessValue_Params* p = params.get(); |
| 511 FillInBlobData(value->blob_info, &p->blob_or_file_info); |
| 512 RegisterBlobsAndSend( |
| 513 value->blob_info, |
| 514 base::Bind(CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValue_Params, |
| 515 IndexedDBMsg_CallbacksSuccessValue>, |
| 516 base::Owned(params.release()), |
| 517 dispatcher_host_, |
| 518 value->blob_info, |
| 519 base::Unretained(&p->blob_or_file_info))); |
| 520 } |
308 dispatcher_host_ = NULL; | 521 dispatcher_host_ = NULL; |
309 } | 522 } |
310 | 523 |
311 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) { | 524 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) { |
312 DCHECK(dispatcher_host_.get()); | 525 DCHECK(dispatcher_host_.get()); |
313 | 526 |
314 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 527 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
315 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 528 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
316 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 529 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
317 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 530 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
(...skipping 26 matching lines...) Expand all Loading... |
344 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 557 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
345 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 558 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
346 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); | 559 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); |
347 | 560 |
348 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined( | 561 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined( |
349 ipc_thread_id_, ipc_callbacks_id_)); | 562 ipc_thread_id_, ipc_callbacks_id_)); |
350 dispatcher_host_ = NULL; | 563 dispatcher_host_ = NULL; |
351 } | 564 } |
352 | 565 |
353 } // namespace content | 566 } // namespace content |
OLD | NEW |