Service Worker: Add ServiceWorkerContainer.getRegistrations() method.

content/browser/service_worker/service_worker_storage.cc

Index: content/browser/service_worker/service_worker_storage.cc
diff --git a/content/browser/service_worker/service_worker_storage.cc b/content/browser/service_worker/service_worker_storage.cc
index c8a11c39fb3e805332083e5430795a8724fa698e..317389f1f4d20f574cbe6a8a02423fe013a809e5 100644
--- a/content/browser/service_worker/service_worker_storage.cc
+++ b/content/browser/service_worker/service_worker_storage.cc
@@ -460,38 +460,38 @@ void ServiceWorkerStorage::FindRegistrationForIdOnly(
 }
 
 void ServiceWorkerStorage::GetRegistrationsForOrigin(
-    const GURL& origin, const GetRegistrationsInfosCallback& callback) {
+    const GURL& origin,
+    const GetRegistrationsCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::GetRegistrationsForOrigin,
           weak_factory_.GetWeakPtr(), origin, callback))) {
     if (state_ != INITIALIZING || !context_) {
-      RunSoon(FROM_HERE, base::Bind(
-          callback, std::vector<ServiceWorkerRegistrationInfo>()));
+      RunSoon(FROM_HERE,
+              base::Bind(callback, std::vector<ServiceWorkerRegistration*>()));
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   RegistrationList* registrations = new RegistrationList;
+  ResourceListList* resource_lists = new ResourceListList;
   PostTaskAndReplyWithResult(
-      database_task_manager_->GetTaskRunner(),
-      FROM_HERE,
+      database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetRegistrationsForOrigin,
-                 base::Unretained(database_.get()),
-                 origin,
-                 base::Unretained(registrations)),
+                 base::Unretained(database_.get()), origin,
+                 base::Unretained(registrations),
+                 base::Unretained(resource_lists)),
       base::Bind(&ServiceWorkerStorage::DidGetRegistrations,
-                 weak_factory_.GetWeakPtr(),
-                 callback,
-                 base::Owned(registrations),
+                 weak_factory_.GetWeakPtr(), callback,
+                 base::Owned(registrations), base::Owned(resource_lists),
                  origin));
 }
 
