content/browser/service_worker/service_worker_database_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/service_worker/service_worker_database.h"
   6
   7 #include <string>
   8
   9 #include "base/files/file_util.h"
  10 #include "base/files/scoped_temp_dir.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "content/browser/service_worker/service_worker_database.pb.h"
  14 #include "content/common/service_worker/service_worker_types.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
  17
  18 namespace content {
  19
  20 namespace {
  21
  22 typedef ServiceWorkerDatabase::RegistrationData RegistrationData;
  23 typedef ServiceWorkerDatabase::ResourceRecord Resource;
  24
  25 struct AvailableIds {
  26   int64 reg_id;
  27   int64 res_id;
  28   int64 ver_id;
  29
  30   AvailableIds() : reg_id(-1), res_id(-1), ver_id(-1) {}
  31   ~AvailableIds() {}
  32 };
  33
  34 GURL URL(const GURL& origin, const std::string& path) {
  35   EXPECT_TRUE(origin.is_valid());
  36   EXPECT_EQ(origin, origin.GetOrigin());
  37   GURL out(origin.spec() + path);
  38   EXPECT_TRUE(out.is_valid());
  39   return out;
  40 }
  41
  42 Resource CreateResource(int64 resource_id, const GURL& url, uint64 size_bytes) {
  43   EXPECT_TRUE(url.is_valid());
  44   return Resource(resource_id, url, size_bytes);
  45 }
  46
  47 ServiceWorkerDatabase* CreateDatabase(const base::FilePath& path) {
  48   return new ServiceWorkerDatabase(path);
  49 }
  50
  51 ServiceWorkerDatabase* CreateDatabaseInMemory() {
  52   return new ServiceWorkerDatabase(base::FilePath());
  53 }
  54
  55 void VerifyRegistrationData(const RegistrationData& expected,
  56                             const RegistrationData& actual) {
  57   EXPECT_EQ(expected.registration_id, actual.registration_id);
  58   EXPECT_EQ(expected.scope, actual.scope);
  59   EXPECT_EQ(expected.script, actual.script);
  60   EXPECT_EQ(expected.version_id, actual.version_id);
  61   EXPECT_EQ(expected.is_active, actual.is_active);
  62   EXPECT_EQ(expected.has_fetch_handler, actual.has_fetch_handler);
  63   EXPECT_EQ(expected.last_update_check, actual.last_update_check);
  64   EXPECT_EQ(expected.resources_total_size_bytes,
  65             actual.resources_total_size_bytes);
  66 }
  67
  68 void VerifyResourceRecords(const std::vector<Resource>& expected,
  69                            const std::vector<Resource>& actual) {
  70   ASSERT_EQ(expected.size(), actual.size());
  71   for (size_t i = 0; i < expected.size(); ++i) {
  72     EXPECT_EQ(expected[i].resource_id, actual[i].resource_id);
  73     EXPECT_EQ(expected[i].url, actual[i].url);
  74     EXPECT_EQ(expected[i].size_bytes, actual[i].size_bytes);
  75   }
  76 }
  77
  78 }  // namespace
  79
  80 TEST(ServiceWorkerDatabaseTest, OpenDatabase) {
  81   base::ScopedTempDir database_dir;
  82   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
  83   scoped_ptr<ServiceWorkerDatabase> database(
  84       CreateDatabase(database_dir.path()));
  85
  86   // Should be false because the database does not exist at the path.
  87   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
  88             database->LazyOpen(false));
  89
  90   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
  91
  92   database.reset(CreateDatabase(database_dir.path()));
  93   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(false));
  94 }
  95
  96 TEST(ServiceWorkerDatabaseTest, OpenDatabase_InMemory) {
  97   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
  98
  99   // Should be false because the database does not exist in memory.
 100   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 101             database->LazyOpen(false));
 102
 103   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
 104   database.reset(CreateDatabaseInMemory());
 105
 106   // Should be false because the database is not persistent.
 107   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 108             database->LazyOpen(false));
 109 }
 110
 111 TEST(ServiceWorkerDatabaseTest, DatabaseVersion) {
 112   GURL origin("http://example.com");
 113   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 114   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
 115
 116   // Opening a new database does not write anything, so its schema version
 117   // should be 0.
 118   int64 db_version = -1;
 119   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 120             database->ReadDatabaseVersion(&db_version));
 121   EXPECT_EQ(0u, db_version);
 122
 123   // First writing triggers database initialization and bumps the schema
 124   // version.
 125   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
 126   resources.push_back(CreateResource(1, URL(origin, "/resource"), 10));
 127   ServiceWorkerDatabase::RegistrationData deleted_version;
 128   std::vector<int64> newly_purgeable_resources;
 129   ServiceWorkerDatabase::RegistrationData data;
 130   data.resources_total_size_bytes = 10;
 131   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 132             database->WriteRegistration(
 133                 data, resources, &deleted_version, &newly_purgeable_resources));
 134
 135   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 136             database->ReadDatabaseVersion(&db_version));
 137   EXPECT_LT(0, db_version);
 138 }
 139
 140 TEST(ServiceWorkerDatabaseTest, UpgradeSchemaToVersion2) {
 141   base::ScopedTempDir database_dir;
 142   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 143   scoped_ptr<ServiceWorkerDatabase> database(
 144       CreateDatabase(database_dir.path()));
 145
 146   GURL origin("http://example.com");
 147
 148   // Add a registration to the database.
 149   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
 150   ServiceWorkerDatabase::RegistrationData deleted_version;
 151   std::vector<int64> newly_purgeable_resources;
 152   ServiceWorkerDatabase::RegistrationData data;
 153   data.registration_id = 100;
 154   data.scope = URL(origin, "/foo");
 155   data.script = URL(origin, "/script1.js");
 156   data.version_id = 200;
 157   data.resources_total_size_bytes = 300;
 158   resources.push_back(CreateResource(1, data.script, 300));
 159   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 160             database->WriteRegistration(data, resources, &deleted_version,
 161                                         &newly_purgeable_resources));
 162
 163   // Sanity check on current version.
 164   int64 db_version = -1;
 165   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 166             database->ReadDatabaseVersion(&db_version));
 167   EXPECT_LE(2, db_version);
 168
 169   // Now delete the data that will be created in an upgrade to schema version 2,
 170   // and reset the schema version to 1.
 171   leveldb::WriteBatch batch;
 172   batch.Delete("REGID_TO_ORIGIN:" + base::Int64ToString(data.registration_id));
 173   batch.Put("INITDATA_DB_VERSION", base::Int64ToString(1));
 174   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, database->WriteBatch(&batch));
 175
 176   // Make sure correct data got deleted.
 177   GURL origin_out;
 178   EXPECT_EQ(
 179       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 180       database->ReadRegistrationOrigin(data.registration_id, &origin_out));
 181
 182   // Close and reopen the database to verify the schema got updated.
 183   database.reset(CreateDatabase(database_dir.path()));
 184   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
 185
 186   // Verify version number.
 187   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 188             database->ReadDatabaseVersion(&db_version));
 189   EXPECT_LE(2, db_version);
 190
 191   // And check that looking up origin for registration works.
 192   EXPECT_EQ(
 193       ServiceWorkerDatabase::STATUS_OK,
 194       database->ReadRegistrationOrigin(data.registration_id, &origin_out));
 195   EXPECT_EQ(origin, origin_out);
 196 }
 197
 198 TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) {
 199   base::ScopedTempDir database_dir;
 200   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
 201   scoped_ptr<ServiceWorkerDatabase> database(
 202       CreateDatabase(database_dir.path()));
 203
 204   GURL origin("http://example.com");
 205
 206   // The database has never been used, so returns initial values.
 207   AvailableIds ids;
 208   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
 209       &ids.reg_id, &ids.ver_id, &ids.res_id));
 210   EXPECT_EQ(0, ids.reg_id);
 211   EXPECT_EQ(0, ids.ver_id);
 212   EXPECT_EQ(0, ids.res_id);
 213
 214   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
 215   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
 216       &ids.reg_id, &ids.ver_id, &ids.res_id));
 217   EXPECT_EQ(0, ids.reg_id);
 218   EXPECT_EQ(0, ids.ver_id);
 219   EXPECT_EQ(0, ids.res_id);
 220
 221   // Writing a registration bumps the next available ids.
 222   std::vector<Resource> resources1;
 223   RegistrationData data1;
 224   ServiceWorkerDatabase::RegistrationData deleted_version;
 225   std::vector<int64> newly_purgeable_resources;
 226   data1.registration_id = 100;
 227   data1.scope = URL(origin, "/foo");
 228   data1.script = URL(origin, "/script1.js");
 229   data1.version_id = 200;
 230   data1.resources_total_size_bytes = 300;
 231   resources1.push_back(CreateResource(1, data1.script, 300));
 232   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 233             database->WriteRegistration(data1, resources1, &deleted_version,
 234                                         &newly_purgeable_resources));
 235
 236   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
 237       &ids.reg_id, &ids.ver_id, &ids.res_id));
 238   EXPECT_EQ(101, ids.reg_id);
 239   EXPECT_EQ(201, ids.ver_id);
 240   EXPECT_EQ(0, ids.res_id);
 241
 242   // Writing uncommitted resources bumps the next available id.
 243   const int64 kUncommittedIds[] = {0, 1, 3, 5, 6, 10};
 244   EXPECT_EQ(
 245       ServiceWorkerDatabase::STATUS_OK,
 246       database->WriteUncommittedResourceIds(std::set<int64>(
 247           kUncommittedIds, kUncommittedIds + arraysize(kUncommittedIds))));
 248   EXPECT_EQ(
 249       ServiceWorkerDatabase::STATUS_OK,
 250       database->GetNextAvailableIds(&ids.reg_id, &ids.ver_id, &ids.res_id));
 251   EXPECT_EQ(101, ids.reg_id);
 252   EXPECT_EQ(201, ids.ver_id);
 253   EXPECT_EQ(11, ids.res_id);
 254
 255   // Writing purgeable resources bumps the next available id.
 256   const int64 kPurgeableIds[] = {4, 12, 16, 17, 20};
 257   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 258             database->WriteUncommittedResourceIds(std::set<int64>(
 259                 kPurgeableIds, kPurgeableIds + arraysize(kPurgeableIds))));
 260   EXPECT_EQ(
 261       ServiceWorkerDatabase::STATUS_OK,
 262       database->GetNextAvailableIds(&ids.reg_id, &ids.ver_id, &ids.res_id));
 263   EXPECT_EQ(101, ids.reg_id);
 264   EXPECT_EQ(201, ids.ver_id);
 265   EXPECT_EQ(21, ids.res_id);
 266
 267   // Writing a registration whose ids are lower than the stored ones should not
 268   // bump the next available ids.
 269   RegistrationData data2;
 270   data2.registration_id = 10;
 271   data2.scope = URL(origin, "/bar");
 272   data2.script = URL(origin, "/script2.js");
 273   data2.version_id = 20;
 274   data2.resources_total_size_bytes = 400;
 275   std::vector<Resource> resources2;
 276   resources2.push_back(CreateResource(2, data2.script, 400));
 277   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 278             database->WriteRegistration(data2, resources2, &deleted_version,
 279                                         &newly_purgeable_resources));
 280
 281   // Same with resources.
 282   int64 kLowResourceId = 15;
 283   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 284             database->WriteUncommittedResourceIds(
 285                 std::set<int64>(&kLowResourceId, &kLowResourceId + 1)));
 286
 287   // Close and reopen the database to verify the stored values.
 288   database.reset(CreateDatabase(database_dir.path()));
 289
 290   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
 291       &ids.reg_id, &ids.ver_id, &ids.res_id));
 292   EXPECT_EQ(101, ids.reg_id);
 293   EXPECT_EQ(201, ids.ver_id);
 294   EXPECT_EQ(21, ids.res_id);
 295 }
 296
 297 TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
 298   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 299
 300   std::set<GURL> origins;
 301   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 302             database->GetOriginsWithRegistrations(&origins));
 303   EXPECT_TRUE(origins.empty());
 304
 305   ServiceWorkerDatabase::RegistrationData deleted_version;
 306   std::vector<int64> newly_purgeable_resources;
 307
 308   GURL origin1("http://example.com");
 309   RegistrationData data1;
 310   data1.registration_id = 123;
 311   data1.scope = URL(origin1, "/foo");
 312   data1.script = URL(origin1, "/script1.js");
 313   data1.version_id = 456;
 314   data1.resources_total_size_bytes = 100;
 315   std::vector<Resource> resources1;
 316   resources1.push_back(CreateResource(1, data1.script, 100));
 317   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 318             database->WriteRegistration(data1, resources1, &deleted_version,
 319                                         &newly_purgeable_resources));
 320
 321   GURL origin2("https://www.example.com");
 322   RegistrationData data2;
 323   data2.registration_id = 234;
 324   data2.scope = URL(origin2, "/bar");
 325   data2.script = URL(origin2, "/script2.js");
 326   data2.version_id = 567;
 327   data2.resources_total_size_bytes = 200;
 328   std::vector<Resource> resources2;
 329   resources2.push_back(CreateResource(2, data2.script, 200));
 330   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 331             database->WriteRegistration(data2, resources2, &deleted_version,
 332                                         &newly_purgeable_resources));
 333
 334   GURL origin3("https://example.org");
 335   RegistrationData data3;
 336   data3.registration_id = 345;
 337   data3.scope = URL(origin3, "/hoge");
 338   data3.script = URL(origin3, "/script3.js");
 339   data3.version_id = 678;
 340   data3.resources_total_size_bytes = 300;
 341   std::vector<Resource> resources3;
 342   resources3.push_back(CreateResource(3, data3.script, 300));
 343   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 344             database->WriteRegistration(data3, resources3, &deleted_version,
 345                                         &newly_purgeable_resources));
 346
 347   // |origin3| has two registrations.
 348   RegistrationData data4;
 349   data4.registration_id = 456;
 350   data4.scope = URL(origin3, "/fuga");
 351   data4.script = URL(origin3, "/script4.js");
 352   data4.version_id = 789;
 353   data4.resources_total_size_bytes = 400;
 354   std::vector<Resource> resources4;
 355   resources4.push_back(CreateResource(4, data4.script, 400));
 356   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 357             database->WriteRegistration(data4, resources4, &deleted_version,
 358                                         &newly_purgeable_resources));
 359
 360   origins.clear();
 361   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 362             database->GetOriginsWithRegistrations(&origins));
 363   EXPECT_EQ(3U, origins.size());
 364   EXPECT_TRUE(ContainsKey(origins, origin1));
 365   EXPECT_TRUE(ContainsKey(origins, origin2));
 366   EXPECT_TRUE(ContainsKey(origins, origin3));
 367
 368   // |origin3| has another registration, so should not remove it from the
 369   // unique origin list.
 370   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 371             database->DeleteRegistration(data4.registration_id,
 372                                          origin3,
 373                                          &deleted_version,
 374                                          &newly_purgeable_resources));
 375   EXPECT_EQ(data4.registration_id, deleted_version.registration_id);
 376
 377   origins.clear();
 378   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 379             database->GetOriginsWithRegistrations(&origins));
 380   EXPECT_EQ(3U, origins.size());
 381   EXPECT_TRUE(ContainsKey(origins, origin1));
 382   EXPECT_TRUE(ContainsKey(origins, origin2));
 383   EXPECT_TRUE(ContainsKey(origins, origin3));
 384
 385   // |origin3| should be removed from the unique origin list.
 386   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 387             database->DeleteRegistration(data3.registration_id,
 388                                          origin3,
 389                                          &deleted_version,
 390                                          &newly_purgeable_resources));
 391   EXPECT_EQ(data3.registration_id, deleted_version.registration_id);
 392
 393   origins.clear();
 394   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 395             database->GetOriginsWithRegistrations(&origins));
 396   EXPECT_EQ(2U, origins.size());
 397   EXPECT_TRUE(ContainsKey(origins, origin1));
 398   EXPECT_TRUE(ContainsKey(origins, origin2));
 399 }
 400
 401 TEST(ServiceWorkerDatabaseTest, GetRegistrationsForOrigin) {
 402   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 403
 404   GURL origin1("http://example.com");
 405   GURL origin2("https://www.example.com");
 406   GURL origin3("https://example.org");
 407
 408   std::vector<RegistrationData> registrations;
 409   std::vector<std::vector<Resource>> resources_list;
 410   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 411             database->GetRegistrationsForOrigin(origin1, &registrations,
 412                                                 &resources_list));
 413   EXPECT_TRUE(registrations.empty());
 414   EXPECT_TRUE(resources_list.empty());
 415
 416   ServiceWorkerDatabase::RegistrationData deleted_version;
 417   std::vector<int64> newly_purgeable_resources;
 418
 419   RegistrationData data1;
 420   data1.registration_id = 100;
 421   data1.scope = URL(origin1, "/foo");
 422   data1.script = URL(origin1, "/script1.js");
 423   data1.version_id = 1000;
 424   data1.resources_total_size_bytes = 100;
 425   std::vector<Resource> resources1;
 426   resources1.push_back(CreateResource(1, data1.script, 100));
 427   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 428             database->WriteRegistration(data1, resources1, &deleted_version,
 429                                         &newly_purgeable_resources));
 430
 431   registrations.clear();
 432   resources_list.clear();
 433   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 434             database->GetRegistrationsForOrigin(origin1, &registrations,
 435                                                 &resources_list));
 436   EXPECT_EQ(1U, registrations.size());
 437   VerifyRegistrationData(data1, registrations[0]);
 438   EXPECT_EQ(1U, resources_list.size());
 439   VerifyResourceRecords(resources1, resources_list[0]);
 440
 441   RegistrationData data2;
 442   data2.registration_id = 200;
 443   data2.scope = URL(origin2, "/bar");
 444   data2.script = URL(origin2, "/script2.js");
 445   data2.version_id = 2000;
 446   data2.resources_total_size_bytes = 200;
 447   std::vector<Resource> resources2;
 448   resources2.push_back(CreateResource(2, data2.script, 200));
 449   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 450             database->WriteRegistration(data2, resources2, &deleted_version,
 451                                         &newly_purgeable_resources));
 452
 453   registrations.clear();
 454   resources_list.clear();
 455   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 456             database->GetRegistrationsForOrigin(origin2, &registrations,
 457                                                 &resources_list));
 458   EXPECT_EQ(1U, registrations.size());
 459   VerifyRegistrationData(data2, registrations[0]);
 460   EXPECT_EQ(1U, resources_list.size());
 461   VerifyResourceRecords(resources2, resources_list[0]);
 462
 463   RegistrationData data3;
 464   data3.registration_id = 300;
 465   data3.scope = URL(origin3, "/hoge");
 466   data3.script = URL(origin3, "/script3.js");
 467   data3.version_id = 3000;
 468   data3.resources_total_size_bytes = 300;
 469   std::vector<Resource> resources3;
 470   resources3.push_back(CreateResource(3, data3.script, 300));
 471   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 472             database->WriteRegistration(data3, resources3, &deleted_version,
 473                                         &newly_purgeable_resources));
 474
 475   // |origin3| has two registrations.
 476   RegistrationData data4;
 477   data4.registration_id = 400;
 478   data4.scope = URL(origin3, "/fuga");
 479   data4.script = URL(origin3, "/script4.js");
 480   data4.version_id = 4000;
 481   data4.resources_total_size_bytes = 400;
 482   std::vector<Resource> resources4;
 483   resources4.push_back(CreateResource(4, data4.script, 400));
 484   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 485             database->WriteRegistration(data4, resources4, &deleted_version,
 486                                         &newly_purgeable_resources));
 487
 488   registrations.clear();
 489   resources_list.clear();
 490   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 491             database->GetRegistrationsForOrigin(origin3, &registrations,
 492                                                 &resources_list));
 493   EXPECT_EQ(2U, registrations.size());
 494   VerifyRegistrationData(data3, registrations[0]);
 495   VerifyRegistrationData(data4, registrations[1]);
 496   EXPECT_EQ(2U, resources_list.size());
 497   VerifyResourceRecords(resources3, resources_list[0]);
 498   VerifyResourceRecords(resources4, resources_list[1]);
 499
 500   // The third parameter |opt_resources_list| to GetRegistrationsForOrigin()
 501   // is optional. So, nullptr should be acceptable.
 502   registrations.clear();
 503   EXPECT_EQ(
 504       ServiceWorkerDatabase::STATUS_OK,
 505       database->GetRegistrationsForOrigin(origin1, &registrations, nullptr));
 506   EXPECT_EQ(1U, registrations.size());
 507   VerifyRegistrationData(data1, registrations[0]);
 508 }
 509
 510 TEST(ServiceWorkerDatabaseTest, GetAllRegistrations) {
 511   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 512
 513   std::vector<RegistrationData> registrations;
 514   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 515             database->GetAllRegistrations(&registrations));
 516   EXPECT_TRUE(registrations.empty());
 517
 518   ServiceWorkerDatabase::RegistrationData deleted_version;
 519   std::vector<int64> newly_purgeable_resources;
 520
 521   GURL origin1("http://www1.example.com");
 522   RegistrationData data1;
 523   data1.registration_id = 100;
 524   data1.scope = URL(origin1, "/foo");
 525   data1.script = URL(origin1, "/script1.js");
 526   data1.version_id = 1000;
 527   data1.resources_total_size_bytes = 100;
 528   std::vector<Resource> resources1;
 529   resources1.push_back(CreateResource(1, data1.script, 100));
 530   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 531             database->WriteRegistration(data1, resources1, &deleted_version,
 532                                         &newly_purgeable_resources));
 533
 534   GURL origin2("http://www2.example.com");
 535   RegistrationData data2;
 536   data2.registration_id = 200;
 537   data2.scope = URL(origin2, "/bar");
 538   data2.script = URL(origin2, "/script2.js");
 539   data2.version_id = 2000;
 540   data2.resources_total_size_bytes = 200;
 541   std::vector<Resource> resources2;
 542   resources2.push_back(CreateResource(2, data2.script, 200));
 543   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 544             database->WriteRegistration(data2, resources2, &deleted_version,
 545                                         &newly_purgeable_resources));
 546
 547   GURL origin3("http://www3.example.com");
 548   RegistrationData data3;
 549   data3.registration_id = 300;
 550   data3.scope = URL(origin3, "/hoge");
 551   data3.script = URL(origin3, "/script3.js");
 552   data3.version_id = 3000;
 553   data3.resources_total_size_bytes = 300;
 554   std::vector<Resource> resources3;
 555   resources3.push_back(CreateResource(3, data3.script, 300));
 556   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 557             database->WriteRegistration(data3, resources3, &deleted_version,
 558                                         &newly_purgeable_resources));
 559
 560   // |origin3| has two registrations.
 561   RegistrationData data4;
 562   data4.registration_id = 400;
 563   data4.scope = URL(origin3, "/fuga");
 564   data4.script = URL(origin3, "/script4.js");
 565   data4.version_id = 4000;
 566   data4.resources_total_size_bytes = 400;
 567   std::vector<Resource> resources4;
 568   resources4.push_back(CreateResource(4, data4.script, 400));
 569   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 570             database->WriteRegistration(data4, resources4, &deleted_version,
 571                                         &newly_purgeable_resources));
 572
 573   registrations.clear();
 574   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 575             database->GetAllRegistrations(&registrations));
 576   EXPECT_EQ(4U, registrations.size());
 577   VerifyRegistrationData(data1, registrations[0]);
 578   VerifyRegistrationData(data2, registrations[1]);
 579   VerifyRegistrationData(data3, registrations[2]);
 580   VerifyRegistrationData(data4, registrations[3]);
 581 }
 582
 583 TEST(ServiceWorkerDatabaseTest, Registration_Basic) {
 584   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 585
 586   GURL origin("http://example.com");
 587   RegistrationData data;
 588   data.registration_id = 100;
 589   data.scope = URL(origin, "/foo");
 590   data.script = URL(origin, "/script.js");
 591   data.version_id = 200;
 592   data.resources_total_size_bytes = 10939 + 200;
 593
 594   std::vector<Resource> resources;
 595   resources.push_back(CreateResource(1, URL(origin, "/resource1"), 10939));
 596   resources.push_back(CreateResource(2, URL(origin, "/resource2"), 200));
 597
 598   // Write a resource to the uncommitted list to make sure that writing
 599   // registration removes resource ids associated with the registration from
 600   // the uncommitted list.
 601   std::set<int64> uncommitted_ids;
 602   uncommitted_ids.insert(resources[0].resource_id);
 603   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 604             database->WriteUncommittedResourceIds(uncommitted_ids));
 605   std::set<int64> uncommitted_ids_out;
 606   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 607             database->GetUncommittedResourceIds(&uncommitted_ids_out));
 608   EXPECT_EQ(uncommitted_ids, uncommitted_ids_out);
 609
 610   ServiceWorkerDatabase::RegistrationData deleted_version;
 611   deleted_version.version_id = 222;  // Dummy initial value
 612   std::vector<int64> newly_purgeable_resources;
 613
 614   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 615             database->WriteRegistration(
 616                 data, resources, &deleted_version, &newly_purgeable_resources));
 617   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
 618   EXPECT_TRUE(newly_purgeable_resources.empty());
 619
 620   // Make sure that the registration and resource records are stored.
 621   RegistrationData data_out;
 622   std::vector<Resource> resources_out;
 623   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 624             database->ReadRegistration(
 625                 data.registration_id, origin, &data_out, &resources_out));
 626   VerifyRegistrationData(data, data_out);
 627   VerifyResourceRecords(resources, resources_out);
 628   GURL origin_out;
 629   EXPECT_EQ(
 630       ServiceWorkerDatabase::STATUS_OK,
 631       database->ReadRegistrationOrigin(data.registration_id, &origin_out));
 632   EXPECT_EQ(origin, origin_out);
 633
 634   // Make sure that the resource is removed from the uncommitted list.
 635   uncommitted_ids_out.clear();
 636   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 637             database->GetUncommittedResourceIds(&uncommitted_ids_out));
 638   EXPECT_TRUE(uncommitted_ids_out.empty());
 639
 640   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 641             database->DeleteRegistration(data.registration_id,
 642                                          origin,
 643                                          &deleted_version,
 644                                          &newly_purgeable_resources));
 645   EXPECT_EQ(data.version_id, deleted_version.version_id);
 646   ASSERT_EQ(resources.size(), newly_purgeable_resources.size());
 647   for (size_t i = 0; i < resources.size(); ++i)
 648     EXPECT_EQ(newly_purgeable_resources[i], resources[i].resource_id);
 649
 650   // Make sure that the registration and resource records are gone.
 651   resources_out.clear();
 652   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 653             database->ReadRegistration(
 654                 data.registration_id, origin, &data_out, &resources_out));
 655   EXPECT_TRUE(resources_out.empty());
 656   EXPECT_EQ(
 657       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 658       database->ReadRegistrationOrigin(data.registration_id, &origin_out));
 659
 660   // Resources should be purgeable because these are no longer referred.
 661   std::set<int64> purgeable_ids_out;
 662   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 663             database->GetPurgeableResourceIds(&purgeable_ids_out));
 664   EXPECT_EQ(2u, purgeable_ids_out.size());
 665   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[0].resource_id));
 666   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[1].resource_id));
 667 }
 668
 669 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) {
 670   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 671
 672   GURL origin("http://example.com");
 673   RegistrationData data;
 674   data.registration_id = 100;
 675   data.scope = URL(origin, "/foo");
 676   data.script = URL(origin, "/script.js");
 677   data.version_id = 200;
 678   data.resources_total_size_bytes = 19 + 29129;
 679
 680   std::vector<Resource> resources;
 681   resources.push_back(CreateResource(1, URL(origin, "/resource1"), 19));
 682   resources.push_back(CreateResource(2, URL(origin, "/resource2"), 29129));
 683
 684   const int64 kNonExistentRegistrationId = 999;
 685   const int64 kArbitraryVersionId = 222;  // Used as a dummy initial value
 686
 687   ServiceWorkerDatabase::RegistrationData deleted_version;
 688   deleted_version.version_id = kArbitraryVersionId;
 689   std::vector<int64> newly_purgeable_resources;
 690   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 691             database->WriteRegistration(
 692                 data, resources, &deleted_version, &newly_purgeable_resources));
 693   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
 694   EXPECT_TRUE(newly_purgeable_resources.empty());
 695
 696   // Delete from an origin that has a registration.
 697   deleted_version.version_id = kArbitraryVersionId;
 698   newly_purgeable_resources.clear();
 699   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 700             database->DeleteRegistration(kNonExistentRegistrationId,
 701                                          origin,
 702                                          &deleted_version,
 703                                          &newly_purgeable_resources));
 704   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
 705   EXPECT_TRUE(newly_purgeable_resources.empty());
 706
 707   // Delete from an origin that has no registration.
 708   deleted_version.version_id = kArbitraryVersionId;
 709   newly_purgeable_resources.clear();
 710   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 711             database->DeleteRegistration(kNonExistentRegistrationId,
 712                                          GURL("http://example.net"),
 713                                          &deleted_version,
 714                                          &newly_purgeable_resources));
 715   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
 716   EXPECT_TRUE(newly_purgeable_resources.empty());
 717 }
 718
 719 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) {
 720   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 721
 722   GURL origin("http://example.com");
 723   RegistrationData data;
 724   data.registration_id = 100;
 725   data.scope = URL(origin, "/foo");
 726   data.script = URL(origin, "/script.js");
 727   data.version_id = 200;
 728   data.resources_total_size_bytes = 10 + 11;
 729
 730   std::vector<Resource> resources1;
 731   resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 10));
 732   resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 11));
 733
 734   ServiceWorkerDatabase::RegistrationData deleted_version;
 735   deleted_version.version_id = 222;  // Dummy inital value
 736   std::vector<int64> newly_purgeable_resources;
 737
 738   EXPECT_EQ(
 739       ServiceWorkerDatabase::STATUS_OK,
 740       database->WriteRegistration(
 741           data, resources1, &deleted_version, &newly_purgeable_resources));
 742   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
 743   EXPECT_TRUE(newly_purgeable_resources.empty());
 744
 745   // Make sure that the registration and resource records are stored.
 746   RegistrationData data_out;
 747   std::vector<Resource> resources_out;
 748   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
 749       data.registration_id, origin, &data_out, &resources_out));
 750   VerifyRegistrationData(data, data_out);
 751   VerifyResourceRecords(resources1, resources_out);
 752
 753   // Update the registration.
 754   RegistrationData updated_data = data;
 755   updated_data.version_id = data.version_id + 1;
 756   updated_data.resources_total_size_bytes = 12 + 13;
 757   std::vector<Resource> resources2;
 758   resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 12));
 759   resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 13));
 760
 761   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 762             database->WriteRegistration(updated_data,
 763                                         resources2,
 764                                         &deleted_version,
 765                                         &newly_purgeable_resources));
 766   EXPECT_EQ(data.version_id, deleted_version.version_id);
 767   ASSERT_EQ(resources1.size(), newly_purgeable_resources.size());
 768   for (size_t i = 0; i < resources1.size(); ++i)
 769     EXPECT_EQ(newly_purgeable_resources[i], resources1[i].resource_id);
 770
 771   // Make sure that |updated_data| is stored and resources referred from |data|
 772   // is moved to the purgeable list.
 773   resources_out.clear();
 774   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
 775       updated_data.registration_id, origin, &data_out, &resources_out));
 776   VerifyRegistrationData(updated_data, data_out);
 777   VerifyResourceRecords(resources2, resources_out);
 778
 779   std::set<int64> purgeable_ids_out;
 780   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 781             database->GetPurgeableResourceIds(&purgeable_ids_out));
 782   EXPECT_EQ(2u, purgeable_ids_out.size());
 783   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
 784   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 785 }
 786
 787 TEST(ServiceWorkerDatabaseTest, Registration_Multiple) {
 788   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 789   GURL origin("http://example.com");
 790
 791   ServiceWorkerDatabase::RegistrationData deleted_version;
 792   std::vector<int64> newly_purgeable_resources;
 793
 794   // Add registration1.
 795   RegistrationData data1;
 796   data1.registration_id = 100;
 797   data1.scope = URL(origin, "/foo");
 798   data1.script = URL(origin, "/script1.js");
 799   data1.version_id = 200;
 800   data1.resources_total_size_bytes = 1451 + 15234;
 801
 802   std::vector<Resource> resources1;
 803   resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 1451));
 804   resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 15234));
 805   EXPECT_EQ(
 806       ServiceWorkerDatabase::STATUS_OK,
 807       database->WriteRegistration(
 808           data1, resources1, &deleted_version, &newly_purgeable_resources));
 809
 810   // Add registration2.
 811   RegistrationData data2;
 812   data2.registration_id = 101;
 813   data2.scope = URL(origin, "/bar");
 814   data2.script = URL(origin, "/script2.js");
 815   data2.version_id = 201;
 816   data2.resources_total_size_bytes = 5 + 6;
 817
 818   std::vector<Resource> resources2;
 819   resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 5));
 820   resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 6));
 821   EXPECT_EQ(
 822       ServiceWorkerDatabase::STATUS_OK,
 823       database->WriteRegistration(
 824           data2, resources2, &deleted_version, &newly_purgeable_resources));
 825
 826   // Make sure that registration1 is stored.
 827   RegistrationData data_out;
 828   std::vector<Resource> resources_out;
 829   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
 830       data1.registration_id, origin, &data_out, &resources_out));
 831   VerifyRegistrationData(data1, data_out);
 832   VerifyResourceRecords(resources1, resources_out);
 833   GURL origin_out;
 834   EXPECT_EQ(
 835       ServiceWorkerDatabase::STATUS_OK,
 836       database->ReadRegistrationOrigin(data1.registration_id, &origin_out));
 837   EXPECT_EQ(origin, origin_out);
 838
 839   // Make sure that registration2 is also stored.
 840   resources_out.clear();
 841   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
 842       data2.registration_id, origin, &data_out, &resources_out));
 843   VerifyRegistrationData(data2, data_out);
 844   VerifyResourceRecords(resources2, resources_out);
 845   EXPECT_EQ(
 846       ServiceWorkerDatabase::STATUS_OK,
 847       database->ReadRegistrationOrigin(data2.registration_id, &origin_out));
 848   EXPECT_EQ(origin, origin_out);
 849
 850   std::set<int64> purgeable_ids_out;
 851   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 852             database->GetPurgeableResourceIds(&purgeable_ids_out));
 853   EXPECT_TRUE(purgeable_ids_out.empty());
 854
 855   // Delete registration1.
 856   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 857             database->DeleteRegistration(data1.registration_id,
 858                                          origin,
 859                                          &deleted_version,
 860                                          &newly_purgeable_resources));
 861   EXPECT_EQ(data1.registration_id, deleted_version.registration_id);
 862
 863   // Make sure that registration1 is gone.
 864   resources_out.clear();
 865   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 866             database->ReadRegistration(
 867                 data1.registration_id, origin, &data_out, &resources_out));
 868   EXPECT_TRUE(resources_out.empty());
 869   EXPECT_EQ(
 870       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 871       database->ReadRegistrationOrigin(data1.registration_id, &origin_out));
 872
 873   purgeable_ids_out.clear();
 874   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 875             database->GetPurgeableResourceIds(&purgeable_ids_out));
 876   EXPECT_EQ(2u, purgeable_ids_out.size());
 877   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
 878   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 879
 880   // Make sure that registration2 is still alive.
 881   resources_out.clear();
 882   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
 883       data2.registration_id, origin, &data_out, &resources_out));
 884   VerifyRegistrationData(data2, data_out);
 885   VerifyResourceRecords(resources2, resources_out);
 886   EXPECT_EQ(
 887       ServiceWorkerDatabase::STATUS_OK,
 888       database->ReadRegistrationOrigin(data2.registration_id, &origin_out));
 889   EXPECT_EQ(origin, origin_out);
 890 }
 891
 892 TEST(ServiceWorkerDatabaseTest, Registration_UninitializedDatabase) {
 893   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 894   const GURL origin("http://example.com");
 895
 896   // Should be failed because the database does not exist.
 897   RegistrationData data_out;
 898   std::vector<Resource> resources_out;
 899   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 900             database->ReadRegistration(
 901                 100, origin, &data_out, &resources_out));
 902   EXPECT_EQ(kInvalidServiceWorkerRegistrationId, data_out.registration_id);
 903   EXPECT_TRUE(resources_out.empty());
 904   GURL origin_out;
 905   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 906             database->ReadRegistrationOrigin(100, &origin_out));
 907
 908   // Deleting non-existent registration should succeed.
 909   RegistrationData deleted_version;
 910   std::vector<int64> newly_purgeable_resources;
 911   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 912             database->DeleteRegistration(
 913                 100, origin, &deleted_version, &newly_purgeable_resources));
 914   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
 915   EXPECT_TRUE(newly_purgeable_resources.empty());
 916
 917   // Actually create a new database, but not initialized yet.
 918   database->LazyOpen(true);
 919
 920   // Should be failed because the database is not initialized.
 921   ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_);
 922   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 923             database->ReadRegistration(
 924                 100, origin, &data_out, &resources_out));
 925   EXPECT_EQ(kInvalidServiceWorkerRegistrationId, data_out.registration_id);
 926   EXPECT_TRUE(resources_out.empty());
 927   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 928             database->ReadRegistrationOrigin(100, &origin_out));
 929
 930   // Deleting non-existent registration should succeed.
 931   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 932             database->DeleteRegistration(
 933                 100, origin, &deleted_version, &newly_purgeable_resources));
 934   EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id);
 935   EXPECT_TRUE(newly_purgeable_resources.empty());
 936 }
 937
 938 TEST(ServiceWorkerDatabaseTest, UserData_Basic) {
 939   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 940   const GURL kOrigin("http://example.com");
 941
 942   // Add a registration.
 943   RegistrationData data;
 944   data.registration_id = 100;
 945   data.scope = URL(kOrigin, "/foo");
 946   data.script = URL(kOrigin, "/script.js");
 947   data.version_id = 200;
 948   data.resources_total_size_bytes = 100;
 949   std::vector<Resource> resources;
 950   resources.push_back(CreateResource(1, data.script, 100));
 951   ServiceWorkerDatabase::RegistrationData deleted_version;
 952   std::vector<int64> newly_purgeable_resources;
 953   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
 954             database->WriteRegistration(
 955                 data, resources, &deleted_version, &newly_purgeable_resources));
 956
 957   // Write user data associated with the stored registration.
 958   std::string user_data_out;
 959   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 960             database->WriteUserData(
 961                 data.registration_id, kOrigin, "key1", "data"));
 962   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 963             database->ReadUserData(
 964                 data.registration_id, "key1", &user_data_out));
 965   EXPECT_EQ("data", user_data_out);
 966
 967   // Writing user data not associated with the stored registration should be
 968   // failed.
 969   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 970             database->WriteUserData(300, kOrigin, "key1", "data"));
 971
 972   // Write empty user data for a different key.
 973   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 974             database->WriteUserData(
 975                 data.registration_id, kOrigin, "key2", std::string()));
 976   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 977             database->ReadUserData(
 978                 data.registration_id, "key2", &user_data_out));
 979   EXPECT_EQ(std::string(), user_data_out);
 980   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 981             database->ReadUserData(
 982                 data.registration_id, "key1", &user_data_out));
 983   EXPECT_EQ("data", user_data_out);
 984
 985   // Overwrite the existing user data.
 986   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 987             database->WriteUserData(
 988                 data.registration_id, kOrigin, "key1", "overwrite"));
 989   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 990             database->ReadUserData(
 991                 data.registration_id, "key1", &user_data_out));
 992   EXPECT_EQ("overwrite", user_data_out);
 993
 994   // Delete the user data.
 995   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
 996             database->DeleteUserData(data.registration_id, "key1"));
 997   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
 998             database->ReadUserData(
 999                 data.registration_id, "key1", &user_data_out));
