Service Worker: Add ServiceWorkerContainer.getRegistrations() method.

content/browser/service_worker/service_worker_storage_unittest.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 <string>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 48 matching lines @@
   *found = registration;
 }
 
 ServiceWorkerStorage::FindRegistrationCallback MakeFindCallback(
     bool* was_called,
     ServiceWorkerStatusCode* result,
     scoped_refptr<ServiceWorkerRegistration>* found) {
   return base::Bind(&FindCallback, was_called, result, found);
 }
 
-void GetAllCallback(
+void GetAllCallback(bool* was_called,
+                    std::vector<ServiceWorkerRegistration*>* all_out,
+                    const std::vector<ServiceWorkerRegistration*>& all) {
+  *was_called = true;
+  *all_out = all;
+}
+
+void GetAllInfosCallback(
     bool* was_called,
     std::vector<ServiceWorkerRegistrationInfo>* all_out,
     const std::vector<ServiceWorkerRegistrationInfo>& all) {
   *was_called = true;
   *all_out = all;
 }
 
+ServiceWorkerStorage::GetRegistrationsCallback MakeGetRegistrationsCallback(
+    bool* was_called,
+    std::vector<ServiceWorkerRegistration*>* all,
+    std::vector<std::vector<ResourceRecord>>* resource_lists) {
+  return base::Bind(&GetAllCallback, was_called, all);
+}
+
 ServiceWorkerStorage::GetRegistrationsInfosCallback
-MakeGetRegistrationsCallback(bool* was_called,
-                             std::vector<ServiceWorkerRegistrationInfo>* all) {
-  return base::Bind(&GetAllCallback, was_called, all);
+MakeGetRegistrationsInfosCallback(
+    bool* was_called,
+    std::vector<ServiceWorkerRegistrationInfo>* all) {
+  return base::Bind(&GetAllInfosCallback, was_called, all);
 }
 
 void GetUserDataCallback(
     bool* was_called,
     std::string* data_out,
     ServiceWorkerStatusCode* status_out,
     const std::string& data,
     ServiceWorkerStatusCode status) {
   *was_called = true;
   *data_out = data;
@@ skipping 231 matching lines @@
     bool was_called = false;
     ServiceWorkerStatusCode result = SERVICE_WORKER_ERROR_FAILED;
     storage()->DeleteRegistration(
         registration_id, origin, MakeStatusCallback(&was_called, &result));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return result;
   }
 
-  void GetAllRegistrations(
+  void GetAllRegistrationsInfos(
       std::vector<ServiceWorkerRegistrationInfo>* registrations) {
     bool was_called = false;
-    storage()->GetAllRegistrations(
-        MakeGetRegistrationsCallback(&was_called, registrations));
+    storage()->GetAllRegistrationsInfos(
+        MakeGetRegistrationsInfosCallback(&was_called, registrations));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
   }
 
   void GetRegistrationsForOrigin(
       const GURL& origin,
-      std::vector<ServiceWorkerRegistrationInfo>* registrations) {
+      std::vector<ServiceWorkerRegistration*>* registrations,
+      std::vector<std::vector<ResourceRecord>>* resource_lists) {
     bool was_called = false;
     storage()->GetRegistrationsForOrigin(
-        origin,
-        MakeGetRegistrationsCallback(&was_called, registrations));
+        origin, MakeGetRegistrationsCallback(&was_called, registrations,
+                                             resource_lists));
     EXPECT_FALSE(was_called);  // always async
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
   }
 
   ServiceWorkerStatusCode GetUserData(
       int64 registration_id,
       const std::string& key,
       std::string* data) {
     bool was_called = false;
@@ skipping 213 matching lines @@
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   ASSERT_TRUE(found_registration.get());
   EXPECT_EQ(kRegistrationId, found_registration->id());
   EXPECT_TRUE(found_registration->HasOneRef());
 
   // Check that sizes are populated correctly
   EXPECT_EQ(live_version.get(), found_registration->waiting_version());
   EXPECT_EQ(kResource1Size + kResource2Size,
             found_registration->resources_total_size_bytes());
   std::vector<ServiceWorkerRegistrationInfo> all_registrations;
-  GetAllRegistrations(&all_registrations);
+  GetAllRegistrationsInfos(&all_registrations);
   EXPECT_EQ(1u, all_registrations.size());
   ServiceWorkerRegistrationInfo info = all_registrations[0];
   EXPECT_EQ(kResource1Size + kResource2Size, info.stored_version_size_bytes);
   all_registrations.clear();
 
   // Finding by origin should provide the same result iif origin is kScope.
-  std::vector<ServiceWorkerRegistrationInfo> registrations_origin;
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin);
+  std::vector<ServiceWorkerRegistration*> registrations_origin;
+  std::vector<std::vector<ResourceRecord>> resource_lists;
+  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin,
+                            &resource_lists);
   EXPECT_EQ(1u, registrations_origin.size());
   registrations_origin.clear();
 
-  GetRegistrationsForOrigin(
-      GURL("http://example.com/").GetOrigin(),
-      &registrations_origin);
+  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                            &registrations_origin, &resource_lists);
   EXPECT_TRUE(registrations_origin.empty());
 
   found_registration = NULL;
 
   // Drop the live version too.
   live_version = NULL;
 
   // And FindRegistrationForPattern is always async.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForPattern(kScope, &found_registration));
