Service Worker: Add ServiceWorkerContainer.getRegistrations() method.

content/browser/service_worker/service_worker_database_unittest.cc

 // Copyright 2014 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_database.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 388 matching lines @@
 }
 
 TEST(ServiceWorkerDatabaseTest, GetRegistrationsForOrigin) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin1("http://example.com");
   GURL origin2("https://www.example.com");
   GURL origin3("https://example.org");
 
   std::vector<RegistrationData> registrations;
+  std::vector<std::vector<Resource>> resources_list;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->GetRegistrationsForOrigin(origin1, &registrations));
+            database->GetRegistrationsForOrigin(origin1, &registrations,
+                                                &resources_list));
   EXPECT_TRUE(registrations.empty());
+  EXPECT_TRUE(resources_list.empty());
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
 
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(origin1, "/foo");
   data1.script = URL(origin1, "/script1.js");
   data1.version_id = 1000;
   data1.resources_total_size_bytes = 100;
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, data1.script, 100));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data1, resources1, &deleted_version,
                                         &newly_purgeable_resources));
 
+  registrations.clear();
+  resources_list.clear();
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetRegistrationsForOrigin(origin1, &registrations,
+                                                &resources_list));
+  EXPECT_EQ(1U, registrations.size());
+  VerifyRegistrationData(data1, registrations[0]);
+  EXPECT_EQ(1U, resources_list.size());
+  VerifyResourceRecords(resources1, resources_list[0]);
+
   RegistrationData data2;
   data2.registration_id = 200;
   data2.scope = URL(origin2, "/bar");
   data2.script = URL(origin2, "/script2.js");
   data2.version_id = 2000;
   data2.resources_total_size_bytes = 200;
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(2, data2.script, 200));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data2, resources2, &deleted_version,
                                         &newly_purgeable_resources));
 
+  registrations.clear();
+  resources_list.clear();
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetRegistrationsForOrigin(origin2, &registrations,
+                                                &resources_list));
+  EXPECT_EQ(1U, registrations.size());
+  VerifyRegistrationData(data2, registrations[0]);
+  EXPECT_EQ(1U, resources_list.size());
+  VerifyResourceRecords(resources2, resources_list[0]);
+
   RegistrationData data3;
   data3.registration_id = 300;
   data3.scope = URL(origin3, "/hoge");
   data3.script = URL(origin3, "/script3.js");
   data3.version_id = 3000;
   data3.resources_total_size_bytes = 300;
   std::vector<Resource> resources3;
   resources3.push_back(CreateResource(3, data3.script, 300));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data3, resources3, &deleted_version,
                                         &newly_purgeable_resources));
 
   // |origin3| has two registrations.
   RegistrationData data4;
   data4.registration_id = 400;
   data4.scope = URL(origin3, "/fuga");
   data4.script = URL(origin3, "/script4.js");
   data4.version_id = 4000;
   data4.resources_total_size_bytes = 400;
   std::vector<Resource> resources4;
   resources4.push_back(CreateResource(4, data4.script, 400));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data4, resources4, &deleted_version,
                                         &newly_purgeable_resources));
 
   registrations.clear();
+  resources_list.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->GetRegistrationsForOrigin(origin3, &registrations));
+            database->GetRegistrationsForOrigin(origin3, &registrations,
+                                                &resources_list));
   EXPECT_EQ(2U, registrations.size());
   VerifyRegistrationData(data3, registrations[0]);
   VerifyRegistrationData(data4, registrations[1]);
+  EXPECT_EQ(2U, resources_list.size());
+  VerifyResourceRecords(resources3, resources_list[0]);
+  VerifyResourceRecords(resources4, resources_list[1]);
+
+  // The third parameter |opt_resources_list| to GetRegistrationsForOrigin()
+  // is optional. So, nullptr should be acceptable.
+  registrations.clear();
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->GetRegistrationsForOrigin(origin1, &registrations, nullptr));
+  EXPECT_EQ(1U, registrations.size());
+  VerifyRegistrationData(data1, registrations[0]);
 }
 
 TEST(ServiceWorkerDatabaseTest, GetAllRegistrations) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   std::vector<RegistrationData> registrations;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetAllRegistrations(&registrations));
   EXPECT_TRUE(registrations.empty());
 
@@ skipping 983 matching lines @@
 
   // |origin1| should be removed from the unique origin list.
   std::set<GURL> unique_origins;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithRegistrations(&unique_origins));
   EXPECT_EQ(1u, unique_origins.size());
   EXPECT_TRUE(ContainsKey(unique_origins, origin2));
 
   // The registrations for |origin1| should be removed.
   std::vector<RegistrationData> registrations;
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
-            database->GetRegistrationsForOrigin(origin1, &registrations));
+  EXPECT_EQ(
+      ServiceWorkerDatabase::STATUS_OK,
+      database->GetRegistrationsForOrigin(origin1, &registrations, nullptr));
   EXPECT_TRUE(registrations.empty());
   GURL origin_out;
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
       database->ReadRegistrationOrigin(data1.registration_id, &origin_out));
 
   // The registration for |origin2| should not be removed.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
@@ skipping 48 matching lines @@
       CreateDatabase(database_dir.path()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
   ASSERT_TRUE(base::DirectoryExists(database_dir.path()));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase());
   ASSERT_FALSE(base::DirectoryExists(database_dir.path()));
 }
 
 }  // namespace content