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