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