Service Worker: Migrate to version_uuid and surface ServiceWorker.id. (Chromium 2/3)

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 39 matching lines @@
 
 ServiceWorkerDatabase* CreateDatabaseInMemory() {
   return new ServiceWorkerDatabase(base::FilePath());
 }
 
 void VerifyRegistrationData(const RegistrationData& expected,
                             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.version_uuid, actual.version_uuid);
   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);
 }
 
 void VerifyResourceRecords(const std::vector<Resource>& expected,
                            const std::vector<Resource>& actual) {
   ASSERT_EQ(expected.size(), actual.size());
@@ skipping 85 matching lines @@
 
   // Simulate an existing database created before diskcache migration.
   database->set_skip_writing_diskcache_migration_state_on_init_for_testing();
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   ServiceWorkerDatabase::RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
-  data.version_id = 200;
+  data.version_uuid = "1b304e16-1464-4a75-855a-4e4e62baac81";
   data.resources_total_size_bytes = 300;
   resources.push_back(CreateResource(1, data.script, 300));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data, resources, &deleted_version,
                                         &newly_purgeable_resources));
   migration_needed = false;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->IsDiskCacheMigrationNeeded(&migration_needed));
   ASSERT_TRUE(migration_needed);
   deletion_needed = false;
@@ skipping 38 matching lines @@
   GURL origin("http://example.com");
 
   // Add a registration to the database.
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   ServiceWorkerDatabase::RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script1.js");
-  data.version_id = 200;
+  data.version_uuid = "1b304e16-1464-4a75-855a-4e4e62baac81";
   data.resources_total_size_bytes = 300;
   resources.push_back(CreateResource(1, data.script, 300));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data, resources, &deleted_version,
                                         &newly_purgeable_resources));
 
   // Sanity check on current version.
   int64 db_version = -1;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadDatabaseVersion(&db_version));
@@ skipping 31 matching lines @@
 TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   scoped_ptr<ServiceWorkerDatabase> database(
       CreateDatabase(database_dir.path()));
 
   GURL origin("http://example.com");
 
   // The database has never been used, so returns initial values.
   AvailableIds ids;
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
-      &ids.reg_id, &ids.ver_id, &ids.res_id));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetNextAvailableIds(&ids.reg_id, &ids.res_id));
   EXPECT_EQ(0, ids.reg_id);
-  EXPECT_EQ(0, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
 
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
-      &ids.reg_id, &ids.ver_id, &ids.res_id));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetNextAvailableIds(&ids.reg_id, &ids.res_id));
   EXPECT_EQ(0, ids.reg_id);
-  EXPECT_EQ(0, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
 
   // Writing a registration bumps the next available ids.
   std::vector<Resource> resources1;
   RegistrationData data1;
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   data1.registration_id = 100;
   data1.scope = URL(origin, "/foo");
   data1.script = URL(origin, "/script1.js");
-  data1.version_id = 200;
+  data1.version_uuid = "1b304e16-1464-4a75-855a-4e4e62baac81";
   data1.resources_total_size_bytes = 300;
   resources1.push_back(CreateResource(1, data1.script, 300));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data1, resources1, &deleted_version,
                                         &newly_purgeable_resources));
 
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
-      &ids.reg_id, &ids.ver_id, &ids.res_id));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetNextAvailableIds(&ids.reg_id, &ids.res_id));
   EXPECT_EQ(101, ids.reg_id);
-  EXPECT_EQ(201, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
 
   // Writing uncommitted resources bumps the next available id.
   const int64 kUncommittedIds[] = {0, 1, 3, 5, 6, 10};
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->WriteUncommittedResourceIds(std::set<int64>(
           kUncommittedIds, kUncommittedIds + arraysize(kUncommittedIds))));
-  EXPECT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->GetNextAvailableIds(&ids.reg_id, &ids.ver_id, &ids.res_id));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetNextAvailableIds(&ids.reg_id, &ids.res_id));
   EXPECT_EQ(101, ids.reg_id);
-  EXPECT_EQ(201, ids.ver_id);
   EXPECT_EQ(11, ids.res_id);
 
   // Writing purgeable resources bumps the next available id.
   const int64 kPurgeableIds[] = {4, 12, 16, 17, 20};
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteUncommittedResourceIds(std::set<int64>(
                 kPurgeableIds, kPurgeableIds + arraysize(kPurgeableIds))));
-  EXPECT_EQ(
-      ServiceWorkerDatabase::STATUS_OK,
-      database->GetNextAvailableIds(&ids.reg_id, &ids.ver_id, &ids.res_id));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetNextAvailableIds(&ids.reg_id, &ids.res_id));
   EXPECT_EQ(101, ids.reg_id);
