Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(205)

Side by Side Diff: content/browser/service_worker/service_worker_storage.cc

Issue 1146913004: Service Worker: Add ServiceWorkerContainer.getRegistrations() method. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Use scoped_refptr to ServiceWorkerRegistration and rename variables. Created 5 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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 568 matching lines...) Expand 10 before | Expand all | Expand 10 after
1093 void ServiceWorkerStorage::ReturnFoundRegistration( 1092 void ServiceWorkerStorage::ReturnFoundRegistration(
1094 const FindRegistrationCallback& callback, 1093 const FindRegistrationCallback& callback,
1095 const ServiceWorkerDatabase::RegistrationData& data, 1094 const ServiceWorkerDatabase::RegistrationData& data,
1096 const ResourceList& resources) { 1095 const ResourceList& resources) {
1097 scoped_refptr<ServiceWorkerRegistration> registration = 1096 scoped_refptr<ServiceWorkerRegistration> registration =
1098 GetOrCreateRegistration(data, resources); 1097 GetOrCreateRegistration(data, resources);
1099 CompleteFindNow(registration, SERVICE_WORKER_OK, callback); 1098 CompleteFindNow(registration, SERVICE_WORKER_OK, callback);
1100 } 1099 }
1101 1100
1102 void ServiceWorkerStorage::DidGetRegistrations( 1101 void ServiceWorkerStorage::DidGetRegistrations(
1103 const GetRegistrationsInfosCallback& callback, 1102 const GetRegistrationsCallback& callback,
1104 RegistrationList* registrations, 1103 RegistrationList* registration_data_list,
1104 std::vector<ResourceList>* resources_list,
1105 const GURL& origin_filter, 1105 const GURL& origin_filter,
1106 ServiceWorkerDatabase::Status status) { 1106 ServiceWorkerDatabase::Status status) {
1107 DCHECK(registrations); 1107 DCHECK(registration_data_list);
1108 DCHECK(resources_list);
1109
1108 if (status != ServiceWorkerDatabase::STATUS_OK && 1110 if (status != ServiceWorkerDatabase::STATUS_OK &&
1109 status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) { 1111 status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
1110 ScheduleDeleteAndStartOver(); 1112 ScheduleDeleteAndStartOver();
1113 callback.Run(std::vector<scoped_refptr<ServiceWorkerRegistration>>());
1114 return;
1115 }
1116
1117 // Add all stored registrations.
1118 std::set<int64> registration_ids;
1119 std::vector<scoped_refptr<ServiceWorkerRegistration>> registrations;
1120 size_t index = 0;
1121 for (const auto& registration_data : *registration_data_list) {
1122 registration_ids.insert(registration_data.registration_id);
1123 registrations.push_back(GetOrCreateRegistration(
1124 registration_data, resources_list->at(index++)));
1125 }
1126
1127 // Add unstored registrations that are being installed.
1128 for (RegistrationRefsById::const_iterator it =
1129 installing_registrations_.begin();
1130 it != installing_registrations_.end(); ++it) {
1131 if ((!origin_filter.is_valid() ||
1132 it->second->pattern().GetOrigin() == origin_filter) &&
1133 registration_ids.insert(it->first).second) {
1134 registrations.push_back((it->second).get());
1135 }
1136 }
1137
1138 callback.Run(registrations);
1139 }
1140
1141 void ServiceWorkerStorage::DidGetRegistrationsInfos(
1142 const GetRegistrationsInfosCallback& callback,
1143 RegistrationList* registration_data_list,
1144 const GURL& origin_filter,
1145 ServiceWorkerDatabase::Status status) {
1146 DCHECK(registration_data_list);
1147 if (status != ServiceWorkerDatabase::STATUS_OK &&
1148 status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
1149 ScheduleDeleteAndStartOver();
1111 callback.Run(std::vector<ServiceWorkerRegistrationInfo>()); 1150 callback.Run(std::vector<ServiceWorkerRegistrationInfo>());
1112 return; 1151 return;
1113 } 1152 }
1114 1153
1115 // Add all stored registrations. 1154 // Add all stored registrations.
1116 std::set<int64> pushed_registrations; 1155 std::set<int64> pushed_registrations;
1117 std::vector<ServiceWorkerRegistrationInfo> infos; 1156 std::vector<ServiceWorkerRegistrationInfo> infos;
1118 for (const auto& registration_data : *registrations) { 1157 for (const auto& registration_data : *registration_data_list) {
1119 const bool inserted = 1158 const bool inserted =
1120 pushed_registrations.insert(registration_data.registration_id).second; 1159 pushed_registrations.insert(registration_data.registration_id).second;
1121 DCHECK(inserted); 1160 DCHECK(inserted);
1122 1161
1123 ServiceWorkerRegistration* registration = 1162 ServiceWorkerRegistration* registration =
1124 context_->GetLiveRegistration(registration_data.registration_id); 1163 context_->GetLiveRegistration(registration_data.registration_id);
1125 if (registration) { 1164 if (registration) {
1126 infos.push_back(registration->GetInfo()); 1165 infos.push_back(registration->GetInfo());
1127 continue; 1166 continue;
1128 } 1167 }
(...skipping 434 matching lines...) Expand 10 before | Expand all | Expand 10 after
1563 if (status != ServiceWorkerDatabase::STATUS_OK) { 1602 if (status != ServiceWorkerDatabase::STATUS_OK) {
1564 original_task_runner->PostTask( 1603 original_task_runner->PostTask(
1565 FROM_HERE, 1604 FROM_HERE,
1566 base::Bind( 1605 base::Bind(
1567 callback, false, deleted_version, std::vector<int64>(), status)); 1606 callback, false, deleted_version, std::vector<int64>(), status));
1568 return; 1607 return;
1569 } 1608 }
1570 1609
1571 // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the 1610 // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the
1572 // unique origin list. 1611 // unique origin list.
1573 std::vector<ServiceWorkerDatabase::RegistrationData> registrations; 1612 RegistrationList registrations;
1574 status = database->GetRegistrationsForOrigin(origin, &registrations); 1613 status = database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
1575 if (status != ServiceWorkerDatabase::STATUS_OK) { 1614 if (status != ServiceWorkerDatabase::STATUS_OK) {
1576 original_task_runner->PostTask( 1615 original_task_runner->PostTask(
1577 FROM_HERE, 1616 FROM_HERE,
1578 base::Bind( 1617 base::Bind(
1579 callback, false, deleted_version, std::vector<int64>(), status)); 1618 callback, false, deleted_version, std::vector<int64>(), status));
1580 return; 1619 return;
1581 } 1620 }
1582 1621
1583 bool deletable = registrations.empty(); 1622 bool deletable = registrations.empty();
1584 original_task_runner->PostTask(FROM_HERE, 1623 original_task_runner->PostTask(FROM_HERE,
(...skipping 24 matching lines...) Expand all
1609 } 1648 }
1610 1649
1611 void ServiceWorkerStorage::FindForDocumentInDB( 1650 void ServiceWorkerStorage::FindForDocumentInDB(
1612 ServiceWorkerDatabase* database, 1651 ServiceWorkerDatabase* database,
1613 scoped_refptr<base::SequencedTaskRunner> original_task_runner, 1652 scoped_refptr<base::SequencedTaskRunner> original_task_runner,
1614 const GURL& document_url, 1653 const GURL& document_url,
1615 const FindInDBCallback& callback) { 1654 const FindInDBCallback& callback) {
1616 GURL origin = document_url.GetOrigin(); 1655 GURL origin = document_url.GetOrigin();
1617 RegistrationList registrations; 1656 RegistrationList registrations;
1618 ServiceWorkerDatabase::Status status = 1657 ServiceWorkerDatabase::Status status =
1619 database->GetRegistrationsForOrigin(origin, &registrations); 1658 database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
1620 if (status != ServiceWorkerDatabase::STATUS_OK) { 1659 if (status != ServiceWorkerDatabase::STATUS_OK) {
1621 original_task_runner->PostTask( 1660 original_task_runner->PostTask(
1622 FROM_HERE, 1661 FROM_HERE,
1623 base::Bind(callback, 1662 base::Bind(callback,
1624 ServiceWorkerDatabase::RegistrationData(), 1663 ServiceWorkerDatabase::RegistrationData(),
1625 ResourceList(), 1664 ResourceList(),
1626 status)); 1665 status));
1627 return; 1666 return;
1628 } 1667 }
1629 1668
(...skipping 16 matching lines...) Expand all
1646 FROM_HERE, 1685 FROM_HERE,
1647 base::Bind(callback, data, resources, status)); 1686 base::Bind(callback, data, resources, status));
1648 } 1687 }
1649 1688
1650 void ServiceWorkerStorage::FindForPatternInDB( 1689 void ServiceWorkerStorage::FindForPatternInDB(
1651 ServiceWorkerDatabase* database, 1690 ServiceWorkerDatabase* database,
1652 scoped_refptr<base::SequencedTaskRunner> original_task_runner, 1691 scoped_refptr<base::SequencedTaskRunner> original_task_runner,
1653 const GURL& scope, 1692 const GURL& scope,
1654 const FindInDBCallback& callback) { 1693 const FindInDBCallback& callback) {
1655 GURL origin = scope.GetOrigin(); 1694 GURL origin = scope.GetOrigin();
1656 std::vector<ServiceWorkerDatabase::RegistrationData> registrations; 1695 RegistrationList registrations;
1657 ServiceWorkerDatabase::Status status = 1696 ServiceWorkerDatabase::Status status =
1658 database->GetRegistrationsForOrigin(origin, &registrations); 1697 database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
1659 if (status != ServiceWorkerDatabase::STATUS_OK) { 1698 if (status != ServiceWorkerDatabase::STATUS_OK) {
1660 original_task_runner->PostTask( 1699 original_task_runner->PostTask(
1661 FROM_HERE, 1700 FROM_HERE,
1662 base::Bind(callback, 1701 base::Bind(callback,
1663 ServiceWorkerDatabase::RegistrationData(), 1702 ServiceWorkerDatabase::RegistrationData(),
1664 ResourceList(), 1703 ResourceList(),
1665 status)); 1704 status));
1666 return; 1705 return;
1667 } 1706 }
1668 1707
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after
1807 callback.Run(SERVICE_WORKER_ERROR_FAILED); 1846 callback.Run(SERVICE_WORKER_ERROR_FAILED);
1808 return; 1847 return;
1809 } 1848 }
1810 DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully."; 1849 DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
1811 ServiceWorkerMetrics::RecordDeleteAndStartOverResult( 1850 ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
1812 ServiceWorkerMetrics::DELETE_OK); 1851 ServiceWorkerMetrics::DELETE_OK);
1813 callback.Run(SERVICE_WORKER_OK); 1852 callback.Run(SERVICE_WORKER_OK);
1814 } 1853 }
1815 1854
1816 } // namespace content 1855 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698