OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/service_worker/service_worker_storage.h" | 5 #include "content/browser/service_worker/service_worker_storage.h" |
6 | 6 |
7 #include "base/bind_helpers.h" | 7 #include "base/bind_helpers.h" |
8 #include "base/files/file_util.h" | 8 #include "base/files/file_util.h" |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 #include "base/sequenced_task_runner.h" | 10 #include "base/sequenced_task_runner.h" |
(...skipping 442 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
453 base::Bind(&FindForIdOnlyInDB, | 453 base::Bind(&FindForIdOnlyInDB, |
454 database_.get(), | 454 database_.get(), |
455 base::ThreadTaskRunnerHandle::Get(), | 455 base::ThreadTaskRunnerHandle::Get(), |
456 registration_id, | 456 registration_id, |
457 base::Bind(&ServiceWorkerStorage::DidFindRegistrationForId, | 457 base::Bind(&ServiceWorkerStorage::DidFindRegistrationForId, |
458 weak_factory_.GetWeakPtr(), | 458 weak_factory_.GetWeakPtr(), |
459 callback))); | 459 callback))); |
460 } | 460 } |
461 | 461 |
462 void ServiceWorkerStorage::GetRegistrationsForOrigin( | 462 void ServiceWorkerStorage::GetRegistrationsForOrigin( |
463 const GURL& origin, const GetRegistrationsInfosCallback& callback) { | 463 const GURL& origin, |
| 464 const GetRegistrationsCallback& callback) { |
464 if (!LazyInitialize(base::Bind( | 465 if (!LazyInitialize(base::Bind( |
465 &ServiceWorkerStorage::GetRegistrationsForOrigin, | 466 &ServiceWorkerStorage::GetRegistrationsForOrigin, |
466 weak_factory_.GetWeakPtr(), origin, callback))) { | 467 weak_factory_.GetWeakPtr(), origin, callback))) { |
467 if (state_ != INITIALIZING || !context_) { | 468 if (state_ != INITIALIZING || !context_) { |
468 RunSoon(FROM_HERE, base::Bind( | 469 RunSoon( |
469 callback, std::vector<ServiceWorkerRegistrationInfo>())); | 470 FROM_HERE, |
| 471 base::Bind(callback, |
| 472 std::vector<scoped_refptr<ServiceWorkerRegistration>>())); |
470 } | 473 } |
471 return; | 474 return; |
472 } | 475 } |
473 DCHECK_EQ(INITIALIZED, state_); | 476 DCHECK_EQ(INITIALIZED, state_); |
474 | 477 |
475 RegistrationList* registrations = new RegistrationList; | 478 RegistrationList* registrations = new RegistrationList; |
| 479 std::vector<ResourceList>* resource_lists = new std::vector<ResourceList>; |
476 PostTaskAndReplyWithResult( | 480 PostTaskAndReplyWithResult( |
477 database_task_manager_->GetTaskRunner(), | 481 database_task_manager_->GetTaskRunner(), FROM_HERE, |
478 FROM_HERE, | |
479 base::Bind(&ServiceWorkerDatabase::GetRegistrationsForOrigin, | 482 base::Bind(&ServiceWorkerDatabase::GetRegistrationsForOrigin, |
480 base::Unretained(database_.get()), | 483 base::Unretained(database_.get()), origin, |
481 origin, | 484 base::Unretained(registrations), |
482 base::Unretained(registrations)), | 485 base::Unretained(resource_lists)), |
483 base::Bind(&ServiceWorkerStorage::DidGetRegistrations, | 486 base::Bind(&ServiceWorkerStorage::DidGetRegistrations, |
484 weak_factory_.GetWeakPtr(), | 487 weak_factory_.GetWeakPtr(), callback, |
485 callback, | 488 base::Owned(registrations), base::Owned(resource_lists), |
486 base::Owned(registrations), | |
487 origin)); | 489 origin)); |
488 } | 490 } |
489 | 491 |
490 void ServiceWorkerStorage::GetAllRegistrations( | 492 void ServiceWorkerStorage::GetAllRegistrationsInfos( |
491 const GetRegistrationsInfosCallback& callback) { | 493 const GetRegistrationsInfosCallback& callback) { |
492 if (!LazyInitialize(base::Bind( | 494 if (!LazyInitialize( |
493 &ServiceWorkerStorage::GetAllRegistrations, | 495 base::Bind(&ServiceWorkerStorage::GetAllRegistrationsInfos, |
494 weak_factory_.GetWeakPtr(), callback))) { | 496 weak_factory_.GetWeakPtr(), callback))) { |
495 if (state_ != INITIALIZING || !context_) { | 497 if (state_ != INITIALIZING || !context_) { |
496 RunSoon(FROM_HERE, base::Bind( | 498 RunSoon(FROM_HERE, base::Bind( |
497 callback, std::vector<ServiceWorkerRegistrationInfo>())); | 499 callback, std::vector<ServiceWorkerRegistrationInfo>())); |
498 } | 500 } |
499 return; | 501 return; |
500 } | 502 } |
501 DCHECK_EQ(INITIALIZED, state_); | 503 DCHECK_EQ(INITIALIZED, state_); |
502 | 504 |
503 RegistrationList* registrations = new RegistrationList; | 505 RegistrationList* registrations = new RegistrationList; |
504 PostTaskAndReplyWithResult( | 506 PostTaskAndReplyWithResult( |
505 database_task_manager_->GetTaskRunner(), | 507 database_task_manager_->GetTaskRunner(), FROM_HERE, |
506 FROM_HERE, | |
507 base::Bind(&ServiceWorkerDatabase::GetAllRegistrations, | 508 base::Bind(&ServiceWorkerDatabase::GetAllRegistrations, |
508 base::Unretained(database_.get()), | 509 base::Unretained(database_.get()), |
509 base::Unretained(registrations)), | 510 base::Unretained(registrations)), |
510 base::Bind(&ServiceWorkerStorage::DidGetRegistrations, | 511 base::Bind(&ServiceWorkerStorage::DidGetRegistrationsInfos, |
511 weak_factory_.GetWeakPtr(), | 512 weak_factory_.GetWeakPtr(), callback, |
512 callback, | 513 base::Owned(registrations), GURL())); |
513 base::Owned(registrations), | |
514 GURL())); | |
515 } | 514 } |
516 | 515 |
517 void ServiceWorkerStorage::StoreRegistration( | 516 void ServiceWorkerStorage::StoreRegistration( |
518 ServiceWorkerRegistration* registration, | 517 ServiceWorkerRegistration* registration, |
519 ServiceWorkerVersion* version, | 518 ServiceWorkerVersion* version, |
520 const StatusCallback& callback) { | 519 const StatusCallback& callback) { |
521 DCHECK(registration); | 520 DCHECK(registration); |
522 DCHECK(version); | 521 DCHECK(version); |
523 | 522 |
524 DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_; | 523 DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_; |
(...skipping 574 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1099 const FindRegistrationCallback& callback, | 1098 const FindRegistrationCallback& callback, |
1100 const ServiceWorkerDatabase::RegistrationData& data, | 1099 const ServiceWorkerDatabase::RegistrationData& data, |
1101 const ResourceList& resources) { | 1100 const ResourceList& resources) { |
1102 DCHECK(!resources.empty()); | 1101 DCHECK(!resources.empty()); |
1103 scoped_refptr<ServiceWorkerRegistration> registration = | 1102 scoped_refptr<ServiceWorkerRegistration> registration = |
1104 GetOrCreateRegistration(data, resources); | 1103 GetOrCreateRegistration(data, resources); |
1105 CompleteFindNow(registration, SERVICE_WORKER_OK, callback); | 1104 CompleteFindNow(registration, SERVICE_WORKER_OK, callback); |
1106 } | 1105 } |
1107 | 1106 |
1108 void ServiceWorkerStorage::DidGetRegistrations( | 1107 void ServiceWorkerStorage::DidGetRegistrations( |
1109 const GetRegistrationsInfosCallback& callback, | 1108 const GetRegistrationsCallback& callback, |
1110 RegistrationList* registrations, | 1109 RegistrationList* registration_data_list, |
| 1110 std::vector<ResourceList>* resources_list, |
1111 const GURL& origin_filter, | 1111 const GURL& origin_filter, |
1112 ServiceWorkerDatabase::Status status) { | 1112 ServiceWorkerDatabase::Status status) { |
1113 DCHECK(registrations); | 1113 DCHECK(registration_data_list); |
| 1114 DCHECK(resources_list); |
| 1115 |
1114 if (status != ServiceWorkerDatabase::STATUS_OK && | 1116 if (status != ServiceWorkerDatabase::STATUS_OK && |
1115 status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) { | 1117 status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) { |
1116 ScheduleDeleteAndStartOver(); | 1118 ScheduleDeleteAndStartOver(); |
| 1119 callback.Run(std::vector<scoped_refptr<ServiceWorkerRegistration>>()); |
| 1120 return; |
| 1121 } |
| 1122 |
| 1123 // Add all stored registrations. |
| 1124 std::set<int64> registration_ids; |
| 1125 std::vector<scoped_refptr<ServiceWorkerRegistration>> registrations; |
| 1126 size_t index = 0; |
| 1127 for (const auto& registration_data : *registration_data_list) { |
| 1128 registration_ids.insert(registration_data.registration_id); |
| 1129 registrations.push_back(GetOrCreateRegistration( |
| 1130 registration_data, resources_list->at(index++))); |
| 1131 } |
| 1132 |
| 1133 // Add unstored registrations that are being installed. |
| 1134 for (RegistrationRefsById::const_iterator it = |
| 1135 installing_registrations_.begin(); |
| 1136 it != installing_registrations_.end(); ++it) { |
| 1137 if ((!origin_filter.is_valid() || |
| 1138 it->second->pattern().GetOrigin() == origin_filter) && |
| 1139 registration_ids.insert(it->first).second) { |
| 1140 registrations.push_back((it->second).get()); |
| 1141 } |
| 1142 } |
| 1143 |
| 1144 callback.Run(registrations); |
| 1145 } |
| 1146 |
| 1147 void ServiceWorkerStorage::DidGetRegistrationsInfos( |
| 1148 const GetRegistrationsInfosCallback& callback, |
| 1149 RegistrationList* registration_data_list, |
| 1150 const GURL& origin_filter, |
| 1151 ServiceWorkerDatabase::Status status) { |
| 1152 DCHECK(registration_data_list); |
| 1153 if (status != ServiceWorkerDatabase::STATUS_OK && |
| 1154 status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) { |
| 1155 ScheduleDeleteAndStartOver(); |
1117 callback.Run(std::vector<ServiceWorkerRegistrationInfo>()); | 1156 callback.Run(std::vector<ServiceWorkerRegistrationInfo>()); |
1118 return; | 1157 return; |
1119 } | 1158 } |
1120 | 1159 |
1121 // Add all stored registrations. | 1160 // Add all stored registrations. |
1122 std::set<int64> pushed_registrations; | 1161 std::set<int64> pushed_registrations; |
1123 std::vector<ServiceWorkerRegistrationInfo> infos; | 1162 std::vector<ServiceWorkerRegistrationInfo> infos; |
1124 for (const auto& registration_data : *registrations) { | 1163 for (const auto& registration_data : *registration_data_list) { |
1125 const bool inserted = | 1164 const bool inserted = |
1126 pushed_registrations.insert(registration_data.registration_id).second; | 1165 pushed_registrations.insert(registration_data.registration_id).second; |
1127 DCHECK(inserted); | 1166 DCHECK(inserted); |
1128 | 1167 |
1129 ServiceWorkerRegistration* registration = | 1168 ServiceWorkerRegistration* registration = |
1130 context_->GetLiveRegistration(registration_data.registration_id); | 1169 context_->GetLiveRegistration(registration_data.registration_id); |
1131 if (registration) { | 1170 if (registration) { |
1132 infos.push_back(registration->GetInfo()); | 1171 infos.push_back(registration->GetInfo()); |
1133 continue; | 1172 continue; |
1134 } | 1173 } |
(...skipping 434 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1569 if (status != ServiceWorkerDatabase::STATUS_OK) { | 1608 if (status != ServiceWorkerDatabase::STATUS_OK) { |
1570 original_task_runner->PostTask( | 1609 original_task_runner->PostTask( |
1571 FROM_HERE, | 1610 FROM_HERE, |
1572 base::Bind( | 1611 base::Bind( |
1573 callback, false, deleted_version, std::vector<int64>(), status)); | 1612 callback, false, deleted_version, std::vector<int64>(), status)); |
1574 return; | 1613 return; |
1575 } | 1614 } |
1576 | 1615 |
1577 // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the | 1616 // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the |
1578 // unique origin list. | 1617 // unique origin list. |
1579 std::vector<ServiceWorkerDatabase::RegistrationData> registrations; | 1618 RegistrationList registrations; |
1580 status = database->GetRegistrationsForOrigin(origin, ®istrations); | 1619 status = database->GetRegistrationsForOrigin(origin, ®istrations, nullptr); |
1581 if (status != ServiceWorkerDatabase::STATUS_OK) { | 1620 if (status != ServiceWorkerDatabase::STATUS_OK) { |
1582 original_task_runner->PostTask( | 1621 original_task_runner->PostTask( |
1583 FROM_HERE, | 1622 FROM_HERE, |
1584 base::Bind( | 1623 base::Bind( |
1585 callback, false, deleted_version, std::vector<int64>(), status)); | 1624 callback, false, deleted_version, std::vector<int64>(), status)); |
1586 return; | 1625 return; |
1587 } | 1626 } |
1588 | 1627 |
1589 bool deletable = registrations.empty(); | 1628 bool deletable = registrations.empty(); |
1590 original_task_runner->PostTask(FROM_HERE, | 1629 original_task_runner->PostTask(FROM_HERE, |
(...skipping 24 matching lines...) Expand all Loading... |
1615 } | 1654 } |
1616 | 1655 |
1617 void ServiceWorkerStorage::FindForDocumentInDB( | 1656 void ServiceWorkerStorage::FindForDocumentInDB( |
1618 ServiceWorkerDatabase* database, | 1657 ServiceWorkerDatabase* database, |
1619 scoped_refptr<base::SequencedTaskRunner> original_task_runner, | 1658 scoped_refptr<base::SequencedTaskRunner> original_task_runner, |
1620 const GURL& document_url, | 1659 const GURL& document_url, |
1621 const FindInDBCallback& callback) { | 1660 const FindInDBCallback& callback) { |
1622 GURL origin = document_url.GetOrigin(); | 1661 GURL origin = document_url.GetOrigin(); |
1623 RegistrationList registrations; | 1662 RegistrationList registrations; |
1624 ServiceWorkerDatabase::Status status = | 1663 ServiceWorkerDatabase::Status status = |
1625 database->GetRegistrationsForOrigin(origin, ®istrations); | 1664 database->GetRegistrationsForOrigin(origin, ®istrations, nullptr); |
1626 if (status != ServiceWorkerDatabase::STATUS_OK) { | 1665 if (status != ServiceWorkerDatabase::STATUS_OK) { |
1627 original_task_runner->PostTask( | 1666 original_task_runner->PostTask( |
1628 FROM_HERE, | 1667 FROM_HERE, |
1629 base::Bind(callback, | 1668 base::Bind(callback, |
1630 ServiceWorkerDatabase::RegistrationData(), | 1669 ServiceWorkerDatabase::RegistrationData(), |
1631 ResourceList(), | 1670 ResourceList(), |
1632 status)); | 1671 status)); |
1633 return; | 1672 return; |
1634 } | 1673 } |
1635 | 1674 |
(...skipping 16 matching lines...) Expand all Loading... |
1652 FROM_HERE, | 1691 FROM_HERE, |
1653 base::Bind(callback, data, resources, status)); | 1692 base::Bind(callback, data, resources, status)); |
1654 } | 1693 } |
1655 | 1694 |
1656 void ServiceWorkerStorage::FindForPatternInDB( | 1695 void ServiceWorkerStorage::FindForPatternInDB( |
1657 ServiceWorkerDatabase* database, | 1696 ServiceWorkerDatabase* database, |
1658 scoped_refptr<base::SequencedTaskRunner> original_task_runner, | 1697 scoped_refptr<base::SequencedTaskRunner> original_task_runner, |
1659 const GURL& scope, | 1698 const GURL& scope, |
1660 const FindInDBCallback& callback) { | 1699 const FindInDBCallback& callback) { |
1661 GURL origin = scope.GetOrigin(); | 1700 GURL origin = scope.GetOrigin(); |
1662 std::vector<ServiceWorkerDatabase::RegistrationData> registrations; | 1701 RegistrationList registrations; |
1663 ServiceWorkerDatabase::Status status = | 1702 ServiceWorkerDatabase::Status status = |
1664 database->GetRegistrationsForOrigin(origin, ®istrations); | 1703 database->GetRegistrationsForOrigin(origin, ®istrations, nullptr); |
1665 if (status != ServiceWorkerDatabase::STATUS_OK) { | 1704 if (status != ServiceWorkerDatabase::STATUS_OK) { |
1666 original_task_runner->PostTask( | 1705 original_task_runner->PostTask( |
1667 FROM_HERE, | 1706 FROM_HERE, |
1668 base::Bind(callback, | 1707 base::Bind(callback, |
1669 ServiceWorkerDatabase::RegistrationData(), | 1708 ServiceWorkerDatabase::RegistrationData(), |
1670 ResourceList(), | 1709 ResourceList(), |
1671 status)); | 1710 status)); |
1672 return; | 1711 return; |
1673 } | 1712 } |
1674 | 1713 |
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1811 callback.Run(SERVICE_WORKER_ERROR_FAILED); | 1850 callback.Run(SERVICE_WORKER_ERROR_FAILED); |
1812 return; | 1851 return; |
1813 } | 1852 } |
1814 DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully."; | 1853 DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully."; |
1815 ServiceWorkerMetrics::RecordDeleteAndStartOverResult( | 1854 ServiceWorkerMetrics::RecordDeleteAndStartOverResult( |
1816 ServiceWorkerMetrics::DELETE_OK); | 1855 ServiceWorkerMetrics::DELETE_OK); |
1817 callback.Run(SERVICE_WORKER_OK); | 1856 callback.Run(SERVICE_WORKER_OK); |
1818 } | 1857 } |
1819 | 1858 |
1820 } // namespace content | 1859 } // namespace content |
OLD | NEW |