-void ServiceWorkerStorage::GetAllRegistrations(
+void ServiceWorkerStorage::GetAllRegistrationsInfos(
     const GetRegistrationsInfosCallback& callback) {
-  if (!LazyInitialize(base::Bind(
-          &ServiceWorkerStorage::GetAllRegistrations,
-          weak_factory_.GetWeakPtr(), callback))) {
+  if (!LazyInitialize(
+          base::Bind(&ServiceWorkerStorage::GetAllRegistrationsInfos,
+                     weak_factory_.GetWeakPtr(), callback))) {
     if (state_ != INITIALIZING || !context_) {
       RunSoon(FROM_HERE, base::Bind(
           callback, std::vector<ServiceWorkerRegistrationInfo>()));
@@ -502,16 +502,13 @@ void ServiceWorkerStorage::GetAllRegistrations(
 
   RegistrationList* registrations = new RegistrationList;
   PostTaskAndReplyWithResult(
-      database_task_manager_->GetTaskRunner(),
-      FROM_HERE,
+      database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetAllRegistrations,
                  base::Unretained(database_.get()),
                  base::Unretained(registrations)),
-      base::Bind(&ServiceWorkerStorage::DidGetRegistrations,
-                 weak_factory_.GetWeakPtr(),
-                 callback,
-                 base::Owned(registrations),
-                 GURL()));
+      base::Bind(&ServiceWorkerStorage::DidGetRegistrationsInfos,
+                 weak_factory_.GetWeakPtr(), callback,
+                 base::Owned(registrations), GURL()));
 }
 
 void ServiceWorkerStorage::StoreRegistration(
@@ -1100,6 +1097,53 @@ void ServiceWorkerStorage::ReturnFoundRegistration(
 }
 
 void ServiceWorkerStorage::DidGetRegistrations(
+    const GetRegistrationsCallback& callback,
+    RegistrationList* registrations,
+    ResourceListList* resource_lists,
+    const GURL& origin_filter,
+    ServiceWorkerDatabase::Status status) {
+  DCHECK(registrations);
+  DCHECK(resource_lists);
+
+  if (status != ServiceWorkerDatabase::STATUS_OK &&
+      status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
+    ScheduleDeleteAndStartOver();
+    callback.Run(std::vector<ServiceWorkerRegistration*>());
+    return;
+  }
+
+  // Add all stored registrations.
+  std::set<int64> pushed_registrations;
+  std::vector<ServiceWorkerRegistration*> regs;

[falken, 2015/06/05 02:58:22]

I think some naming tweaks are in order here, it's hard to understand at a
glance registrations vs pushed_registrations vs regs.

|registrations| → |registration_data|
|pushed_registrationed| → |registration_ids|
|regs| → |registrations|

Maybe?

[jungkees, 2015/06/05 06:58:07]

The proposed names look clear. Just renamed them as such.

+  size_t index = 0;
+  for (auto it = (*registrations).begin(); it != (*registrations).end();
+       ++it, ++index) {
+    const bool inserted =
+        pushed_registrations.insert((*it).registration_id).second;
+    DCHECK(inserted);
+
+    scoped_refptr<ServiceWorkerRegistration> registration =
+        GetOrCreateRegistration(*it, (*resource_lists)[index]);
+    if (registration.get()) {
+      regs.push_back(registration.get());
+    }
+  }
+
+  // Add unstored registrations that are being installed.
+  for (RegistrationRefsById::const_iterator it =
+           installing_registrations_.begin();
+       it != installing_registrations_.end(); ++it) {
+    if ((!origin_filter.is_valid() ||
+         it->second->pattern().GetOrigin() == origin_filter) &&
+        pushed_registrations.insert(it->first).second) {
+      regs.push_back((it->second).get());
+    }
+  }
+
+  callback.Run(regs);
+}
+
+void ServiceWorkerStorage::DidGetRegistrationsInfos(
     const GetRegistrationsInfosCallback& callback,
     RegistrationList* registrations,
     const GURL& origin_filter,
@@ -1570,8 +1614,10 @@ void ServiceWorkerStorage::DeleteRegistrationFromDB(
 
   // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the
   // unique origin list.
-  std::vector<ServiceWorkerDatabase::RegistrationData> registrations;
-  status = database->GetRegistrationsForOrigin(origin, &registrations);
+  RegistrationList registrations;
+  std::vector<ResourceList> resource_lists;
+  status = database->GetRegistrationsForOrigin(origin, &registrations,
+                                               &resource_lists);

[falken, 2015/06/05 02:58:22]

if resource_lists is not used, does it make sense to pass a nullptr and make
GetRegForOrigin handle that case? Would it avoid an extra read?

[jungkees, 2015/06/05 06:58:06]

Yes, that's a better way. I'd mulled it over when I initially worked on.
Addressed your comment. Thanks.

   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
@@ -1615,8 +1661,9 @@ void ServiceWorkerStorage::FindForDocumentInDB(
     const FindInDBCallback& callback) {
   GURL origin = document_url.GetOrigin();
   RegistrationList registrations;
-  ServiceWorkerDatabase::Status status =
-      database->GetRegistrationsForOrigin(origin, &registrations);
+  std::vector<ResourceList> resource_lists;
+  ServiceWorkerDatabase::Status status = database->GetRegistrationsForOrigin(
+      origin, &registrations, &resource_lists);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
@@ -1653,9 +1700,10 @@ void ServiceWorkerStorage::FindForPatternInDB(
     const GURL& scope,
     const FindInDBCallback& callback) {
   GURL origin = scope.GetOrigin();
-  std::vector<ServiceWorkerDatabase::RegistrationData> registrations;
-  ServiceWorkerDatabase::Status status =
-      database->GetRegistrationsForOrigin(origin, &registrations);
+  RegistrationList registrations;
+  std::vector<ResourceList> resource_lists;
+  ServiceWorkerDatabase::Status status = database->GetRegistrationsForOrigin(
+      origin, &registrations, &resource_lists);

[falken, 2015/06/05 02:58:22]

same with all these

   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,