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.
5 #include "content/browser/indexed_db/indexed_db_callbacks.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"
15 #include "content/browser/indexed_db/indexed_db_connection.h"
16 #include "content/browser/indexed_db/indexed_db_context_impl.h"
17 #include "content/browser/indexed_db/indexed_db_cursor.h"
18 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
19 #include "content/browser/indexed_db/indexed_db_database_error.h"
20 #include "content/browser/indexed_db/indexed_db_metadata.h"
21 #include "content/browser/indexed_db/indexed_db_value.h"
22 #include "content/common/indexed_db/indexed_db_constants.h"
23 #include "content/common/indexed_db/indexed_db_messages.h"
24 #include "webkit/browser/blob/blob_storage_context.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"
29 using webkit_blob::ShareableFileReference;
34 const int32 kNoCursor = -1;
35 const int32 kNoDatabaseCallbacks = -1;
36 const int64 kNoTransaction = -1;
39 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
41 int32 ipc_callbacks_id)
42 : dispatcher_host_(dispatcher_host),
43 ipc_callbacks_id_(ipc_callbacks_id),
44 ipc_thread_id_(ipc_thread_id),
45 ipc_cursor_id_(kNoCursor),
46 host_transaction_id_(kNoTransaction),
47 ipc_database_id_(kNoDatabase),
48 ipc_database_callbacks_id_(kNoDatabaseCallbacks),
49 data_loss_(blink::WebIDBDataLossNone),
50 sent_blocked_(false) {
53 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
55 int32 ipc_callbacks_id,
57 : dispatcher_host_(dispatcher_host),
58 ipc_callbacks_id_(ipc_callbacks_id),
59 ipc_thread_id_(ipc_thread_id),
60 ipc_cursor_id_(ipc_cursor_id),
61 host_transaction_id_(kNoTransaction),
62 ipc_database_id_(kNoDatabase),
63 ipc_database_callbacks_id_(kNoDatabaseCallbacks),
64 data_loss_(blink::WebIDBDataLossNone),
65 sent_blocked_(false) {
68 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
70 int32 ipc_callbacks_id,
71 int32 ipc_database_callbacks_id,
72 int64 host_transaction_id,
73 const GURL& origin_url)
74 : dispatcher_host_(dispatcher_host),
75 ipc_callbacks_id_(ipc_callbacks_id),
76 ipc_thread_id_(ipc_thread_id),
77 ipc_cursor_id_(kNoCursor),
78 host_transaction_id_(host_transaction_id),
79 origin_url_(origin_url),
80 ipc_database_id_(kNoDatabase),
81 ipc_database_callbacks_id_(ipc_database_callbacks_id),
82 data_loss_(blink::WebIDBDataLossNone),
83 sent_blocked_(false) {
86 IndexedDBCallbacks::~IndexedDBCallbacks() {}
88 void IndexedDBCallbacks::OnError(const IndexedDBDatabaseError& error) {
89 DCHECK(dispatcher_host_.get());
91 dispatcher_host_->Send(new IndexedDBMsg_CallbacksError(
92 ipc_thread_id_, ipc_callbacks_id_, error.code(), error.message()));
93 dispatcher_host_ = NULL;
96 void IndexedDBCallbacks::OnSuccess(const std::vector<base::string16>& value) {
97 DCHECK(dispatcher_host_.get());
99 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
100 DCHECK_EQ(kNoTransaction, host_transaction_id_);
101 DCHECK_EQ(kNoDatabase, ipc_database_id_);
102 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
103 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
105 std::vector<base::string16> list;
106 for (unsigned i = 0; i < value.size(); ++i)
107 list.push_back(value[i]);
109 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessStringList(
110 ipc_thread_id_, ipc_callbacks_id_, list));
111 dispatcher_host_ = NULL;
114 void IndexedDBCallbacks::OnBlocked(int64 existing_version) {
115 DCHECK(dispatcher_host_.get());
117 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
118 // No transaction/db callbacks for DeleteDatabase.
119 DCHECK_EQ(kNoTransaction == host_transaction_id_,
120 kNoDatabaseCallbacks == ipc_database_callbacks_id_);
121 DCHECK_EQ(kNoDatabase, ipc_database_id_);
126 sent_blocked_ = true;
127 dispatcher_host_->Send(new IndexedDBMsg_CallbacksIntBlocked(
128 ipc_thread_id_, ipc_callbacks_id_, existing_version));
131 void IndexedDBCallbacks::OnDataLoss(blink::WebIDBDataLoss data_loss,
132 std::string data_loss_message) {
133 DCHECK_NE(blink::WebIDBDataLossNone, data_loss);
134 data_loss_ = data_loss;
135 data_loss_message_ = data_loss_message;
138 void IndexedDBCallbacks::OnUpgradeNeeded(
140 scoped_ptr<IndexedDBConnection> connection,
141 const IndexedDBDatabaseMetadata& metadata) {
142 DCHECK(dispatcher_host_.get());
144 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
145 DCHECK_NE(kNoTransaction, host_transaction_id_);
146 DCHECK_EQ(kNoDatabase, ipc_database_id_);
147 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
149 dispatcher_host_->RegisterTransactionId(host_transaction_id_, origin_url_);
150 int32 ipc_database_id =
151 dispatcher_host_->Add(connection.release(), ipc_thread_id_, origin_url_);
152 if (ipc_database_id < 0)
154 ipc_database_id_ = ipc_database_id;
155 IndexedDBMsg_CallbacksUpgradeNeeded_Params params;
156 params.ipc_thread_id = ipc_thread_id_;
157 params.ipc_callbacks_id = ipc_callbacks_id_;
158 params.ipc_database_id = ipc_database_id;
159 params.ipc_database_callbacks_id = ipc_database_callbacks_id_;
160 params.old_version = old_version;
161 params.idb_metadata = IndexedDBDispatcherHost::ConvertMetadata(metadata);
162 params.data_loss = data_loss_;
163 params.data_loss_message = data_loss_message_;
164 dispatcher_host_->Send(new IndexedDBMsg_CallbacksUpgradeNeeded(params));
167 void IndexedDBCallbacks::OnSuccess(scoped_ptr<IndexedDBConnection> connection,
168 const IndexedDBDatabaseMetadata& metadata) {
169 DCHECK(dispatcher_host_.get());
171 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
172 DCHECK_NE(kNoTransaction, host_transaction_id_);
173 DCHECK_NE(ipc_database_id_ == kNoDatabase, !connection);
174 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
176 scoped_refptr<IndexedDBCallbacks> self(this);
178 int32 ipc_object_id = kNoDatabase;
179 // Only register if the connection was not previously sent in OnUpgradeNeeded.
180 if (ipc_database_id_ == kNoDatabase) {
181 ipc_object_id = dispatcher_host_->Add(
182 connection.release(), ipc_thread_id_, origin_url_);
185 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBDatabase(
188 ipc_database_callbacks_id_,
190 IndexedDBDispatcherHost::ConvertMetadata(metadata)));
191 dispatcher_host_ = NULL;
194 static std::string CreateBlobData(
195 const IndexedDBBlobInfo& blob_info,
196 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
197 webkit_blob::BlobStorageContext* blob_storage_context,
198 base::TaskRunner* task_runner) {
199 std::string uuid = blob_info.uuid();
201 // We're sending back a live blob, not a reference into our backing store.
202 scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle(
203 blob_storage_context->GetBlobDataFromUUID(uuid));
204 dispatcher_host->HoldBlobDataHandle(uuid, blob_data_handle.Pass());
207 scoped_refptr<ShareableFileReference> shareable_file =
208 ShareableFileReference::Get(blob_info.file_path());
209 if (!shareable_file.get()) {
210 shareable_file = ShareableFileReference::GetOrCreate(
211 blob_info.file_path(),
212 ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
214 if (!blob_info.release_callback().is_null())
215 shareable_file->AddFinalReleaseCallback(blob_info.release_callback());
218 uuid = base::GenerateGUID();
219 scoped_refptr<webkit_blob::BlobData> blob_data =
220 new webkit_blob::BlobData(uuid);
221 blob_data->AppendFile(
222 blob_info.file_path(), 0, blob_info.size(), blob_info.last_modified());
223 scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle(
224 blob_storage_context->AddFinishedBlob(blob_data.get()));
225 dispatcher_host->HoldBlobDataHandle(uuid, blob_data_handle.Pass());
230 static bool CreateAllBlobs(
231 const std::vector<IndexedDBBlobInfo>& blob_info,
232 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info,
233 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host) {
234 DCHECK_EQ(blob_info.size(), blob_or_file_info->size());
236 if (!dispatcher_host->blob_storage_context())
238 for (i = 0; i < blob_info.size(); ++i) {
239 (*blob_or_file_info)[i].uuid =
240 CreateBlobData(blob_info[i],
242 dispatcher_host->blob_storage_context(),
243 dispatcher_host->Context()->TaskRunner());
248 template <class ParamType, class MsgType>
249 static void CreateBlobsAndSend(
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(new MsgType(*params));
259 static void BlobLookupForCursorPrefetch(
260 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params* params,
261 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
262 const std::vector<IndexedDBValue>& values) {
263 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
264 DCHECK_EQ(values.size(), params->blob_or_file_infos.size());
266 std::vector<IndexedDBValue>::const_iterator value_iter;
267 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >::iterator blob_iter;
268 for (value_iter = values.begin(), blob_iter =
269 params->blob_or_file_infos.begin(); value_iter != values.end();
270 ++value_iter, ++blob_iter) {
271 if (!CreateAllBlobs(value_iter->blob_info, &*blob_iter, dispatcher_host))
274 dispatcher_host->Send(
275 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params));
278 static void FillInBlobData(
279 const std::vector<IndexedDBBlobInfo>& blob_info,
280 std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info) {
281 for (std::vector<IndexedDBBlobInfo>::const_iterator iter = blob_info.begin();
282 iter != blob_info.end();
284 if (iter->is_file()) {
285 IndexedDBMsg_BlobOrFileInfo info;
287 info.mime_type = iter->type();
288 info.file_name = iter->file_name();
289 info.file_path = iter->file_path().AsUTF16Unsafe();
290 info.size = iter->size();
291 info.last_modified = iter->last_modified().ToDoubleT();
292 blob_or_file_info->push_back(info);
294 IndexedDBMsg_BlobOrFileInfo info;
295 info.mime_type = iter->type();
296 info.size = iter->size();
297 blob_or_file_info->push_back(info);
302 void IndexedDBCallbacks::RegisterBlobsAndSend(
303 const std::vector<IndexedDBBlobInfo>& blob_info,
304 const base::Closure& callback) {
305 std::vector<IndexedDBBlobInfo>::const_iterator iter;
306 for (iter = blob_info.begin(); iter != blob_info.end(); ++iter) {
307 if (!iter->mark_used_callback().is_null())
308 iter->mark_used_callback().Run();
310 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
311 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback);
314 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
315 const IndexedDBKey& key,
316 const IndexedDBKey& primary_key,
317 IndexedDBValue* value) {
318 DCHECK(dispatcher_host_.get());
320 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
321 DCHECK_EQ(kNoTransaction, host_transaction_id_);
322 DCHECK_EQ(kNoDatabase, ipc_database_id_);
323 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
324 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
326 int32 ipc_object_id = dispatcher_host_->Add(cursor.get());
327 scoped_ptr<IndexedDBMsg_CallbacksSuccessIDBCursor_Params> params(
328 new IndexedDBMsg_CallbacksSuccessIDBCursor_Params());
329 params->ipc_thread_id = ipc_thread_id_;
330 params->ipc_callbacks_id = ipc_callbacks_id_;
331 params->ipc_cursor_id = ipc_object_id;
333 params->primary_key = primary_key;
334 if (value && !value->empty())
335 std::swap(params->value, value->bits);
336 // TODO(alecflett): Avoid a copy here: the whole params object is
337 // being copied into the message.
338 if (!value || value->blob_info.empty()) {
339 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(*params));
341 IndexedDBMsg_CallbacksSuccessIDBCursor_Params* p = params.get();
342 FillInBlobData(value->blob_info, &p->blob_or_file_info);
343 RegisterBlobsAndSend(
346 CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessIDBCursor_Params,
347 IndexedDBMsg_CallbacksSuccessIDBCursor>,
348 base::Owned(params.release()),
351 base::Unretained(&p->blob_or_file_info)));
353 dispatcher_host_ = NULL;
356 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key,
357 const IndexedDBKey& primary_key,
358 IndexedDBValue* value) {
359 DCHECK(dispatcher_host_.get());
361 DCHECK_NE(kNoCursor, ipc_cursor_id_);
362 DCHECK_EQ(kNoTransaction, host_transaction_id_);
363 DCHECK_EQ(kNoDatabase, ipc_database_id_);
364 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
365 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
367 IndexedDBCursor* idb_cursor =
368 dispatcher_host_->GetCursorFromId(ipc_cursor_id_);
374 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorContinue_Params> params(
375 new IndexedDBMsg_CallbacksSuccessCursorContinue_Params());
376 params->ipc_thread_id = ipc_thread_id_;
377 params->ipc_callbacks_id = ipc_callbacks_id_;
378 params->ipc_cursor_id = ipc_cursor_id_;
380 params->primary_key = primary_key;
381 if (value && !value->empty())
382 std::swap(params->value, value->bits);
383 // TODO(alecflett): Avoid a copy here: the whole params object is
384 // being copied into the message.
385 if (!value || value->blob_info.empty()) {
386 dispatcher_host_->Send(
387 new IndexedDBMsg_CallbacksSuccessCursorContinue(*params));
389 IndexedDBMsg_CallbacksSuccessCursorContinue_Params* p = params.get();
390 FillInBlobData(value->blob_info, &p->blob_or_file_info);
391 RegisterBlobsAndSend(
393 base::Bind(CreateBlobsAndSend<
394 IndexedDBMsg_CallbacksSuccessCursorContinue_Params,
395 IndexedDBMsg_CallbacksSuccessCursorContinue>,
396 base::Owned(params.release()),
399 base::Unretained(&p->blob_or_file_info)));
401 dispatcher_host_ = NULL;
404 void IndexedDBCallbacks::OnSuccessWithPrefetch(
405 const std::vector<IndexedDBKey>& keys,
406 const std::vector<IndexedDBKey>& primary_keys,
407 std::vector<IndexedDBValue>* values) {
408 DCHECK_EQ(keys.size(), primary_keys.size());
409 DCHECK_EQ(keys.size(), values->size());
411 DCHECK(dispatcher_host_.get());
413 DCHECK_NE(kNoCursor, ipc_cursor_id_);
414 DCHECK_EQ(kNoTransaction, host_transaction_id_);
415 DCHECK_EQ(kNoDatabase, ipc_database_id_);
416 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
417 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
419 std::vector<IndexedDBKey> msgKeys;
420 std::vector<IndexedDBKey> msgPrimaryKeys;
422 for (size_t i = 0; i < keys.size(); ++i) {
423 msgKeys.push_back(keys[i]);
424 msgPrimaryKeys.push_back(primary_keys[i]);
427 scoped_ptr<IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params> params(
428 new IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params());
429 params->ipc_thread_id = ipc_thread_id_;
430 params->ipc_callbacks_id = ipc_callbacks_id_;
431 params->ipc_cursor_id = ipc_cursor_id_;
432 params->keys = msgKeys;
433 params->primary_keys = msgPrimaryKeys;
434 std::vector<std::string>& values_bits = params->values;
435 values_bits.resize(values->size());
436 std::vector<std::vector<IndexedDBMsg_BlobOrFileInfo> >& values_blob_infos =
437 params->blob_or_file_infos;
438 values_blob_infos.resize(values->size());
440 bool found_blob_info = false;
441 std::vector<IndexedDBValue>::iterator iter = values->begin();
442 for (size_t i = 0; iter != values->end(); ++iter, ++i) {
443 values_bits[i].swap(iter->bits);
444 if (iter->blob_info.size()) {
445 found_blob_info = true;
446 FillInBlobData(iter->blob_info, &values_blob_infos[i]);
447 std::vector<IndexedDBBlobInfo>::const_iterator blob_iter;
448 for (blob_iter = iter->blob_info.begin();
449 blob_iter != iter->blob_info.end();
451 if (!blob_iter->mark_used_callback().is_null())
452 blob_iter->mark_used_callback().Run();
457 if (found_blob_info) {
458 BrowserThread::PostTask(BrowserThread::IO,
460 base::Bind(BlobLookupForCursorPrefetch,
461 base::Owned(params.release()),
465 dispatcher_host_->Send(
466 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params.get()));
468 dispatcher_host_ = NULL;
471 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value,
472 const IndexedDBKey& key,
473 const IndexedDBKeyPath& key_path) {
474 DCHECK(dispatcher_host_.get());
476 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
477 DCHECK_EQ(kNoTransaction, host_transaction_id_);
478 DCHECK_EQ(kNoDatabase, ipc_database_id_);
479 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
480 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
482 scoped_ptr<IndexedDBMsg_CallbacksSuccessValueWithKey_Params> params(
483 new IndexedDBMsg_CallbacksSuccessValueWithKey_Params());
484 params->ipc_thread_id = ipc_thread_id_;
485 params->ipc_callbacks_id = ipc_callbacks_id_;
486 params->primary_key = key;
487 params->key_path = key_path;
488 if (value && !value->empty())
489 std::swap(params->value, value->bits);
490 if (!value || value->blob_info.empty()) {
491 dispatcher_host_->Send(
492 new IndexedDBMsg_CallbacksSuccessValueWithKey(*params));
494 IndexedDBMsg_CallbacksSuccessValueWithKey_Params* p = params.get();
495 FillInBlobData(value->blob_info, &p->blob_or_file_info);
496 RegisterBlobsAndSend(
499 CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValueWithKey_Params,
500 IndexedDBMsg_CallbacksSuccessValueWithKey>,
501 base::Owned(params.release()),
504 base::Unretained(&p->blob_or_file_info)));
506 dispatcher_host_ = NULL;
509 void IndexedDBCallbacks::OnSuccess(IndexedDBValue* value) {
510 DCHECK(dispatcher_host_.get());
511 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL);
512 DCHECK_EQ(kNoTransaction, host_transaction_id_);
513 DCHECK_EQ(kNoDatabase, ipc_database_id_);
514 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
515 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
517 scoped_ptr<IndexedDBMsg_CallbacksSuccessValue_Params> params(
518 new IndexedDBMsg_CallbacksSuccessValue_Params());
519 params->ipc_thread_id = ipc_thread_id_;
520 params->ipc_callbacks_id = ipc_callbacks_id_;
521 if (value && !value->empty())
522 std::swap(params->value, value->bits);
523 if (!value || value->blob_info.empty()) {
524 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue(*params));
526 IndexedDBMsg_CallbacksSuccessValue_Params* p = params.get();
527 FillInBlobData(value->blob_info, &p->blob_or_file_info);
528 RegisterBlobsAndSend(
530 base::Bind(CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValue_Params,
531 IndexedDBMsg_CallbacksSuccessValue>,
532 base::Owned(params.release()),
535 base::Unretained(&p->blob_or_file_info)));
537 dispatcher_host_ = NULL;
540 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) {
541 DCHECK(dispatcher_host_.get());
543 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
544 DCHECK_EQ(kNoTransaction, host_transaction_id_);
545 DCHECK_EQ(kNoDatabase, ipc_database_id_);
546 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
547 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
549 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIndexedDBKey(
550 ipc_thread_id_, ipc_callbacks_id_, value));
551 dispatcher_host_ = NULL;
554 void IndexedDBCallbacks::OnSuccess(int64 value) {
555 DCHECK(dispatcher_host_.get());
557 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
558 DCHECK_EQ(kNoTransaction, host_transaction_id_);
559 DCHECK_EQ(kNoDatabase, ipc_database_id_);
560 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
561 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
563 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessInteger(
564 ipc_thread_id_, ipc_callbacks_id_, value));
565 dispatcher_host_ = NULL;
568 void IndexedDBCallbacks::OnSuccess() {
569 DCHECK(dispatcher_host_.get());
571 DCHECK_EQ(kNoCursor, ipc_cursor_id_);
572 DCHECK_EQ(kNoTransaction, host_transaction_id_);
573 DCHECK_EQ(kNoDatabase, ipc_database_id_);
574 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
575 DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
577 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined(
578 ipc_thread_id_, ipc_callbacks_id_));
579 dispatcher_host_ = NULL;
582 } // namespace content