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 3 // found in the LICENSE file. 4 5 #include "content/browser/indexed_db/indexed_db_callbacks.h" 6 7 #include <algorithm> 8 9 #include "base/guid.h" 10 #include "base/metrics/histogram.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "base/time/time.h" 13 #include "content/browser/child_process_security_policy_impl.h" 14 #include "content/browser/fileapi/fileapi_message_filter.h" 15 #include "content/browser/indexed_db/indexed_db_blob_info.h" 16 #include "content/browser/indexed_db/indexed_db_connection.h" 17 #include "content/browser/indexed_db/indexed_db_context_impl.h" 18 #include "content/browser/indexed_db/indexed_db_cursor.h" 19 #include "content/browser/indexed_db/indexed_db_database_callbacks.h" 20 #include "content/browser/indexed_db/indexed_db_database_error.h" 21 #include "content/browser/indexed_db/indexed_db_metadata.h" 22 #include "content/browser/indexed_db/indexed_db_value.h" 23 #include "content/common/indexed_db/indexed_db_constants.h" 24 #include "content/common/indexed_db/indexed_db_messages.h" 25 #include "storage/browser/blob/blob_storage_context.h" 26 #include "storage/browser/quota/quota_manager.h" 27 #include "storage/common/blob/blob_data.h" 28 #include "storage/common/blob/shareable_file_reference.h" 29 30 using storage::ShareableFileReference; 31 32 namespace content { 33 34 namespace { 35 const int32 kNoCursor = -1; 36 const int32 kNoDatabaseCallbacks = -1; 37 const int64 kNoTransaction = -1; 38 } 39 40 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host, 41 int32 ipc_thread_id, 42 int32 ipc_callbacks_id) 43 : dispatcher_host_(dispatcher_host), 44 ipc_callbacks_id_(ipc_callbacks_id), 45 ipc_thread_id_(ipc_thread_id), 46 ipc_cursor_id_(kNoCursor), 47 host_transaction_id_(kNoTransaction), 48 ipc_database_id_(kNoDatabase), 49 ipc_database_callbacks_id_(kNoDatabaseCallbacks), 50 data_loss_(blink::WebIDBDataLossNone), 51 sent_blocked_(false) { 52 } 53 54 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host, 55 int32 ipc_thread_id, 56 int32 ipc_callbacks_id, 57 int32 ipc_cursor_id) 58 : dispatcher_host_(dispatcher_host), 59 ipc_callbacks_id_(ipc_callbacks_id), 60 ipc_thread_id_(ipc_thread_id), 61 ipc_cursor_id_(ipc_cursor_id), 62 host_transaction_id_(kNoTransaction), 63 ipc_database_id_(kNoDatabase), 64 ipc_database_callbacks_id_(kNoDatabaseCallbacks), 65 data_loss_(blink::WebIDBDataLossNone), 66 sent_blocked_(false) { 67 } 68 69 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host, 70 int32 ipc_thread_id, 71 int32 ipc_callbacks_id, 72 int32 ipc_database_callbacks_id, 73 int64 host_transaction_id, 74 const GURL& origin_url) 75 : dispatcher_host_(dispatcher_host), 76 ipc_callbacks_id_(ipc_callbacks_id), 77 ipc_thread_id_(ipc_thread_id), 78 ipc_cursor_id_(kNoCursor), 79 host_transaction_id_(host_transaction_id), 80 origin_url_(origin_url), 81 ipc_database_id_(kNoDatabase), 82 ipc_database_callbacks_id_(ipc_database_callbacks_id), 83 data_loss_(blink::WebIDBDataLossNone), 84 sent_blocked_(false) { 85 } 86 87 IndexedDBCallbacks::~IndexedDBCallbacks() {} 88 89 void IndexedDBCallbacks::OnError(const IndexedDBDatabaseError& error) { 90 DCHECK(dispatcher_host_.get()); 91 92 dispatcher_host_->Send(new IndexedDBMsg_CallbacksError( 93 ipc_thread_id_, ipc_callbacks_id_, error.code(), error.message())); 94 dispatcher_host_ = NULL; 95 96 if (!connection_open_start_time_.is_null()) { 97 UMA_HISTOGRAM_MEDIUM_TIMES( 98 "WebCore.IndexedDB.OpenTime.Error", 99 base::TimeTicks::Now() - connection_open_start_time_); 100 connection_open_start_time_ = base::TimeTicks(); 101 } 102 } 103 104 void IndexedDBCallbacks::OnSuccess(const std::vector<base::string16>& value) { 105 DCHECK(dispatcher_host_.get()); 106 107 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 108 DCHECK_EQ(kNoTransaction, host_transaction_id_); 109 DCHECK_EQ(kNoDatabase, ipc_database_id_); 110 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 111 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 112 113 std::vector<base::string16> list; 114 for (unsigned i = 0; i < value.size(); ++i) 115 list.push_back(value[i]); 116 117 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessStringList( 118 ipc_thread_id_, ipc_callbacks_id_, list)); 119 dispatcher_host_ = NULL; 120 } 121 122 void IndexedDBCallbacks::OnBlocked(int64 existing_version) { 123 DCHECK(dispatcher_host_.get()); 124 125 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 126 // No transaction/db callbacks for DeleteDatabase. 127 DCHECK_EQ(kNoTransaction == host_transaction_id_, 128 kNoDatabaseCallbacks == ipc_database_callbacks_id_); 129 DCHECK_EQ(kNoDatabase, ipc_database_id_); 130 131 if (sent_blocked_) 132 return; 133 134 sent_blocked_ = true; 135 dispatcher_host_->Send(new IndexedDBMsg_CallbacksIntBlocked( 136 ipc_thread_id_, ipc_callbacks_id_, existing_version)); 137 138 if (!connection_open_start_time_.is_null()) { 139 UMA_HISTOGRAM_MEDIUM_TIMES( 140 "WebCore.IndexedDB.OpenTime.Blocked", 141 base::TimeTicks::Now() - connection_open_start_time_); 142 connection_open_start_time_ = base::TimeTicks(); 143 } 144 } 145 146 void IndexedDBCallbacks::OnDataLoss(blink::WebIDBDataLoss data_loss, 147 std::string data_loss_message) { 148 DCHECK_NE(blink::WebIDBDataLossNone, data_loss); 149 data_loss_ = data_loss; 150 data_loss_message_ = data_loss_message; 151 } 152 153 void IndexedDBCallbacks::OnUpgradeNeeded( 154 int64 old_version, 155 scoped_ptr<IndexedDBConnection> connection, 156 const IndexedDBDatabaseMetadata& metadata) { 157 DCHECK(dispatcher_host_.get()); 158 159 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 160 DCHECK_NE(kNoTransaction, host_transaction_id_); 161 DCHECK_EQ(kNoDatabase, ipc_database_id_); 162 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 163 164 dispatcher_host_->RegisterTransactionId(host_transaction_id_, origin_url_); 165 int32 ipc_database_id = 166 dispatcher_host_->Add(connection.release(), ipc_thread_id_, origin_url_); 167 if (ipc_database_id < 0) 168 return; 169 ipc_database_id_ = ipc_database_id; 170 IndexedDBMsg_CallbacksUpgradeNeeded_Params params; 171 params.ipc_thread_id = ipc_thread_id_; 172 params.ipc_callbacks_id = ipc_callbacks_id_; 173 params.ipc_database_id = ipc_database_id; 174 params.ipc_database_callbacks_id = ipc_database_callbacks_id_; 175 params.old_version = old_version; 176 params.idb_metadata = IndexedDBDispatcherHost::ConvertMetadata(metadata); 177 params.data_loss = data_loss_; 178 params.data_loss_message = data_loss_message_; 179 dispatcher_host_->Send(new IndexedDBMsg_CallbacksUpgradeNeeded(params)); 180 181 if (!connection_open_start_time_.is_null()) { 182 UMA_HISTOGRAM_MEDIUM_TIMES( 183 "WebCore.IndexedDB.OpenTime.UpgradeNeeded", 184 base::TimeTicks::Now() - connection_open_start_time_); 185 connection_open_start_time_ = base::TimeTicks(); 186 } 187 } 188 189 void IndexedDBCallbacks::OnSuccess(scoped_ptr<IndexedDBConnection> connection, 190 const IndexedDBDatabaseMetadata& metadata) { 191 DCHECK(dispatcher_host_.get()); 192 193 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 194 DCHECK_NE(kNoTransaction, host_transaction_id_); 195 DCHECK_NE(ipc_database_id_ == kNoDatabase, !connection); 196 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 197 198 scoped_refptr<IndexedDBCallbacks> self(this); 199 200 int32 ipc_object_id = kNoDatabase; 201 // Only register if the connection was not previously sent in OnUpgradeNeeded. 202 if (ipc_database_id_ == kNoDatabase) { 203 ipc_object_id = dispatcher_host_->Add( 204 connection.release(), ipc_thread_id_, origin_url_); 205 } 206 207 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBDatabase( 208 ipc_thread_id_, 209 ipc_callbacks_id_, 210 ipc_database_callbacks_id_, 211 ipc_object_id, 212 IndexedDBDispatcherHost::ConvertMetadata(metadata))); 213 dispatcher_host_ = NULL; 214 215 if (!connection_open_start_time_.is_null()) { 216 UMA_HISTOGRAM_MEDIUM_TIMES( 217 "WebCore.IndexedDB.OpenTime.Success", 218 base::TimeTicks::Now() - connection_open_start_time_); 219 connection_open_start_time_ = base::TimeTicks(); 220 } 221 } 222 223 static std::string CreateBlobData( 224 const IndexedDBBlobInfo& blob_info, 225 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, 226 storage::BlobStorageContext* blob_storage_context, 227 base::TaskRunner* task_runner) { 228 std::string uuid = blob_info.uuid(); 229 if (!uuid.empty()) { 230 // We're sending back a live blob, not a reference into our backing store. 231 scoped_ptr<storage::BlobDataHandle> blob_data_handle( 232 blob_storage_context->GetBlobDataFromUUID(uuid)); 233 dispatcher_host->HoldBlobDataHandle(uuid, blob_data_handle.Pass()); 234 return uuid; 235 } 236 scoped_refptr<ShareableFileReference> shareable_file = 237 ShareableFileReference::Get(blob_info.file_path()); 238 if (!shareable_file.get()) { 239 shareable_file = ShareableFileReference::GetOrCreate( 240 blob_info.file_path(), 241 ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE, 242 task_runner); 243 if (!blob_info.release_callback().is_null()) 244 shareable_file->AddFinalReleaseCallback(blob_info.release_callback()); 245 } 246 247 uuid = base::GenerateGUID(); 248 scoped_refptr<storage::BlobData> blob_data = new storage::BlobData(uuid); 249 blob_data->set_content_type(base::UTF16ToUTF8(blob_info.type())); 250 blob_data->AppendFile( 251 blob_info.file_path(), 0, blob_info.size(), blob_info.last_modified()); 252 scoped_ptr<storage::BlobDataHandle> blob_data_handle( 253 blob_storage_context->AddFinishedBlob(blob_data.get())); 254 dispatcher_host->HoldBlobDataHandle(uuid, blob_data_handle.Pass()); 255 256 return uuid; 257 } 258 259 static bool CreateAllBlobs( 260 const std::vector<IndexedDBBlobInfo>& blob_info, 261 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info, 262 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host) { 263 DCHECK_EQ(blob_info.size(), blob_or_file_info->size()); 264 size_t i; 265 if (!dispatcher_host->blob_storage_context()) 266 return false; 267 for (i = 0; i < blob_info.size(); ++i) { 268 (*blob_or_file_info)[i].uuid = 269 CreateBlobData(blob_info[i], 270 dispatcher_host, 271 dispatcher_host->blob_storage_context(), 272 dispatcher_host->Context()->TaskRunner()); 273 } 274 return true; 275 } 276 277 template <class ParamType, class MsgType> 278 static void CreateBlobsAndSend( 279 ParamType* params, 280 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, 281 const std::vector<IndexedDBBlobInfo>& blob_info, 282 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { 283 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 284 if (CreateAllBlobs(blob_info, blob_or_file_info, dispatcher_host)) 285 dispatcher_host->Send(new MsgType(*params)); 286 } 287 288 static void BlobLookupForCursorPrefetch( 289 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params* params, 290 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host, 291 const std::vector<IndexedDBValue>& values) { 292 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 293 DCHECK_EQ(values.size(), params->blob_or_file_infos.size()); 294 295 std::vector<IndexedDBValue>::const_iterator value_iter; 296 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >::iterator blob_iter; 297 for (value_iter = values.begin(), blob_iter = 298 params->blob_or_file_infos.begin(); value_iter != values.end(); 299 ++value_iter, ++blob_iter) { 300 if (!CreateAllBlobs(value_iter->blob_info, &*blob_iter, dispatcher_host)) 301 return; 302 } 303 dispatcher_host->Send( 304 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params)); 305 } 306 307 static void FillInBlobData( 308 const std::vector<IndexedDBBlobInfo>& blob_info, 309 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) { 310 for (std::vector<IndexedDBBlobInfo>::const_iterator iter = blob_info.begin(); 311 iter != blob_info.end(); 312 ++iter) { 313 if (iter->is_file()) { 314 IndexedDBMsg_BlobOrFileInfo info; 315 info.is_file = true; 316 info.mime_type = iter->type(); 317 info.file_name = iter->file_name(); 318 info.file_path = iter->file_path().AsUTF16Unsafe(); 319 info.size = iter->size(); 320 info.last_modified = iter->last_modified().ToDoubleT(); 321 blob_or_file_info->push_back(info); 322 } else { 323 IndexedDBMsg_BlobOrFileInfo info; 324 info.mime_type = iter->type(); 325 info.size = iter->size(); 326 blob_or_file_info->push_back(info); 327 } 328 } 329 } 330 331 void IndexedDBCallbacks::RegisterBlobsAndSend( 332 const std::vector<IndexedDBBlobInfo>& blob_info, 333 const base::Closure& callback) { 334 std::vector<IndexedDBBlobInfo>::const_iterator iter; 335 for (iter = blob_info.begin(); iter != blob_info.end(); ++iter) { 336 if (!iter->mark_used_callback().is_null()) 337 iter->mark_used_callback().Run(); 338 } 339 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO)); 340 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback); 341 } 342 343 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor, 344 const IndexedDBKey& key, 345 const IndexedDBKey& primary_key, 346 IndexedDBValue* value) { 347 DCHECK(dispatcher_host_.get()); 348 349 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 350 DCHECK_EQ(kNoTransaction, host_transaction_id_); 351 DCHECK_EQ(kNoDatabase, ipc_database_id_); 352 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 353 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 354 355 int32 ipc_object_id = dispatcher_host_->Add(cursor.get()); 356 scoped_ptr<IndexedDBMsg_CallbacksSuccessIDBCursor_Params> params( 357 new IndexedDBMsg_CallbacksSuccessIDBCursor_Params()); 358 params->ipc_thread_id = ipc_thread_id_; 359 params->ipc_callbacks_id = ipc_callbacks_id_; 360 params->ipc_cursor_id = ipc_object_id; 361 params->key = key; 362 params->primary_key = primary_key; 363 if (value && !value->empty()) 364 std::swap(params->value, value->bits); 365 // TODO(alecflett): Avoid a copy here: the whole params object is 366 // being copied into the message. 367 if (!value || value->blob_info.empty()) { 368 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(*params)); 369 } else { 370 IndexedDBMsg_CallbacksSuccessIDBCursor_Params* p = params.get(); 371 FillInBlobData(value->blob_info, &p->blob_or_file_info); 372 RegisterBlobsAndSend( 373 value->blob_info, 374 base::Bind( 375 CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessIDBCursor_Params, 376 IndexedDBMsg_CallbacksSuccessIDBCursor>, 377 base::Owned(params.release()), 378 dispatcher_host_, 379 value->blob_info, 380 base::Unretained(&p->blob_or_file_info))); 381 } 382 dispatcher_host_ = NULL; 383 } 384 385 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key, 386 const IndexedDBKey& primary_key, 387 IndexedDBValue* value) { 388 DCHECK(dispatcher_host_.get()); 389 390 DCHECK_NE(kNoCursor, ipc_cursor_id_); 391 DCHECK_EQ(kNoTransaction, host_transaction_id_); 392 DCHECK_EQ(kNoDatabase, ipc_database_id_); 393 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 394 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 395 396 IndexedDBCursor* idb_cursor = 397 dispatcher_host_->GetCursorFromId(ipc_cursor_id_); 398 399 DCHECK(idb_cursor); 400 if (!idb_cursor) 401 return; 402 403 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorContinue_Params> params( 404 new IndexedDBMsg_CallbacksSuccessCursorContinue_Params()); 405 params->ipc_thread_id = ipc_thread_id_; 406 params->ipc_callbacks_id = ipc_callbacks_id_; 407 params->ipc_cursor_id = ipc_cursor_id_; 408 params->key = key; 409 params->primary_key = primary_key; 410 if (value && !value->empty()) 411 std::swap(params->value, value->bits); 412 // TODO(alecflett): Avoid a copy here: the whole params object is 413 // being copied into the message. 414 if (!value || value->blob_info.empty()) { 415 dispatcher_host_->Send( 416 new IndexedDBMsg_CallbacksSuccessCursorContinue(*params)); 417 } else { 418 IndexedDBMsg_CallbacksSuccessCursorContinue_Params* p = params.get(); 419 FillInBlobData(value->blob_info, &p->blob_or_file_info); 420 RegisterBlobsAndSend( 421 value->blob_info, 422 base::Bind(CreateBlobsAndSend< 423 IndexedDBMsg_CallbacksSuccessCursorContinue_Params, 424 IndexedDBMsg_CallbacksSuccessCursorContinue>, 425 base::Owned(params.release()), 426 dispatcher_host_, 427 value->blob_info, 428 base::Unretained(&p->blob_or_file_info))); 429 } 430 dispatcher_host_ = NULL; 431 } 432 433 void IndexedDBCallbacks::OnSuccessWithPrefetch( 434 const std::vector<IndexedDBKey>& keys, 435 const std::vector<IndexedDBKey>& primary_keys, 436 std::vector<IndexedDBValue>* values) { 437 DCHECK_EQ(keys.size(), primary_keys.size()); 438 DCHECK_EQ(keys.size(), values->size()); 439 440 DCHECK(dispatcher_host_.get()); 441 442 DCHECK_NE(kNoCursor, ipc_cursor_id_); 443 DCHECK_EQ(kNoTransaction, host_transaction_id_); 444 DCHECK_EQ(kNoDatabase, ipc_database_id_); 445 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 446 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 447 448 std::vector<IndexedDBKey> msgKeys; 449 std::vector<IndexedDBKey> msgPrimaryKeys; 450 451 for (size_t i = 0; i < keys.size(); ++i) { 452 msgKeys.push_back(keys[i]); 453 msgPrimaryKeys.push_back(primary_keys[i]); 454 } 455 456 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params> params( 457 new IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params()); 458 params->ipc_thread_id = ipc_thread_id_; 459 params->ipc_callbacks_id = ipc_callbacks_id_; 460 params->ipc_cursor_id = ipc_cursor_id_; 461 params->keys = msgKeys; 462 params->primary_keys = msgPrimaryKeys; 463 std::vector<std::string>& values_bits = params->values; 464 values_bits.resize(values->size()); 465 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >& values_blob_infos = 466 params->blob_or_file_infos; 467 values_blob_infos.resize(values->size()); 468 469 bool found_blob_info = false; 470 std::vector<IndexedDBValue>::iterator iter = values->begin(); 471 for (size_t i = 0; iter != values->end(); ++iter, ++i) { 472 values_bits[i].swap(iter->bits); 473 if (iter->blob_info.size()) { 474 found_blob_info = true; 475 FillInBlobData(iter->blob_info, &values_blob_infos[i]); 476 std::vector<IndexedDBBlobInfo>::const_iterator blob_iter; 477 for (blob_iter = iter->blob_info.begin(); 478 blob_iter != iter->blob_info.end(); 479 ++blob_iter) { 480 if (!blob_iter->mark_used_callback().is_null()) 481 blob_iter->mark_used_callback().Run(); 482 } 483 } 484 } 485 486 if (found_blob_info) { 487 BrowserThread::PostTask(BrowserThread::IO, 488 FROM_HERE, 489 base::Bind(BlobLookupForCursorPrefetch, 490 base::Owned(params.release()), 491 dispatcher_host_, 492 *values)); 493 } else { 494 dispatcher_host_->Send( 495 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params.get())); 496 } 497 dispatcher_host_ = NULL; 498 } 499 500 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value, 501 const IndexedDBKey& key, 502 const IndexedDBKeyPath& key_path) { 503 DCHECK(dispatcher_host_.get()); 504 505 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 506 DCHECK_EQ(kNoTransaction, host_transaction_id_); 507 DCHECK_EQ(kNoDatabase, ipc_database_id_); 508 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 509 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 510 511 scoped_ptr<IndexedDBMsg_CallbacksSuccessValueWithKey_Params> params( 512 new IndexedDBMsg_CallbacksSuccessValueWithKey_Params()); 513 params->ipc_thread_id = ipc_thread_id_; 514 params->ipc_callbacks_id = ipc_callbacks_id_; 515 params->primary_key = key; 516 params->key_path = key_path; 517 if (value && !value->empty()) 518 std::swap(params->value, value->bits); 519 if (!value || value->blob_info.empty()) { 520 dispatcher_host_->Send( 521 new IndexedDBMsg_CallbacksSuccessValueWithKey(*params)); 522 } else { 523 IndexedDBMsg_CallbacksSuccessValueWithKey_Params* p = params.get(); 524 FillInBlobData(value->blob_info, &p->blob_or_file_info); 525 RegisterBlobsAndSend( 526 value->blob_info, 527 base::Bind( 528 CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValueWithKey_Params, 529 IndexedDBMsg_CallbacksSuccessValueWithKey>, 530 base::Owned(params.release()), 531 dispatcher_host_, 532 value->blob_info, 533 base::Unretained(&p->blob_or_file_info))); 534 } 535 dispatcher_host_ = NULL; 536 } 537 538 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value) { 539 DCHECK(dispatcher_host_.get()); 540 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL); 541 DCHECK_EQ(kNoTransaction, host_transaction_id_); 542 DCHECK_EQ(kNoDatabase, ipc_database_id_); 543 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 544 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 545 546 scoped_ptr<IndexedDBMsg_CallbacksSuccessValue_Params> params( 547 new IndexedDBMsg_CallbacksSuccessValue_Params()); 548 params->ipc_thread_id = ipc_thread_id_; 549 params->ipc_callbacks_id = ipc_callbacks_id_; 550 if (value && !value->empty()) 551 std::swap(params->value, value->bits); 552 if (!value || value->blob_info.empty()) { 553 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue(*params)); 554 } else { 555 IndexedDBMsg_CallbacksSuccessValue_Params* p = params.get(); 556 FillInBlobData(value->blob_info, &p->blob_or_file_info); 557 RegisterBlobsAndSend( 558 value->blob_info, 559 base::Bind(CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValue_Params, 560 IndexedDBMsg_CallbacksSuccessValue>, 561 base::Owned(params.release()), 562 dispatcher_host_, 563 value->blob_info, 564 base::Unretained(&p->blob_or_file_info))); 565 } 566 dispatcher_host_ = NULL; 567 } 568 569 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) { 570 DCHECK(dispatcher_host_.get()); 571 572 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 573 DCHECK_EQ(kNoTransaction, host_transaction_id_); 574 DCHECK_EQ(kNoDatabase, ipc_database_id_); 575 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 576 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 577 578 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIndexedDBKey( 579 ipc_thread_id_, ipc_callbacks_id_, value)); 580 dispatcher_host_ = NULL; 581 } 582 583 void IndexedDBCallbacks::OnSuccess(int64 value) { 584 DCHECK(dispatcher_host_.get()); 585 586 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 587 DCHECK_EQ(kNoTransaction, host_transaction_id_); 588 DCHECK_EQ(kNoDatabase, ipc_database_id_); 589 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 590 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 591 592 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessInteger( 593 ipc_thread_id_, ipc_callbacks_id_, value)); 594 dispatcher_host_ = NULL; 595 } 596 597 void IndexedDBCallbacks::OnSuccess() { 598 DCHECK(dispatcher_host_.get()); 599 600 DCHECK_EQ(kNoCursor, ipc_cursor_id_); 601 DCHECK_EQ(kNoTransaction, host_transaction_id_); 602 DCHECK_EQ(kNoDatabase, ipc_database_id_); 603 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); 604 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_); 605 606 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined( 607 ipc_thread_id_, ipc_callbacks_id_)); 608 dispatcher_host_ = NULL; 609 } 610 611 void IndexedDBCallbacks::SetConnectionOpenStartTime( 612 const base::TimeTicks& start_time) { 613 connection_open_start_time_ = start_time; 614 } 615 616 } // namespace content 617