-  EXPECT_EQ(201, ids.ver_id);
   EXPECT_EQ(21, ids.res_id);
 
   // Writing a registration whose ids are lower than the stored ones should not
   // bump the next available ids.
   RegistrationData data2;
   data2.registration_id = 10;
   data2.scope = URL(origin, "/bar");
   data2.script = URL(origin, "/script2.js");
-  data2.version_id = 20;
+  data2.version_uuid = "a616c852-7fc0-46c4-9f6e-0f6f2cb4aa4c";
   data2.resources_total_size_bytes = 400;
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(2, data2.script, 400));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data2, resources2, &deleted_version,
                                         &newly_purgeable_resources));
 
   // Same with resources.
   int64 kLowResourceId = 15;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteUncommittedResourceIds(
                 std::set<int64>(&kLowResourceId, &kLowResourceId + 1)));
 
   // Close and reopen the database to verify the stored values.
   database.reset(CreateDatabase(database_dir.path()));
 
-  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
-      &ids.reg_id, &ids.ver_id, &ids.res_id));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetNextAvailableIds(&ids.reg_id, &ids.res_id));
   EXPECT_EQ(101, ids.reg_id);
-  EXPECT_EQ(201, ids.ver_id);
   EXPECT_EQ(21, ids.res_id);
 }
 
 TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   std::set<GURL> origins;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithRegistrations(&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.version_uuid = "0ab2638a-2005-411e-aa89-76e14892b618";
   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));
 
   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.version_uuid = "0acb271b-b4eb-4323-b049-6db3d1571c43";
   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.version_uuid = "de8cc4f5-3f3b-4f60-b4f5-d4ddc1cb5e69";
   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 = 456;
   data4.scope = URL(origin3, "/fuga");
   data4.script = URL(origin3, "/script4.js");
-  data4.version_id = 789;
+  data4.version_uuid = "fe7fcca9-904b-4e45-85e2-2414c4424f18";
   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));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetOriginsWithRegistrations(&origins));
@@ skipping 50 matching lines @@
   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.version_uuid = "5e837d34-3ad6-4043-bcea-41bc02ec203e";
   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.version_uuid = "9bb6c620-8ea3-4b17-9654-e0346a8fc2ce";
   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.version_uuid = "afa0e540-8432-491e-af58-9461850477dd";
   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.version_uuid = "142b546d-5b7c-4932-89b9-efca171bd28f";
   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,
@@ skipping 25 matching lines @@
   EXPECT_TRUE(registrations.empty());
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
 
   GURL origin1("http://www1.example.com");
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(origin1, "/foo");
   data1.script = URL(origin1, "/script1.js");
-  data1.version_id = 1000;
+  data1.version_uuid = "5e837d34-3ad6-4043-bcea-41bc02ec203e";
   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));
 
   GURL origin2("http://www2.example.com");
   RegistrationData data2;
   data2.registration_id = 200;
   data2.scope = URL(origin2, "/bar");
   data2.script = URL(origin2, "/script2.js");
-  data2.version_id = 2000;
+  data2.version_uuid = "9bb6c620-8ea3-4b17-9654-e0346a8fc2ce";
   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("http://www3.example.com");
   RegistrationData data3;
   data3.registration_id = 300;
   data3.scope = URL(origin3, "/hoge");
   data3.script = URL(origin3, "/script3.js");
-  data3.version_id = 3000;
+  data3.version_uuid = "afa0e540-8432-491e-af58-9461850477dd";
   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.version_uuid = "142b546d-5b7c-4932-89b9-efca171bd28f";
   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();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetAllRegistrations(&registrations));
   EXPECT_EQ(4U, registrations.size());
   VerifyRegistrationData(data1, registrations[0]);
   VerifyRegistrationData(data2, registrations[1]);
   VerifyRegistrationData(data3, registrations[2]);
   VerifyRegistrationData(data4, registrations[3]);
 }
 
 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.version_uuid = "663f73e1-37d6-4ec9-a809-01afdcb1634d";
   data.resources_total_size_bytes = 10939 + 200;
 
   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);
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteUncommittedResourceIds(uncommitted_ids));
   std::set<int64> uncommitted_ids_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetUncommittedResourceIds(&uncommitted_ids_out));
   EXPECT_EQ(uncommitted_ids, uncommitted_ids_out);
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
-  deleted_version.version_id = 222;  // Dummy initial value
+  deleted_version.version_uuid =
+      "0185fb13-bb72-42ad-8cdc-cbaabf794dc6";  // Dummy initial value
   std::vector<int64> newly_purgeable_resources;
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(
                 data, resources, &deleted_version, &newly_purgeable_resources));
