Service Worker: Add ServiceWorkerContainer.getRegistrations() method.

content/browser/service_worker/service_worker_storage.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_storage.h"
 
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 442 matching lines @@
       base::Bind(&FindForIdOnlyInDB,
                  database_.get(),
                  base::ThreadTaskRunnerHandle::Get(),
                  registration_id,
                  base::Bind(&ServiceWorkerStorage::DidFindRegistrationForId,
                             weak_factory_.GetWeakPtr(),
                             callback)));
 }
 
 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>()));
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   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(
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version,
     const StatusCallback& callback) {
   DCHECK(registration);
   DCHECK(version);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
@@ skipping 568 matching lines @@
 void ServiceWorkerStorage::ReturnFoundRegistration(
     const FindRegistrationCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources) {
   scoped_refptr<ServiceWorkerRegistration> registration =
       GetOrCreateRegistration(data, resources);
   CompleteFindNow(registration, SERVICE_WORKER_OK, callback);
 }
 
 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,
     ServiceWorkerDatabase::Status status) {
   DCHECK(registrations);
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
     callback.Run(std::vector<ServiceWorkerRegistrationInfo>());
     return;
@@ skipping 450 matching lines @@
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE,
         base::Bind(
             callback, false, deleted_version, std::vector<int64>(), status));
     return;
   }
 
   // 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,
         base::Bind(
             callback, false, deleted_version, std::vector<int64>(), status));
     return;
   }
 
   bool deletable = registrations.empty();
   original_task_runner->PostTask(FROM_HERE,
@@ skipping 23 matching lines @@
                                             status));
 }
 
 void ServiceWorkerStorage::FindForDocumentInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const GURL& document_url,
     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,
         base::Bind(callback,
                    ServiceWorkerDatabase::RegistrationData(),
                    ResourceList(),
                    status));
     return;
   }
 
@@ skipping 16 matching lines @@
       FROM_HERE,
       base::Bind(callback, data, resources, status));
 }
 
 void ServiceWorkerStorage::FindForPatternInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     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,
         base::Bind(callback,
                    ServiceWorkerDatabase::RegistrationData(),
                    ResourceList(),
                    status));
     return;
   }
 
@@ skipping 138 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
       ServiceWorkerMetrics::DELETE_OK);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content