Store foreign fetch scopes in database with other SW information.

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 45 matching lines @@
                             const RegistrationData& actual) {
   EXPECT_EQ(expected.registration_id, actual.registration_id);
   EXPECT_EQ(expected.scope, actual.scope);
   EXPECT_EQ(expected.script, actual.script);
   EXPECT_EQ(expected.version_id, actual.version_id);
   EXPECT_EQ(expected.is_active, actual.is_active);
   EXPECT_EQ(expected.has_fetch_handler, actual.has_fetch_handler);
   EXPECT_EQ(expected.last_update_check, actual.last_update_check);
   EXPECT_EQ(expected.resources_total_size_bytes,
             actual.resources_total_size_bytes);
+  EXPECT_EQ(expected.foreign_fetch_scopes, actual.foreign_fetch_scopes);
 }
 
 void VerifyResourceRecords(const std::vector<Resource>& expected,
                            const std::vector<Resource>& actual) {
   ASSERT_EQ(expected.size(), actual.size());
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i].resource_id, actual[i].resource_id);
     EXPECT_EQ(expected[i].url, actual[i].url);
     EXPECT_EQ(expected[i].size_bytes, actual[i].size_bytes);
   }
@@ skipping 576 matching lines @@
 TEST(ServiceWorkerDatabaseTest, Registration_Basic) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin("http://example.com");
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
   data.version_id = 200;
   data.resources_total_size_bytes = 10939 + 200;
+  data.foreign_fetch_scopes.push_back(URL(origin, "/foo/bar"));
 
   std::vector<Resource> resources;
   resources.push_back(CreateResource(1, URL(origin, "/resource1"), 10939));
   resources.push_back(CreateResource(2, URL(origin, "/resource2"), 200));
 
   // Write a resource to the uncommitted list to make sure that writing
   // registration removes resource ids associated with the registration from
   // the uncommitted list.
   std::set<int64> uncommitted_ids;
   uncommitted_ids.insert(resources[0].resource_id);
@@ skipping 116 matching lines @@
 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin("http://example.com");
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
   data.version_id = 200;
   data.resources_total_size_bytes = 10 + 11;
+  data.foreign_fetch_scopes.push_back(URL(origin, "/foo"));
 
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 10));
   resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 11));
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   deleted_version.version_id = 222;  // Dummy inital value
   std::vector<int64> newly_purgeable_resources;
 
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data, resources1, &deleted_version, &newly_purgeable_resources));
   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
   EXPECT_TRUE(newly_purgeable_resources.empty());
 
   // Make sure that the registration and resource records are stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data, data_out);
   VerifyResourceRecords(resources1, resources_out);
 
   // Update the registration.
   RegistrationData updated_data = data;
   updated_data.version_id = data.version_id + 1;
   updated_data.resources_total_size_bytes = 12 + 13;
+  updated_data.foreign_fetch_scopes.clear();
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 12));
   resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 13));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(updated_data,
                                         resources2,
                                         &deleted_version,
                                         &newly_purgeable_resources));
   EXPECT_EQ(data.version_id, deleted_version.version_id);
@@ skipping 622 matching lines @@
   GURL origin1("http://example.com");
   GURL origin2("http://example.org");
 
   // |origin1| has two registrations (registration1 and registration2).
   RegistrationData data1;
   data1.registration_id = 10;
   data1.scope = URL(origin1, "/foo");
   data1.script = URL(origin1, "/script1.js");
   data1.version_id = 100;
   data1.resources_total_size_bytes = 2013 + 512;
+  data1.foreign_fetch_scopes.push_back(URL(origin1, "/foo/ff"));
 
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, URL(origin1, "/resource1"), 2013));
   resources1.push_back(CreateResource(2, URL(origin1, "/resource2"), 512));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data1, resources1, &deleted_version, &newly_purgeable_resources));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
@@ skipping 27 matching lines @@
       database->WriteUserData(
           data2.registration_id, origin1, "key4", "data4"));
 
   // |origin2| has one registration (registration3).
   RegistrationData data3;
   data3.registration_id = 12;
   data3.scope = URL(origin2, "/hoge");
   data3.script = URL(origin2, "/script3.js");
   data3.version_id = 102;
   data3.resources_total_size_bytes = 6 + 7;
+  data3.foreign_fetch_scopes.push_back(URL(origin2, "/hoge/ff"));
 
   std::vector<Resource> resources3;
   resources3.push_back(CreateResource(5, URL(origin2, "/resource5"), 6));
   resources3.push_back(CreateResource(6, URL(origin2, "/resource6"), 7));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data3, resources3, &deleted_version, &newly_purgeable_resources));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
@@ skipping 10 matching lines @@
             database->DeleteAllDataForOrigins(origins_to_delete,
                                               &newly_purgeable_resources));
 
   // |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));
 