1000   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1001             database->ReadUserData(
1002                 data.registration_id, "key2", &user_data_out));
1003   EXPECT_EQ(std::string(), user_data_out);
1004 }
1005
1006 TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) {
1007   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1008   const GURL kOrigin("http://example.com");
1009
1010   // Add registration 1.
1011   RegistrationData data1;
1012   data1.registration_id = 100;
1013   data1.scope = URL(kOrigin, "/foo");
1014   data1.script = URL(kOrigin, "/script1.js");
1015   data1.version_id = 200;
1016   data1.resources_total_size_bytes = 100;
1017   std::vector<Resource> resources1;
1018   resources1.push_back(CreateResource(1, data1.script, 100));
1019
1020   // Add registration 2.
1021   RegistrationData data2;
1022   data2.registration_id = 101;
1023   data2.scope = URL(kOrigin, "/bar");
1024   data2.script = URL(kOrigin, "/script2.js");
1025   data2.version_id = 201;
1026   data2.resources_total_size_bytes = 200;
1027   std::vector<Resource> resources2;
1028   resources2.push_back(CreateResource(2, data2.script, 200));
1029
1030   ServiceWorkerDatabase::RegistrationData deleted_version;
1031   std::vector<int64> newly_purgeable_resources;
1032   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1033             database->WriteRegistration(data1, resources1, &deleted_version,
1034                                         &newly_purgeable_resources));
1035   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1036             database->WriteRegistration(data2, resources2, &deleted_version,
1037                                         &newly_purgeable_resources));
1038
1039   // Write user data associated with the registration1.
1040   std::string user_data_out;
1041   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1042             database->WriteUserData(
1043                 data1.registration_id, kOrigin, "key", "data1"));
1044   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1045             database->ReadUserData(
1046                 data1.registration_id, "key", &user_data_out));
1047   EXPECT_EQ("data1", user_data_out);
1048   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1049             database->ReadUserData(
1050                 data2.registration_id, "key", &user_data_out));
1051
1052   // Write user data associated with the registration2. This shouldn't overwrite
1053   // the data associated with registration1.
1054   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1055             database->WriteUserData(
1056                 data2.registration_id, kOrigin, "key", "data2"));
1057   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1058             database->ReadUserData(
1059                 data1.registration_id, "key", &user_data_out));
1060   EXPECT_EQ("data1", user_data_out);
1061   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1062             database->ReadUserData(
1063                 data2.registration_id, "key", &user_data_out));
1064   EXPECT_EQ("data2", user_data_out);
1065
1066   // Get all registrations with user data.
1067   std::vector<std::pair<int64, std::string>> user_data_list;
1068   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1069             database->ReadUserDataForAllRegistrations("key", &user_data_list));
1070   EXPECT_EQ(2u, user_data_list.size());
1071   EXPECT_EQ(data1.registration_id, user_data_list[0].first);
1072   EXPECT_EQ("data1", user_data_list[0].second);
1073   EXPECT_EQ(data2.registration_id, user_data_list[1].first);
1074   EXPECT_EQ("data2", user_data_list[1].second);
1075
1076   // Delete the data associated with the registration2. This shouldn't delete
1077   // the data associated with registration1.
1078   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1079             database->DeleteUserData(data2.registration_id, "key"));
1080   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1081             database->ReadUserData(
1082                 data1.registration_id, "key", &user_data_out));
1083   EXPECT_EQ("data1", user_data_out);
1084   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1085             database->ReadUserData(
1086                 data2.registration_id, "key", &user_data_out));
1087
1088   // And again get all registrations with user data.
1089   user_data_list.clear();
1090   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1091             database->ReadUserDataForAllRegistrations("key", &user_data_list));
1092   EXPECT_EQ(1u, user_data_list.size());
1093   EXPECT_EQ(data1.registration_id, user_data_list[0].first);
1094   EXPECT_EQ("data1", user_data_list[0].second);
1095 }
1096
1097 TEST(ServiceWorkerDatabaseTest, UserData_DeleteRegistration) {
1098   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1099   const GURL kOrigin("http://example.com");
1100
1101   // Add registration 1.
1102   RegistrationData data1;
1103   data1.registration_id = 100;
1104   data1.scope = URL(kOrigin, "/foo");
1105   data1.script = URL(kOrigin, "/script1.js");
1106   data1.version_id = 200;
1107   data1.resources_total_size_bytes = 100;
1108   std::vector<Resource> resources1;
1109   resources1.push_back(CreateResource(1, data1.script, 100));
1110
1111   // Add registration 2.
1112   RegistrationData data2;
1113   data2.registration_id = 101;
1114   data2.scope = URL(kOrigin, "/bar");
1115   data2.script = URL(kOrigin, "/script2.js");
1116   data2.version_id = 201;
1117   data2.resources_total_size_bytes = 200;
1118   std::vector<Resource> resources2;
1119   resources2.push_back(CreateResource(2, data2.script, 200));
1120
1121   ServiceWorkerDatabase::RegistrationData deleted_version;
1122   std::vector<int64> newly_purgeable_resources;
1123   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1124             database->WriteRegistration(data1, resources1, &deleted_version,
1125                                         &newly_purgeable_resources));
1126   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1127             database->WriteRegistration(data2, resources2, &deleted_version,
1128                                         &newly_purgeable_resources));
1129
1130   // Write user data associated with the registration1.
1131   std::string user_data_out;
1132   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1133             database->WriteUserData(
1134                 data1.registration_id, kOrigin, "key1", "data1"));
1135   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1136             database->WriteUserData(
1137                 data1.registration_id, kOrigin, "key2", "data2"));
1138   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1139             database->ReadUserData(
1140                 data1.registration_id, "key1", &user_data_out));
1141   ASSERT_EQ("data1", user_data_out);
1142   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1143             database->ReadUserData(
1144                 data1.registration_id, "key2", &user_data_out));
1145   ASSERT_EQ("data2", user_data_out);
1146
1147   // Write user data associated with the registration2.
1148   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1149             database->WriteUserData(
1150                 data2.registration_id, kOrigin, "key3", "data3"));
1151   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1152             database->ReadUserData(
1153                 data2.registration_id, "key3", &user_data_out));
1154   ASSERT_EQ("data3", user_data_out);
1155
1156   // Delete all data associated with the registration1. This shouldn't delete
1157   // the data associated with registration2.
1158   ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
1159             database->DeleteRegistration(
1160                 data1.registration_id, kOrigin,
1161                 &deleted_version, &newly_purgeable_resources));
1162   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1163             database->ReadUserData(
1164                 data1.registration_id, "key1", &user_data_out));
1165   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1166             database->ReadUserData(
1167                 data1.registration_id, "key2", &user_data_out));
1168   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1169             database->ReadUserData(
1170                 data2.registration_id, "key3", &user_data_out));
1171   EXPECT_EQ("data3", user_data_out);
1172 }
1173
1174 TEST(ServiceWorkerDatabaseTest, UserData_UninitializedDatabase) {
1175   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1176   const GURL kOrigin("http://example.com");
1177
1178   // Should be failed because the database does not exist.
1179   std::string user_data_out;
1180   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1181             database->ReadUserData(100, "key", &user_data_out));
1182
1183   // Should be failed because the associated registration does not exist.
1184   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1185             database->WriteUserData(100, kOrigin, "key", "data"));
1186
1187   // Deleting non-existent entry should succeed.
1188   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1189             database->DeleteUserData(100, "key"));
1190
1191   // Actually create a new database, but not initialized yet.
1192   database->LazyOpen(true);
1193
1194   // Should be failed because the database is not initialized.
1195   ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_);
1196   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1197             database->ReadUserData(100, "key", &user_data_out));
1198   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1199             database->WriteUserData(100, kOrigin, "key", "data"));
1200
1201   // Deleting non-existent entry should succeed.
1202   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1203             database->DeleteUserData(100, "key"));
1204 }
1205
1206 TEST(ServiceWorkerDatabaseTest, UpdateVersionToActive) {
1207   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1208   GURL origin("http://example.com");
1209
1210   ServiceWorkerDatabase::RegistrationData deleted_version;
1211   std::vector<int64> newly_purgeable_resources;
1212
1213   // Should be false because a registration does not exist.
1214   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1215             database->UpdateVersionToActive(0, origin));
1216
1217   // Add a registration.
1218   RegistrationData data;
1219   data.registration_id = 100;
1220   data.scope = URL(origin, "/foo");
1221   data.script = URL(origin, "/script.js");
1222   data.version_id = 200;
1223   data.is_active = false;
1224   data.resources_total_size_bytes = 100;
1225   std::vector<Resource> resources;
1226   resources.push_back(CreateResource(1, data.script, 100));
1227   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1228             database->WriteRegistration(data, resources, &deleted_version,
1229                                         &newly_purgeable_resources));
1230
1231   // Make sure that the registration is stored.
1232   RegistrationData data_out;
1233   std::vector<Resource> resources_out;
1234   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1235             database->ReadRegistration(
1236                 data.registration_id, origin, &data_out, &resources_out));
1237   VerifyRegistrationData(data, data_out);
1238   EXPECT_EQ(1u, resources_out.size());
1239
1240   // Activate the registration.
1241   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1242             database->UpdateVersionToActive(data.registration_id, origin));
1243
1244   // Make sure that the registration is activated.
1245   resources_out.clear();
1246   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1247             database->ReadRegistration(
1248                 data.registration_id, origin, &data_out, &resources_out));
1249   RegistrationData expected_data = data;
1250   expected_data.is_active = true;
1251   VerifyRegistrationData(expected_data, data_out);
1252   EXPECT_EQ(1u, resources_out.size());
1253
1254   // Delete the registration.
1255   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1256             database->DeleteRegistration(data.registration_id,
1257                                          origin,
1258                                          &deleted_version,
1259                                          &newly_purgeable_resources));
1260   EXPECT_EQ(data.registration_id, deleted_version.registration_id);
1261
1262   // Should be false because the registration is gone.
1263   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1264             database->UpdateVersionToActive(data.registration_id, origin));
1265 }
1266
1267 TEST(ServiceWorkerDatabaseTest, UpdateLastCheckTime) {
1268   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1269   GURL origin("http://example.com");
1270   ServiceWorkerDatabase::RegistrationData deleted_version;
1271   std::vector<int64> newly_purgeable_resources;
1272
1273   // Should be false because a registration does not exist.
1274   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1275             database->UpdateLastCheckTime(0, origin, base::Time::Now()));
1276
1277   // Add a registration.
1278   RegistrationData data;
1279   data.registration_id = 100;
1280   data.scope = URL(origin, "/foo");
1281   data.script = URL(origin, "/script.js");
1282   data.version_id = 200;
1283   data.last_update_check = base::Time::Now();
1284   data.resources_total_size_bytes = 100;
1285   std::vector<Resource> resources;
1286   resources.push_back(CreateResource(1, data.script, 100));
1287   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1288             database->WriteRegistration(data, resources, &deleted_version,
1289                                         &newly_purgeable_resources));
1290
1291   // Make sure that the registration is stored.
1292   RegistrationData data_out;
1293   std::vector<Resource> resources_out;
1294   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1295             database->ReadRegistration(
1296                 data.registration_id, origin, &data_out, &resources_out));
1297   VerifyRegistrationData(data, data_out);
1298   EXPECT_EQ(1u, resources_out.size());
1299
1300   // Update the last check time.
1301   base::Time updated_time = base::Time::Now();
1302   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1303             database->UpdateLastCheckTime(
1304                 data.registration_id, origin, updated_time));
1305
1306   // Make sure that the registration is updated.
1307   resources_out.clear();
1308   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1309             database->ReadRegistration(
1310                 data.registration_id, origin, &data_out, &resources_out));
1311   RegistrationData expected_data = data;
1312   expected_data.last_update_check = updated_time;
1313   VerifyRegistrationData(expected_data, data_out);
1314   EXPECT_EQ(1u, resources_out.size());
1315
1316   // Delete the registration.
1317   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1318             database->DeleteRegistration(data.registration_id,
1319                                          origin,
1320                                          &deleted_version,
1321                                          &newly_purgeable_resources));
1322   EXPECT_EQ(data.registration_id, deleted_version.registration_id);
1323
1324   // Should be false because the registration is gone.
1325   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1326             database->UpdateLastCheckTime(
1327                 data.registration_id, origin, base::Time::Now()));
1328 }
1329
1330 TEST(ServiceWorkerDatabaseTest, UncommittedResourceIds) {
1331   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1332
1333   // Write {1, 2, 3}.
1334   std::set<int64> ids1;
1335   ids1.insert(1);
1336   ids1.insert(2);
1337   ids1.insert(3);
1338   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1339             database->WriteUncommittedResourceIds(ids1));
1340
1341   std::set<int64> ids_out;
1342   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1343             database->GetUncommittedResourceIds(&ids_out));
1344   EXPECT_EQ(ids1, ids_out);
1345
1346   // Write {2, 4}.
1347   std::set<int64> ids2;
1348   ids2.insert(2);
1349   ids2.insert(4);
1350   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1351             database->WriteUncommittedResourceIds(ids2));
1352
1353   ids_out.clear();
1354   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1355             database->GetUncommittedResourceIds(&ids_out));
1356   std::set<int64> expected = base::STLSetUnion<std::set<int64> >(ids1, ids2);
1357   EXPECT_EQ(expected, ids_out);
1358
1359   // Delete {2, 3}.
1360   std::set<int64> ids3;
1361   ids3.insert(2);
1362   ids3.insert(3);
1363   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1364             database->ClearUncommittedResourceIds(ids3));
1365
1366   ids_out.clear();
1367   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1368             database->GetUncommittedResourceIds(&ids_out));
1369   expected = base::STLSetDifference<std::set<int64> >(expected, ids3);
1370   EXPECT_EQ(expected, ids_out);
1371 }
1372
1373 TEST(ServiceWorkerDatabaseTest, PurgeableResourceIds) {
1374   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1375
1376   // Write {1, 2, 3}.
1377   std::set<int64> ids1;
1378   ids1.insert(1);
1379   ids1.insert(2);
1380   ids1.insert(3);
1381   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1382             database->WritePurgeableResourceIds(ids1));
1383
1384   std::set<int64> ids_out;
1385   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1386             database->GetPurgeableResourceIds(&ids_out));
1387   EXPECT_EQ(ids1, ids_out);
1388
1389   // Write {2, 4}.
1390   std::set<int64> ids2;
1391   ids2.insert(2);
1392   ids2.insert(4);
1393   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1394             database->WritePurgeableResourceIds(ids2));
1395
1396   ids_out.clear();
1397   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1398             database->GetPurgeableResourceIds(&ids_out));
1399   std::set<int64> expected = base::STLSetUnion<std::set<int64> >(ids1, ids2);
1400   EXPECT_EQ(expected, ids_out);
1401
1402   // Delete {2, 3}.
1403   std::set<int64> ids3;
1404   ids3.insert(2);
1405   ids3.insert(3);
1406   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1407             database->ClearPurgeableResourceIds(ids3));
1408
1409   ids_out.clear();
1410   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1411             database->GetPurgeableResourceIds(&ids_out));
1412   expected = base::STLSetDifference<std::set<int64> >(expected, ids3);
1413   EXPECT_EQ(expected, ids_out);
1414 }
1415
1416 TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
1417   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
1418   ServiceWorkerDatabase::RegistrationData deleted_version;
1419   std::vector<int64> newly_purgeable_resources;
1420
1421   // Data associated with |origin1| will be removed.
1422   GURL origin1("http://example.com");
1423   GURL origin2("http://example.org");
1424
1425   // |origin1| has two registrations (registration1 and registration2).
1426   RegistrationData data1;
1427   data1.registration_id = 10;
1428   data1.scope = URL(origin1, "/foo");
1429   data1.script = URL(origin1, "/script1.js");
1430   data1.version_id = 100;
1431   data1.resources_total_size_bytes = 2013 + 512;
1432
1433   std::vector<Resource> resources1;
1434   resources1.push_back(CreateResource(1, URL(origin1, "/resource1"), 2013));
1435   resources1.push_back(CreateResource(2, URL(origin1, "/resource2"), 512));
1436   ASSERT_EQ(
1437       ServiceWorkerDatabase::STATUS_OK,
1438       database->WriteRegistration(
1439           data1, resources1, &deleted_version, &newly_purgeable_resources));
1440   ASSERT_EQ(
1441       ServiceWorkerDatabase::STATUS_OK,
1442       database->WriteUserData(
1443           data1.registration_id, origin1, "key1", "data1"));
1444   ASSERT_EQ(
1445       ServiceWorkerDatabase::STATUS_OK,
1446       database->WriteUserData(
1447           data1.registration_id, origin1, "key2", "data2"));
1448
1449   RegistrationData data2;
1450   data2.registration_id = 11;
1451   data2.scope = URL(origin1, "/bar");
1452   data2.script = URL(origin1, "/script2.js");
1453   data2.version_id = 101;
1454   data2.resources_total_size_bytes = 4 + 5;
1455
1456   std::vector<Resource> resources2;
1457   resources2.push_back(CreateResource(3, URL(origin1, "/resource3"), 4));
1458   resources2.push_back(CreateResource(4, URL(origin1, "/resource4"), 5));
1459   ASSERT_EQ(
1460       ServiceWorkerDatabase::STATUS_OK,
1461       database->WriteRegistration(
1462           data2, resources2, &deleted_version, &newly_purgeable_resources));
1463   ASSERT_EQ(
1464       ServiceWorkerDatabase::STATUS_OK,
1465       database->WriteUserData(
1466           data2.registration_id, origin1, "key3", "data3"));
1467   ASSERT_EQ(
1468       ServiceWorkerDatabase::STATUS_OK,
1469       database->WriteUserData(
1470           data2.registration_id, origin1, "key4", "data4"));
1471
1472   // |origin2| has one registration (registration3).
1473   RegistrationData data3;
1474   data3.registration_id = 12;
1475   data3.scope = URL(origin2, "/hoge");
1476   data3.script = URL(origin2, "/script3.js");
1477   data3.version_id = 102;
1478   data3.resources_total_size_bytes = 6 + 7;
1479
1480   std::vector<Resource> resources3;
1481   resources3.push_back(CreateResource(5, URL(origin2, "/resource5"), 6));
1482   resources3.push_back(CreateResource(6, URL(origin2, "/resource6"), 7));
1483   ASSERT_EQ(
1484       ServiceWorkerDatabase::STATUS_OK,
1485       database->WriteRegistration(
1486           data3, resources3, &deleted_version, &newly_purgeable_resources));
1487   ASSERT_EQ(
1488       ServiceWorkerDatabase::STATUS_OK,
1489       database->WriteUserData(
1490           data3.registration_id, origin2, "key5", "data5"));
1491   ASSERT_EQ(
1492       ServiceWorkerDatabase::STATUS_OK,
1493       database->WriteUserData(
1494           data3.registration_id, origin2, "key6", "data6"));
1495
1496   std::set<GURL> origins_to_delete;
1497   origins_to_delete.insert(origin1);
1498   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1499             database->DeleteAllDataForOrigins(origins_to_delete,
1500                                               &newly_purgeable_resources));
1501
1502   // |origin1| should be removed from the unique origin list.
1503   std::set<GURL> unique_origins;
1504   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1505             database->GetOriginsWithRegistrations(&unique_origins));
1506   EXPECT_EQ(1u, unique_origins.size());
1507   EXPECT_TRUE(ContainsKey(unique_origins, origin2));
1508
1509   // The registrations for |origin1| should be removed.
1510   std::vector<RegistrationData> registrations;
1511   EXPECT_EQ(
1512       ServiceWorkerDatabase::STATUS_OK,
1513       database->GetRegistrationsForOrigin(origin1, &registrations, nullptr));
1514   EXPECT_TRUE(registrations.empty());
1515   GURL origin_out;
1516   EXPECT_EQ(
1517       ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1518       database->ReadRegistrationOrigin(data1.registration_id, &origin_out));
1519
1520   // The registration for |origin2| should not be removed.
1521   RegistrationData data_out;
1522   std::vector<Resource> resources_out;
1523   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
1524       data3.registration_id, origin2, &data_out, &resources_out));
1525   VerifyRegistrationData(data3, data_out);
1526   VerifyResourceRecords(resources3, resources_out);
1527   EXPECT_EQ(
1528       ServiceWorkerDatabase::STATUS_OK,
1529       database->ReadRegistrationOrigin(data3.registration_id, &origin_out));
1530   EXPECT_EQ(origin2, origin_out);
1531
1532   // The resources associated with |origin1| should be purgeable.
1533   std::set<int64> purgeable_ids_out;
1534   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1535             database->GetPurgeableResourceIds(&purgeable_ids_out));
1536   EXPECT_EQ(4u, purgeable_ids_out.size());
1537   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 1));
1538   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 2));
1539   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 3));
1540   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 4));
1541
1542   // The user data associated with |origin1| should be removed.
1543   std::string user_data_out;
1544   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1545             database->ReadUserData(
1546                 data1.registration_id, "key1", &user_data_out));
1547   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1548             database->ReadUserData(
1549                 data1.registration_id, "key2", &user_data_out));
1550   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1551             database->ReadUserData(
1552                 data2.registration_id, "key3", &user_data_out));
1553   EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
1554             database->ReadUserData(
1555                 data2.registration_id, "key4", &user_data_out));
1556
1557   // The user data associated with |origin2| should not be removed.
1558   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1559             database->ReadUserData(
1560                 data3.registration_id, "key5", &user_data_out));
1561   EXPECT_EQ("data5", user_data_out);
1562   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1563             database->ReadUserData(
1564                 data3.registration_id, "key6", &user_data_out));
1565   EXPECT_EQ("data6", user_data_out);
1566 }
1567
1568 TEST(ServiceWorkerDatabaseTest, DestroyDatabase) {
1569   base::ScopedTempDir database_dir;
1570   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
1571   scoped_ptr<ServiceWorkerDatabase> database(
1572       CreateDatabase(database_dir.path()));
1573
1574   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
1575   ASSERT_TRUE(base::DirectoryExists(database_dir.path()));
1576
1577   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase());
1578   ASSERT_FALSE(base::DirectoryExists(database_dir.path()));
1579 }
1580
1581 }  // namespace content