@@ skipping 71 matching lines @@
   // Create an unstored registration.
   scoped_refptr<ServiceWorkerRegistration> live_registration =
       new ServiceWorkerRegistration(
           kScope, kRegistrationId, context_ptr_);
   scoped_refptr<ServiceWorkerVersion> live_version =
       new ServiceWorkerVersion(
           live_registration.get(), kScript, kVersionId, context_ptr_);
   live_version->SetStatus(ServiceWorkerVersion::INSTALLING);
   live_registration->SetWaitingVersion(live_version);
 
-  // Should not be findable, including by GetAllRegistrations.
+  // Should not be findable, including by GetAllRegistrationsInfos.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForIdOnly(kRegistrationId, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   std::vector<ServiceWorkerRegistrationInfo> all_registrations;
-  GetAllRegistrations(&all_registrations);
+  GetAllRegistrationsInfos(&all_registrations);
   EXPECT_TRUE(all_registrations.empty());
 
-  std::vector<ServiceWorkerRegistrationInfo> registrations_origin;
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin);
+  std::vector<ServiceWorkerRegistration*> registrations_origin;
+  std::vector<std::vector<ResourceRecord>> resource_lists;
+  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin,
+                            &resource_lists);
   EXPECT_TRUE(registrations_origin.empty());
 
-  GetRegistrationsForOrigin(
-      GURL("http://example.com/").GetOrigin(),
-      &registrations_origin);
+  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                            &registrations_origin, &resource_lists);
   EXPECT_TRUE(registrations_origin.empty());
 
   // Notify storage of it being installed.
   storage()->NotifyInstallingRegistration(live_registration.get());
 
   // Now should be findable.
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForIdOnly(kRegistrationId, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
   EXPECT_EQ(SERVICE_WORKER_OK,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_EQ(live_registration, found_registration);
   found_registration = NULL;
 
-  GetAllRegistrations(&all_registrations);
+  GetAllRegistrationsInfos(&all_registrations);
   EXPECT_EQ(1u, all_registrations.size());
   all_registrations.clear();
 
   // Finding by origin should provide the same result iif origin is kScope.
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin);
+  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin,
+                            &resource_lists);
   EXPECT_EQ(1u, registrations_origin.size());
   registrations_origin.clear();
 
-  GetRegistrationsForOrigin(
-      GURL("http://example.com/").GetOrigin(),
-      &registrations_origin);
+  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                            &registrations_origin, &resource_lists);
   EXPECT_TRUE(registrations_origin.empty());
 
   // Notify storage of installation no longer happening.
   storage()->NotifyDoneInstallingRegistration(
       live_registration.get(), NULL, SERVICE_WORKER_OK);
 
   // Once again, should not be findable.
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForId(
                 kRegistrationId, kScope.GetOrigin(), &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForIdOnly(kRegistrationId, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForDocument(kDocumentUrl, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND,
             FindRegistrationForPattern(kScope, &found_registration));
   EXPECT_FALSE(found_registration.get());
 
-  GetAllRegistrations(&all_registrations);
+  GetAllRegistrationsInfos(&all_registrations);
   EXPECT_TRUE(all_registrations.empty());
 
-  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin);
+  GetRegistrationsForOrigin(kScope.GetOrigin(), &registrations_origin,
+                            &resource_lists);
   EXPECT_TRUE(registrations_origin.empty());
 
-  GetRegistrationsForOrigin(
-      GURL("http://example.com/").GetOrigin(),
-      &registrations_origin);
+  GetRegistrationsForOrigin(GURL("http://example.com/").GetOrigin(),
+                            &registrations_origin, &resource_lists);
   EXPECT_TRUE(registrations_origin.empty());
 }
 
 TEST_F(ServiceWorkerStorageTest, StoreUserData) {
   const GURL kScope("http://www.test.not/scope/");
   const GURL kScript("http://www.test.not/script.js");
   const int64 kRegistrationId = 0;
   const int64 kVersionId = 0;
 
   LazyInitialize();
@@ skipping 630 matching lines @@
   are_equal = true;
   storage()->CompareScriptResources(
       5, 6,
       base::Bind(&OnCompareComplete, &status, &are_equal));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(SERVICE_WORKER_OK, status);
   EXPECT_FALSE(are_equal);
 }
 
 }  // namespace content