-  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(deleted_version.version_uuid.empty());
   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(resources, resources_out);
   GURL origin_out;
   EXPECT_EQ(
       ServiceWorkerDatabase::STATUS_OK,
       database->ReadRegistrationOrigin(data.registration_id, &origin_out));
   EXPECT_EQ(origin, origin_out);
 
   // Make sure that the resource is removed from the uncommitted list.
   uncommitted_ids_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->GetUncommittedResourceIds(&uncommitted_ids_out));
   EXPECT_TRUE(uncommitted_ids_out.empty());
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(data.registration_id,
                                          origin,
                                          &deleted_version,
                                          &newly_purgeable_resources));
-  EXPECT_EQ(data.version_id, deleted_version.version_id);
+  EXPECT_EQ(data.version_uuid, deleted_version.version_uuid);
   ASSERT_EQ(resources.size(), newly_purgeable_resources.size());
   for (size_t i = 0; i < resources.size(); ++i)
     EXPECT_EQ(newly_purgeable_resources[i], resources[i].resource_id);
 
   // Make sure that the registration and resource records are gone.
   resources_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->ReadRegistration(
                 data.registration_id, origin, &data_out, &resources_out));
   EXPECT_TRUE(resources_out.empty());
@@ skipping 11 matching lines @@
 }
 
 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) {
   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.version_uuid = "c4684df5-39e2-4dde-ba61-793c17e61491";
   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 kNonExistentRegistrationId = 999;
-  const int64 kArbitraryVersionId = 222;  // Used as a dummy initial value
+  const std::string kArbitraryVersionId =
+      "19682155-36a8-4a21-b8d0-9de545e645a6";  // Used as a dummy initial value
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
-  deleted_version.version_id = kArbitraryVersionId;
+  deleted_version.version_uuid = kArbitraryVersionId;
   std::vector<int64> newly_purgeable_resources;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(
                 data, resources, &deleted_version, &newly_purgeable_resources));
-  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(deleted_version.version_uuid.empty());
   EXPECT_TRUE(newly_purgeable_resources.empty());
 
   // Delete from an origin that has a registration.
-  deleted_version.version_id = kArbitraryVersionId;
+  deleted_version.version_uuid = kArbitraryVersionId;
   newly_purgeable_resources.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(kNonExistentRegistrationId,
                                          origin,
                                          &deleted_version,
                                          &newly_purgeable_resources));
-  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(deleted_version.version_uuid.empty());
   EXPECT_TRUE(newly_purgeable_resources.empty());
 
   // Delete from an origin that has no registration.
-  deleted_version.version_id = kArbitraryVersionId;
+  deleted_version.version_uuid = kArbitraryVersionId;
   newly_purgeable_resources.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(kNonExistentRegistrationId,
                                          GURL("http://example.net"),
                                          &deleted_version,
                                          &newly_purgeable_resources));
-  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(deleted_version.version_uuid.empty());
   EXPECT_TRUE(newly_purgeable_resources.empty());
 }
 
 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.version_uuid = "b294411b-4a2c-4bf4-b072-6775a499bbd7";
   data.resources_total_size_bytes = 10 + 11;
 
   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
+  deleted_version.version_uuid =
+      "904d263b-9872-49f2-bd33-147b98f6d1b8";  // 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(deleted_version.version_uuid.empty());
   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.version_uuid =
+      "a504ba56-4f06-4c48-a904-474e25bca691";  // New version id
   updated_data.resources_total_size_bytes = 12 + 13;
   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);
+  EXPECT_EQ(data.version_uuid, deleted_version.version_uuid);
   ASSERT_EQ(resources1.size(), newly_purgeable_resources.size());
   for (size_t i = 0; i < resources1.size(); ++i)
     EXPECT_EQ(newly_purgeable_resources[i], resources1[i].resource_id);
 
   // Make sure that |updated_data| is stored and resources referred from |data|
   // is moved to the purgeable list.
   resources_out.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       updated_data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(updated_data, data_out);
@@ skipping 12 matching lines @@
   GURL origin("http://example.com");
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
 
   // Add registration1.
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(origin, "/foo");
   data1.script = URL(origin, "/script1.js");
-  data1.version_id = 200;
+  data1.version_uuid = "f731439c-d7ea-423d-91e4-9fc910f439f2";
   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.version_id = 201;
+  data2.version_uuid = "3eba69fd-38f3-4807-a5ac-329d22d91357";
   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 78 matching lines @@
   GURL origin_out;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->ReadRegistrationOrigin(100, &origin_out));
 
   // Deleting non-existent registration should succeed.
   RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(
                 100, origin, &deleted_version, &newly_purgeable_resources));
-  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(deleted_version.version_uuid.empty());
   EXPECT_TRUE(newly_purgeable_resources.empty());
 
   // Actually create a new database, but not initialized yet.
   database->LazyOpen(true);
 
   // Should be failed because the database is not initialized.
   ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_);
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->ReadRegistration(
                 100, origin, &data_out, &resources_out));
   EXPECT_EQ(kInvalidServiceWorkerRegistrationId, data_out.registration_id);
   EXPECT_TRUE(resources_out.empty());
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->ReadRegistrationOrigin(100, &origin_out));
 
   // Deleting non-existent registration should succeed.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->DeleteRegistration(
                 100, origin, &deleted_version, &newly_purgeable_resources));
