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;
+  std::vector<ResourceList>* resource_lists = new std::vector<ResourceList>;
   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* registration_data,
+    std::vector<ResourceList>* resource_lists,
+    const GURL& origin_filter,
+    ServiceWorkerDatabase::Status status) {
+  DCHECK(registration_data);
+  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> registration_ids;
+  std::vector<ServiceWorkerRegistration*> registrations;

[michaeln, 2015/06/05 21:50:41]

This needs to be a vector of scoped_refptrs, otherwise if a callee makes a copy
of the vector for later use, that would be bad. Also, if the registration is
created in this loop, it will already have been deleted by the time the callee
gets the vector.

[jungkees, 2015/06/06 13:55:12]

I had to be more careful about this indeed. Addressed the comment. Thanks.

+  size_t index = 0;
+  for (auto it = (*registration_data).begin(); it != (*registration_data).end();

[michaeln, 2015/06/05 21:50:42]

This loop probably could be easier to read and match more closely the loop in
the very similar method below.

int index = 0
for (const auto& registration_data : *registrations) {
   registration_ids.insert(registration_data.registration_id);
   registrations.push_back(
       GetOrCreateRegistration(registration_data,
                               resource_lists->at(index++));
}

[jungkees, 2015/06/06 13:55:12]

Neat! Addressed. Thanks.

+       ++it, ++index) {
+    const bool inserted = registration_ids.insert((*it).registration_id).second;
+    DCHECK(inserted);
+
+    scoped_refptr<ServiceWorkerRegistration> registration =
+        GetOrCreateRegistration(*it, (*resource_lists)[index]);
+    if (registration.get()) {

[michaeln, 2015/06/05 21:50:42]

no need for the null check, it's either gotten or created

[jungkees, 2015/06/06 13:55:12]

Right. This condition has been removed by replacing the loop code with the one
your commented.

+      registrations.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) &&
+        registration_ids.insert(it->first).second) {
+      registrations.push_back((it->second).get());
+    }
+  }
+
+  callback.Run(registrations);
+}
+
+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;
+  status = database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
   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 24 matching lines @@
 }
 
 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);
+      database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
   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;
+  RegistrationList registrations;
   ServiceWorkerDatabase::Status status =
-      database->GetRegistrationsForOrigin(origin, &registrations);
+      database->GetRegistrationsForOrigin(origin, &registrations, nullptr);
   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