ServiceWorker: Ensure that a resource list contains the main script

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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 601 matching lines @@
   VerifyRegistrationData(data4, registrations[3]);
 }
 
 TEST(ServiceWorkerDatabaseTest, Registration_Basic) {
   std::unique_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.script = URL(origin, "/resource1");
   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
@@ skipping 66 matching lines @@
   EXPECT_TRUE(base::ContainsKey(purgeable_ids_out, resources[1].resource_id));
 }
 
 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) {
   std::unique_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.script = URL(origin, "/resource1");
   data.version_id = 200;
   data.resources_total_size_bytes = 19 + 29129;
 
   std::vector<Resource> resources;
   resources.push_back(CreateResource(1, URL(origin, "/resource1"), 19));
   resources.push_back(CreateResource(2, URL(origin, "/resource2"), 29129));
 
   const int64_t kNonExistentRegistrationId = 999;
   const int64_t kArbitraryVersionId = 222;  // Used as a dummy initial value
 
@@ skipping 29 matching lines @@
   EXPECT_TRUE(newly_purgeable_resources.empty());
 }
 
 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) {
   std::unique_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.script = URL(origin, "/resource1");
   data.version_id = 200;
   data.resources_total_size_bytes = 10 + 11;
   data.foreign_fetch_scopes.push_back(URL(origin, "/foo"));
   data.foreign_fetch_origins.push_back(
       url::Origin(GURL("https://chromium.org")));
 
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 10));
   resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 11));
 
@@ skipping 11 matching lines @@
   // 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.script = URL(origin, "/resource3");
   updated_data.version_id = data.version_id + 1;
   updated_data.resources_total_size_bytes = 12 + 13;
   updated_data.foreign_fetch_scopes.clear();
   updated_data.foreign_fetch_origins.push_back(
       url::Origin(GURL("https://example.com")));
   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,
@@ skipping 26 matching lines @@
   std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   GURL origin("http://example.com");
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64_t> newly_purgeable_resources;
 
   // Add registration1.
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(origin, "/foo");
-  data1.script = URL(origin, "/script1.js");
+  data1.script = URL(origin, "/resource1");
   data1.version_id = 200;
   data1.resources_total_size_bytes = 1451 + 15234;
 
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 1451));
   resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 15234));
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data1, resources1, &deleted_version, &newly_purgeable_resources));
 
   // Add registration2.
   RegistrationData data2;
   data2.registration_id = 101;
   data2.scope = URL(origin, "/bar");
-  data2.script = URL(origin, "/script2.js");
+  data2.script = URL(origin, "/resource3");
   data2.version_id = 201;
   data2.resources_total_size_bytes = 5 + 6;
 
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 5));
   resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 6));
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data2, resources2, &deleted_version, &newly_purgeable_resources));
@@ skipping 616 matching lines @@
   std::vector<int64_t> newly_purgeable_resources;
 
   // Data associated with |origin1| will be removed.
   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.script = URL(origin1, "/resource1");
   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,
             database->WriteUserData(data1.registration_id, origin1,
                                     {{"key1", "data1"}}));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteUserData(data1.registration_id, origin1,
                                     {{"key2", "data2"}}));
 
   RegistrationData data2;
   data2.registration_id = 11;
   data2.scope = URL(origin1, "/bar");
-  data2.script = URL(origin1, "/script2.js");
+  data2.script = URL(origin1, "/resource3");
   data2.version_id = 101;
   data2.resources_total_size_bytes = 4 + 5;
 
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(3, URL(origin1, "/resource3"), 4));
   resources2.push_back(CreateResource(4, URL(origin1, "/resource4"), 5));
   ASSERT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteRegistration(
           data2, resources2, &deleted_version, &newly_purgeable_resources));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteUserData(data2.registration_id, origin1,
                                     {{"key3", "data3"}}));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             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.script = URL(origin2, "/resource5");
   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(
@@ skipping 228 matching lines @@
             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());
 }
 
+TEST(ServiceWorkerDatabaseTest, Corruption_NoMainResource) {
+  std::unique_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
+  ServiceWorkerDatabase::RegistrationData deleted_version;
+  std::vector<int64_t> newly_purgeable_resources;
+
+  GURL origin("http://example.com");
+
+  RegistrationData data;
+  data.registration_id = 10;
+  data.scope = URL(origin, "/foo");
+  data.script = URL(origin, "/resource1");
+  data.version_id = 100;
+  data.resources_total_size_bytes = 2016;
+
+  // Simulate that "/resource1" wasn't correctly written in the database by not
+  // adding it.
+  std::vector<Resource> resources;
+  resources.push_back(CreateResource(2, URL(origin, "/resource2"), 2016));
+
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, resources, &deleted_version,
+                                        &newly_purgeable_resources));
+
+  // The database should detect lack of the main resource (i.e. "/resource1").
+  RegistrationData data_out;
+  std::vector<Resource> resources_out;
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED,
+            database->ReadRegistration(data.registration_id, origin, &data_out,
+                                       &resources_out));
+  EXPECT_TRUE(resources_out.empty());
+}
+
 }  // namespace content