+  // |origin1| should be removed from the foreign fetch origin list.
+  unique_origins.clear();
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetOriginsWithForeignFetchRegistrations(&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, nullptr));
   EXPECT_TRUE(registrations.empty());
   GURL origin_out;
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
       database->ReadRegistrationOrigin(data1.registration_id, &origin_out));
@@ skipping 52 matching lines @@
   scoped_ptr<ServiceWorkerDatabase> database(
       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()));
 }
 
+TEST(ServiceWorkerDatabaseTest, GetOriginsWithForeignFetchRegistrations) {
+  scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
+
+  std::set<GURL> origins;
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetOriginsWithForeignFetchRegistrations(&origins));
+  EXPECT_TRUE(origins.empty());
+
+  ServiceWorkerDatabase::RegistrationData deleted_version;
+  std::vector<int64> newly_purgeable_resources;
+
+  GURL origin1("http://example.com");
+  RegistrationData data1;
+  data1.registration_id = 123;
+  data1.scope = URL(origin1, "/foo");
+  data1.script = URL(origin1, "/script1.js");
+  data1.version_id = 456;
+  data1.resources_total_size_bytes = 100;
+  data1.foreign_fetch_scopes.push_back(URL(origin1, "/foo/bar"));
+  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));
+
+  GURL origin2("https://www.example.com");
+  RegistrationData data2;
+  data2.registration_id = 234;
+  data2.scope = URL(origin2, "/bar");
+  data2.script = URL(origin2, "/script2.js");
+  data2.version_id = 567;
+  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));
+
+  GURL origin3("https://example.org");
+  RegistrationData data3;
+  data3.registration_id = 345;
+  data3.scope = URL(origin3, "/hoge");
+  data3.script = URL(origin3, "/script3.js");
+  data3.version_id = 678;
+  data3.resources_total_size_bytes = 300;
+  data3.foreign_fetch_scopes.push_back(URL(origin1, "/hoge/foo"));
+  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 three registrations.
+  RegistrationData data4;
+  data4.registration_id = 456;
+  data4.scope = URL(origin3, "/fuga");
+  data4.script = URL(origin3, "/script4.js");
+  data4.version_id = 789;
+  data4.resources_total_size_bytes = 400;
+  data4.foreign_fetch_scopes.push_back(URL(origin1, "/fuga/bar"));
+  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));
+
+  RegistrationData data5;
+  data5.registration_id = 567;
+  data5.scope = URL(origin3, "/bla");
+  data5.script = URL(origin3, "/script5.js");
+  data5.version_id = 890;
+  data5.resources_total_size_bytes = 500;
+  std::vector<Resource> resources5;
+  resources5.push_back(CreateResource(5, data5.script, 500));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data5, resources5, &deleted_version,
+                                        &newly_purgeable_resources));
+
+  origins.clear();
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetOriginsWithForeignFetchRegistrations(&origins));
+  EXPECT_EQ(2U, origins.size());
+  EXPECT_TRUE(ContainsKey(origins, origin1));
+  EXPECT_TRUE(ContainsKey(origins, origin3));
+
+  // |origin3| has another registration, so should not remove it from the
+  // foreign fetch origin list.
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data4.registration_id, origin3,
+                                         &deleted_version,
+                                         &newly_purgeable_resources));
+  EXPECT_EQ(data4.registration_id, deleted_version.registration_id);
+
+  origins.clear();
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetOriginsWithForeignFetchRegistrations(&origins));
+  EXPECT_EQ(2U, origins.size());
+  EXPECT_TRUE(ContainsKey(origins, origin1));
+  EXPECT_TRUE(ContainsKey(origins, origin3));
+
+  // |origin3| should be removed from the foreign fetch origin list, since its
+  // only remaining registration doesn't have foreign fetch scopes.
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data3.registration_id, origin3,
+                                         &deleted_version,
+                                         &newly_purgeable_resources));
+  EXPECT_EQ(data3.registration_id, deleted_version.registration_id);
+
+  origins.clear();
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetOriginsWithForeignFetchRegistrations(&origins));
+  EXPECT_EQ(1U, origins.size());
+  EXPECT_TRUE(ContainsKey(origins, origin1));
+
+  // |origin1| should be removed from the foreign fetch origin list, since we
+  // replace its registration with one without scopes.
+  RegistrationData updated_data1 = data1;
+  updated_data1.version_id++;
+  updated_data1.resources_total_size_bytes = 12 + 13;
+  updated_data1.foreign_fetch_scopes.clear();
+  std::vector<Resource> updated_resources1;
+  updated_resources1.push_back(
+      CreateResource(13, URL(origin1, "/resource3"), 12));
+  updated_resources1.push_back(
+      CreateResource(14, URL(origin1, "/resource4"), 13));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(updated_data1, updated_resources1,
+                                        &deleted_version,
+                                        &newly_purgeable_resources));
+
+  origins.clear();
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetOriginsWithForeignFetchRegistrations(&origins));
+  EXPECT_EQ(0U, origins.size());
+}
+
 }  // namespace content