-  EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
+  EXPECT_TRUE(deleted_version.version_uuid.empty());
   EXPECT_TRUE(newly_purgeable_resources.empty());
 }
 
 TEST(ServiceWorkerDatabaseTest, UserData_Basic) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   const GURL kOrigin("http://example.com");
 
   // Add a registration.
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(kOrigin, "/foo");
   data.script = URL(kOrigin, "/script.js");
-  data.version_id = 200;
+  data.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010";
   data.resources_total_size_bytes = 100;
   std::vector<Resource> resources;
   resources.push_back(CreateResource(1, data.script, 100));
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(
                 data, resources, &deleted_version, &newly_purgeable_resources));
 
   // Write user data associated with the stored registration.
@@ skipping 47 matching lines @@
 
 TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   const GURL kOrigin("http://example.com");
 
   // Add registration 1.
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(kOrigin, "/foo");
   data1.script = URL(kOrigin, "/script1.js");
-  data1.version_id = 200;
+  data1.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010";
   data1.resources_total_size_bytes = 100;
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, data1.script, 100));
 
   // Add registration 2.
   RegistrationData data2;
   data2.registration_id = 101;
   data2.scope = URL(kOrigin, "/bar");
   data2.script = URL(kOrigin, "/script2.js");
-  data2.version_id = 201;
+  data2.version_uuid = "645ba1bc-bc64-4867-bfb8-71a909704254";
   data2.resources_total_size_bytes = 200;
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(2, data2.script, 200));
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data1, resources1, &deleted_version,
                                         &newly_purgeable_resources));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ skipping 60 matching lines @@
 
 TEST(ServiceWorkerDatabaseTest, UserData_DeleteRegistration) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
   const GURL kOrigin("http://example.com");
 
   // Add registration 1.
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(kOrigin, "/foo");
   data1.script = URL(kOrigin, "/script1.js");
-  data1.version_id = 200;
+  data1.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010";
   data1.resources_total_size_bytes = 100;
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, data1.script, 100));
 
   // Add registration 2.
   RegistrationData data2;
   data2.registration_id = 101;
   data2.scope = URL(kOrigin, "/bar");
   data2.script = URL(kOrigin, "/script2.js");
-  data2.version_id = 201;
+  data2.version_uuid = "645ba1bc-bc64-4867-bfb8-71a909704254";
   data2.resources_total_size_bytes = 200;
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(2, data2.script, 200));
 
   ServiceWorkerDatabase::RegistrationData deleted_version;
   std::vector<int64> newly_purgeable_resources;
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data1, resources1, &deleted_version,
                                         &newly_purgeable_resources));
   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ skipping 85 matching lines @@
 
   // Should be false because a registration does not exist.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->UpdateVersionToActive(0, origin));
 
   // Add a registration.
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
-  data.version_id = 200;
+  data.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010";
   data.is_active = false;
   data.resources_total_size_bytes = 100;
   std::vector<Resource> resources;
   resources.push_back(CreateResource(1, data.script, 100));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data, resources, &deleted_version,
                                         &newly_purgeable_resources));
 
   // Make sure that the registration is stored.
   RegistrationData data_out;
@@ skipping 39 matching lines @@
 
   // Should be false because a registration does not exist.
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
             database->UpdateLastCheckTime(0, origin, base::Time::Now()));
 
   // Add a registration.
   RegistrationData data;
   data.registration_id = 100;
   data.scope = URL(origin, "/foo");
   data.script = URL(origin, "/script.js");
-  data.version_id = 200;
+  data.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010";
   data.last_update_check = base::Time::Now();
   data.resources_total_size_bytes = 100;
   std::vector<Resource> resources;
   resources.push_back(CreateResource(1, data.script, 100));
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->WriteRegistration(data, resources, &deleted_version,
                                         &newly_purgeable_resources));
 
   // Make sure that the registration is stored.
   RegistrationData data_out;
@@ skipping 127 matching lines @@
 
   // 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.version_id = 100;
+  data1.version_uuid = "8dba4236-45fc-4694-b451-c34b45a4666d";
   data1.resources_total_size_bytes = 2013 + 512;
 
   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.version_id = 101;
+  data2.version_uuid = "9cdf4806-400b-4238-b890-f480273d4ea8";
   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.version_id = 102;
+  data3.version_uuid = "743b5448-f6e3-4141-ad5b-2e40118bf07f";
   data3.resources_total_size_bytes = 6 + 7;
 
   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(
@@ skipping 84 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