OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/service_worker/service_worker_database.h" | 5 #include "content/browser/service_worker/service_worker_database.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/files/file_util.h" | 9 #include "base/files/file_util.h" |
10 #include "base/files/scoped_temp_dir.h" | 10 #include "base/files/scoped_temp_dir.h" |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 | 50 |
51 ServiceWorkerDatabase* CreateDatabaseInMemory() { | 51 ServiceWorkerDatabase* CreateDatabaseInMemory() { |
52 return new ServiceWorkerDatabase(base::FilePath()); | 52 return new ServiceWorkerDatabase(base::FilePath()); |
53 } | 53 } |
54 | 54 |
55 void VerifyRegistrationData(const RegistrationData& expected, | 55 void VerifyRegistrationData(const RegistrationData& expected, |
56 const RegistrationData& actual) { | 56 const RegistrationData& actual) { |
57 EXPECT_EQ(expected.registration_id, actual.registration_id); | 57 EXPECT_EQ(expected.registration_id, actual.registration_id); |
58 EXPECT_EQ(expected.scope, actual.scope); | 58 EXPECT_EQ(expected.scope, actual.scope); |
59 EXPECT_EQ(expected.script, actual.script); | 59 EXPECT_EQ(expected.script, actual.script); |
60 EXPECT_EQ(expected.version_id, actual.version_id); | 60 EXPECT_EQ(expected.version_uuid, actual.version_uuid); |
61 EXPECT_EQ(expected.is_active, actual.is_active); | 61 EXPECT_EQ(expected.is_active, actual.is_active); |
62 EXPECT_EQ(expected.has_fetch_handler, actual.has_fetch_handler); | 62 EXPECT_EQ(expected.has_fetch_handler, actual.has_fetch_handler); |
63 EXPECT_EQ(expected.last_update_check, actual.last_update_check); | 63 EXPECT_EQ(expected.last_update_check, actual.last_update_check); |
64 EXPECT_EQ(expected.resources_total_size_bytes, | 64 EXPECT_EQ(expected.resources_total_size_bytes, |
65 actual.resources_total_size_bytes); | 65 actual.resources_total_size_bytes); |
66 } | 66 } |
67 | 67 |
68 void VerifyResourceRecords(const std::vector<Resource>& expected, | 68 void VerifyResourceRecords(const std::vector<Resource>& expected, |
69 const std::vector<Resource>& actual) { | 69 const std::vector<Resource>& actual) { |
70 ASSERT_EQ(expected.size(), actual.size()); | 70 ASSERT_EQ(expected.size(), actual.size()); |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
156 | 156 |
157 // Simulate an existing database created before diskcache migration. | 157 // Simulate an existing database created before diskcache migration. |
158 database->set_skip_writing_diskcache_migration_state_on_init_for_testing(); | 158 database->set_skip_writing_diskcache_migration_state_on_init_for_testing(); |
159 std::vector<ServiceWorkerDatabase::ResourceRecord> resources; | 159 std::vector<ServiceWorkerDatabase::ResourceRecord> resources; |
160 ServiceWorkerDatabase::RegistrationData deleted_version; | 160 ServiceWorkerDatabase::RegistrationData deleted_version; |
161 std::vector<int64> newly_purgeable_resources; | 161 std::vector<int64> newly_purgeable_resources; |
162 ServiceWorkerDatabase::RegistrationData data; | 162 ServiceWorkerDatabase::RegistrationData data; |
163 data.registration_id = 100; | 163 data.registration_id = 100; |
164 data.scope = URL(origin, "/foo"); | 164 data.scope = URL(origin, "/foo"); |
165 data.script = URL(origin, "/script.js"); | 165 data.script = URL(origin, "/script.js"); |
166 data.version_id = 200; | 166 data.version_uuid = "1b304e16-1464-4a75-855a-4e4e62baac81"; |
167 data.resources_total_size_bytes = 300; | 167 data.resources_total_size_bytes = 300; |
168 resources.push_back(CreateResource(1, data.script, 300)); | 168 resources.push_back(CreateResource(1, data.script, 300)); |
169 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 169 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
170 database->WriteRegistration(data, resources, &deleted_version, | 170 database->WriteRegistration(data, resources, &deleted_version, |
171 &newly_purgeable_resources)); | 171 &newly_purgeable_resources)); |
172 migration_needed = false; | 172 migration_needed = false; |
173 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 173 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
174 database->IsDiskCacheMigrationNeeded(&migration_needed)); | 174 database->IsDiskCacheMigrationNeeded(&migration_needed)); |
175 ASSERT_TRUE(migration_needed); | 175 ASSERT_TRUE(migration_needed); |
176 deletion_needed = false; | 176 deletion_needed = false; |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
215 GURL origin("http://example.com"); | 215 GURL origin("http://example.com"); |
216 | 216 |
217 // Add a registration to the database. | 217 // Add a registration to the database. |
218 std::vector<ServiceWorkerDatabase::ResourceRecord> resources; | 218 std::vector<ServiceWorkerDatabase::ResourceRecord> resources; |
219 ServiceWorkerDatabase::RegistrationData deleted_version; | 219 ServiceWorkerDatabase::RegistrationData deleted_version; |
220 std::vector<int64> newly_purgeable_resources; | 220 std::vector<int64> newly_purgeable_resources; |
221 ServiceWorkerDatabase::RegistrationData data; | 221 ServiceWorkerDatabase::RegistrationData data; |
222 data.registration_id = 100; | 222 data.registration_id = 100; |
223 data.scope = URL(origin, "/foo"); | 223 data.scope = URL(origin, "/foo"); |
224 data.script = URL(origin, "/script1.js"); | 224 data.script = URL(origin, "/script1.js"); |
225 data.version_id = 200; | 225 data.version_uuid = "1b304e16-1464-4a75-855a-4e4e62baac81"; |
226 data.resources_total_size_bytes = 300; | 226 data.resources_total_size_bytes = 300; |
227 resources.push_back(CreateResource(1, data.script, 300)); | 227 resources.push_back(CreateResource(1, data.script, 300)); |
228 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 228 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
229 database->WriteRegistration(data, resources, &deleted_version, | 229 database->WriteRegistration(data, resources, &deleted_version, |
230 &newly_purgeable_resources)); | 230 &newly_purgeable_resources)); |
231 | 231 |
232 // Sanity check on current version. | 232 // Sanity check on current version. |
233 int64 db_version = -1; | 233 int64 db_version = -1; |
234 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 234 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
235 database->ReadDatabaseVersion(&db_version)); | 235 database->ReadDatabaseVersion(&db_version)); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
267 TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) { | 267 TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) { |
268 base::ScopedTempDir database_dir; | 268 base::ScopedTempDir database_dir; |
269 ASSERT_TRUE(database_dir.CreateUniqueTempDir()); | 269 ASSERT_TRUE(database_dir.CreateUniqueTempDir()); |
270 scoped_ptr<ServiceWorkerDatabase> database( | 270 scoped_ptr<ServiceWorkerDatabase> database( |
271 CreateDatabase(database_dir.path())); | 271 CreateDatabase(database_dir.path())); |
272 | 272 |
273 GURL origin("http://example.com"); | 273 GURL origin("http://example.com"); |
274 | 274 |
275 // The database has never been used, so returns initial values. | 275 // The database has never been used, so returns initial values. |
276 AvailableIds ids; | 276 AvailableIds ids; |
277 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds( | 277 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
278 &ids.reg_id, &ids.ver_id, &ids.res_id)); | 278 database->GetNextAvailableIds(&ids.reg_id, &ids.res_id)); |
279 EXPECT_EQ(0, ids.reg_id); | 279 EXPECT_EQ(0, ids.reg_id); |
280 EXPECT_EQ(0, ids.ver_id); | |
281 EXPECT_EQ(0, ids.res_id); | 280 EXPECT_EQ(0, ids.res_id); |
282 | 281 |
283 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true)); | 282 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true)); |
284 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds( | 283 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
285 &ids.reg_id, &ids.ver_id, &ids.res_id)); | 284 database->GetNextAvailableIds(&ids.reg_id, &ids.res_id)); |
286 EXPECT_EQ(0, ids.reg_id); | 285 EXPECT_EQ(0, ids.reg_id); |
287 EXPECT_EQ(0, ids.ver_id); | |
288 EXPECT_EQ(0, ids.res_id); | 286 EXPECT_EQ(0, ids.res_id); |
289 | 287 |
290 // Writing a registration bumps the next available ids. | 288 // Writing a registration bumps the next available ids. |
291 std::vector<Resource> resources1; | 289 std::vector<Resource> resources1; |
292 RegistrationData data1; | 290 RegistrationData data1; |
293 ServiceWorkerDatabase::RegistrationData deleted_version; | 291 ServiceWorkerDatabase::RegistrationData deleted_version; |
294 std::vector<int64> newly_purgeable_resources; | 292 std::vector<int64> newly_purgeable_resources; |
295 data1.registration_id = 100; | 293 data1.registration_id = 100; |
296 data1.scope = URL(origin, "/foo"); | 294 data1.scope = URL(origin, "/foo"); |
297 data1.script = URL(origin, "/script1.js"); | 295 data1.script = URL(origin, "/script1.js"); |
298 data1.version_id = 200; | 296 data1.version_uuid = "1b304e16-1464-4a75-855a-4e4e62baac81"; |
299 data1.resources_total_size_bytes = 300; | 297 data1.resources_total_size_bytes = 300; |
300 resources1.push_back(CreateResource(1, data1.script, 300)); | 298 resources1.push_back(CreateResource(1, data1.script, 300)); |
301 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 299 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
302 database->WriteRegistration(data1, resources1, &deleted_version, | 300 database->WriteRegistration(data1, resources1, &deleted_version, |
303 &newly_purgeable_resources)); | 301 &newly_purgeable_resources)); |
304 | 302 |
305 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds( | 303 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
306 &ids.reg_id, &ids.ver_id, &ids.res_id)); | 304 database->GetNextAvailableIds(&ids.reg_id, &ids.res_id)); |
307 EXPECT_EQ(101, ids.reg_id); | 305 EXPECT_EQ(101, ids.reg_id); |
308 EXPECT_EQ(201, ids.ver_id); | |
309 EXPECT_EQ(0, ids.res_id); | 306 EXPECT_EQ(0, ids.res_id); |
310 | 307 |
311 // Writing uncommitted resources bumps the next available id. | 308 // Writing uncommitted resources bumps the next available id. |
312 const int64 kUncommittedIds[] = {0, 1, 3, 5, 6, 10}; | 309 const int64 kUncommittedIds[] = {0, 1, 3, 5, 6, 10}; |
313 EXPECT_EQ( | 310 EXPECT_EQ( |
314 ServiceWorkerDatabase::STATUS_OK, | 311 ServiceWorkerDatabase::STATUS_OK, |
315 database->WriteUncommittedResourceIds(std::set<int64>( | 312 database->WriteUncommittedResourceIds(std::set<int64>( |
316 kUncommittedIds, kUncommittedIds + arraysize(kUncommittedIds)))); | 313 kUncommittedIds, kUncommittedIds + arraysize(kUncommittedIds)))); |
317 EXPECT_EQ( | 314 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
318 ServiceWorkerDatabase::STATUS_OK, | 315 database->GetNextAvailableIds(&ids.reg_id, &ids.res_id)); |
319 database->GetNextAvailableIds(&ids.reg_id, &ids.ver_id, &ids.res_id)); | |
320 EXPECT_EQ(101, ids.reg_id); | 316 EXPECT_EQ(101, ids.reg_id); |
321 EXPECT_EQ(201, ids.ver_id); | |
322 EXPECT_EQ(11, ids.res_id); | 317 EXPECT_EQ(11, ids.res_id); |
323 | 318 |
324 // Writing purgeable resources bumps the next available id. | 319 // Writing purgeable resources bumps the next available id. |
325 const int64 kPurgeableIds[] = {4, 12, 16, 17, 20}; | 320 const int64 kPurgeableIds[] = {4, 12, 16, 17, 20}; |
326 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 321 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
327 database->WriteUncommittedResourceIds(std::set<int64>( | 322 database->WriteUncommittedResourceIds(std::set<int64>( |
328 kPurgeableIds, kPurgeableIds + arraysize(kPurgeableIds)))); | 323 kPurgeableIds, kPurgeableIds + arraysize(kPurgeableIds)))); |
329 EXPECT_EQ( | 324 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
330 ServiceWorkerDatabase::STATUS_OK, | 325 database->GetNextAvailableIds(&ids.reg_id, &ids.res_id)); |
331 database->GetNextAvailableIds(&ids.reg_id, &ids.ver_id, &ids.res_id)); | |
332 EXPECT_EQ(101, ids.reg_id); | 326 EXPECT_EQ(101, ids.reg_id); |
333 EXPECT_EQ(201, ids.ver_id); | |
334 EXPECT_EQ(21, ids.res_id); | 327 EXPECT_EQ(21, ids.res_id); |
335 | 328 |
336 // Writing a registration whose ids are lower than the stored ones should not | 329 // Writing a registration whose ids are lower than the stored ones should not |
337 // bump the next available ids. | 330 // bump the next available ids. |
338 RegistrationData data2; | 331 RegistrationData data2; |
339 data2.registration_id = 10; | 332 data2.registration_id = 10; |
340 data2.scope = URL(origin, "/bar"); | 333 data2.scope = URL(origin, "/bar"); |
341 data2.script = URL(origin, "/script2.js"); | 334 data2.script = URL(origin, "/script2.js"); |
342 data2.version_id = 20; | 335 data2.version_uuid = "a616c852-7fc0-46c4-9f6e-0f6f2cb4aa4c"; |
343 data2.resources_total_size_bytes = 400; | 336 data2.resources_total_size_bytes = 400; |
344 std::vector<Resource> resources2; | 337 std::vector<Resource> resources2; |
345 resources2.push_back(CreateResource(2, data2.script, 400)); | 338 resources2.push_back(CreateResource(2, data2.script, 400)); |
346 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 339 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
347 database->WriteRegistration(data2, resources2, &deleted_version, | 340 database->WriteRegistration(data2, resources2, &deleted_version, |
348 &newly_purgeable_resources)); | 341 &newly_purgeable_resources)); |
349 | 342 |
350 // Same with resources. | 343 // Same with resources. |
351 int64 kLowResourceId = 15; | 344 int64 kLowResourceId = 15; |
352 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 345 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
353 database->WriteUncommittedResourceIds( | 346 database->WriteUncommittedResourceIds( |
354 std::set<int64>(&kLowResourceId, &kLowResourceId + 1))); | 347 std::set<int64>(&kLowResourceId, &kLowResourceId + 1))); |
355 | 348 |
356 // Close and reopen the database to verify the stored values. | 349 // Close and reopen the database to verify the stored values. |
357 database.reset(CreateDatabase(database_dir.path())); | 350 database.reset(CreateDatabase(database_dir.path())); |
358 | 351 |
359 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds( | 352 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
360 &ids.reg_id, &ids.ver_id, &ids.res_id)); | 353 database->GetNextAvailableIds(&ids.reg_id, &ids.res_id)); |
361 EXPECT_EQ(101, ids.reg_id); | 354 EXPECT_EQ(101, ids.reg_id); |
362 EXPECT_EQ(201, ids.ver_id); | |
363 EXPECT_EQ(21, ids.res_id); | 355 EXPECT_EQ(21, ids.res_id); |
364 } | 356 } |
365 | 357 |
366 TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) { | 358 TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) { |
367 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); | 359 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); |
368 | 360 |
369 std::set<GURL> origins; | 361 std::set<GURL> origins; |
370 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 362 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
371 database->GetOriginsWithRegistrations(&origins)); | 363 database->GetOriginsWithRegistrations(&origins)); |
372 EXPECT_TRUE(origins.empty()); | 364 EXPECT_TRUE(origins.empty()); |
373 | 365 |
374 ServiceWorkerDatabase::RegistrationData deleted_version; | 366 ServiceWorkerDatabase::RegistrationData deleted_version; |
375 std::vector<int64> newly_purgeable_resources; | 367 std::vector<int64> newly_purgeable_resources; |
376 | 368 |
377 GURL origin1("http://example.com"); | 369 GURL origin1("http://example.com"); |
378 RegistrationData data1; | 370 RegistrationData data1; |
379 data1.registration_id = 123; | 371 data1.registration_id = 123; |
380 data1.scope = URL(origin1, "/foo"); | 372 data1.scope = URL(origin1, "/foo"); |
381 data1.script = URL(origin1, "/script1.js"); | 373 data1.script = URL(origin1, "/script1.js"); |
382 data1.version_id = 456; | 374 data1.version_uuid = "0ab2638a-2005-411e-aa89-76e14892b618"; |
383 data1.resources_total_size_bytes = 100; | 375 data1.resources_total_size_bytes = 100; |
384 std::vector<Resource> resources1; | 376 std::vector<Resource> resources1; |
385 resources1.push_back(CreateResource(1, data1.script, 100)); | 377 resources1.push_back(CreateResource(1, data1.script, 100)); |
386 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 378 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
387 database->WriteRegistration(data1, resources1, &deleted_version, | 379 database->WriteRegistration(data1, resources1, &deleted_version, |
388 &newly_purgeable_resources)); | 380 &newly_purgeable_resources)); |
389 | 381 |
390 GURL origin2("https://www.example.com"); | 382 GURL origin2("https://www.example.com"); |
391 RegistrationData data2; | 383 RegistrationData data2; |
392 data2.registration_id = 234; | 384 data2.registration_id = 234; |
393 data2.scope = URL(origin2, "/bar"); | 385 data2.scope = URL(origin2, "/bar"); |
394 data2.script = URL(origin2, "/script2.js"); | 386 data2.script = URL(origin2, "/script2.js"); |
395 data2.version_id = 567; | 387 data2.version_uuid = "0acb271b-b4eb-4323-b049-6db3d1571c43"; |
396 data2.resources_total_size_bytes = 200; | 388 data2.resources_total_size_bytes = 200; |
397 std::vector<Resource> resources2; | 389 std::vector<Resource> resources2; |
398 resources2.push_back(CreateResource(2, data2.script, 200)); | 390 resources2.push_back(CreateResource(2, data2.script, 200)); |
399 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 391 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
400 database->WriteRegistration(data2, resources2, &deleted_version, | 392 database->WriteRegistration(data2, resources2, &deleted_version, |
401 &newly_purgeable_resources)); | 393 &newly_purgeable_resources)); |
402 | 394 |
403 GURL origin3("https://example.org"); | 395 GURL origin3("https://example.org"); |
404 RegistrationData data3; | 396 RegistrationData data3; |
405 data3.registration_id = 345; | 397 data3.registration_id = 345; |
406 data3.scope = URL(origin3, "/hoge"); | 398 data3.scope = URL(origin3, "/hoge"); |
407 data3.script = URL(origin3, "/script3.js"); | 399 data3.script = URL(origin3, "/script3.js"); |
408 data3.version_id = 678; | 400 data3.version_uuid = "de8cc4f5-3f3b-4f60-b4f5-d4ddc1cb5e69"; |
409 data3.resources_total_size_bytes = 300; | 401 data3.resources_total_size_bytes = 300; |
410 std::vector<Resource> resources3; | 402 std::vector<Resource> resources3; |
411 resources3.push_back(CreateResource(3, data3.script, 300)); | 403 resources3.push_back(CreateResource(3, data3.script, 300)); |
412 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 404 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
413 database->WriteRegistration(data3, resources3, &deleted_version, | 405 database->WriteRegistration(data3, resources3, &deleted_version, |
414 &newly_purgeable_resources)); | 406 &newly_purgeable_resources)); |
415 | 407 |
416 // |origin3| has two registrations. | 408 // |origin3| has two registrations. |
417 RegistrationData data4; | 409 RegistrationData data4; |
418 data4.registration_id = 456; | 410 data4.registration_id = 456; |
419 data4.scope = URL(origin3, "/fuga"); | 411 data4.scope = URL(origin3, "/fuga"); |
420 data4.script = URL(origin3, "/script4.js"); | 412 data4.script = URL(origin3, "/script4.js"); |
421 data4.version_id = 789; | 413 data4.version_uuid = "fe7fcca9-904b-4e45-85e2-2414c4424f18"; |
422 data4.resources_total_size_bytes = 400; | 414 data4.resources_total_size_bytes = 400; |
423 std::vector<Resource> resources4; | 415 std::vector<Resource> resources4; |
424 resources4.push_back(CreateResource(4, data4.script, 400)); | 416 resources4.push_back(CreateResource(4, data4.script, 400)); |
425 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 417 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
426 database->WriteRegistration(data4, resources4, &deleted_version, | 418 database->WriteRegistration(data4, resources4, &deleted_version, |
427 &newly_purgeable_resources)); | 419 &newly_purgeable_resources)); |
428 | 420 |
429 origins.clear(); | 421 origins.clear(); |
430 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 422 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
431 database->GetOriginsWithRegistrations(&origins)); | 423 database->GetOriginsWithRegistrations(&origins)); |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
482 EXPECT_TRUE(registrations.empty()); | 474 EXPECT_TRUE(registrations.empty()); |
483 EXPECT_TRUE(resources_list.empty()); | 475 EXPECT_TRUE(resources_list.empty()); |
484 | 476 |
485 ServiceWorkerDatabase::RegistrationData deleted_version; | 477 ServiceWorkerDatabase::RegistrationData deleted_version; |
486 std::vector<int64> newly_purgeable_resources; | 478 std::vector<int64> newly_purgeable_resources; |
487 | 479 |
488 RegistrationData data1; | 480 RegistrationData data1; |
489 data1.registration_id = 100; | 481 data1.registration_id = 100; |
490 data1.scope = URL(origin1, "/foo"); | 482 data1.scope = URL(origin1, "/foo"); |
491 data1.script = URL(origin1, "/script1.js"); | 483 data1.script = URL(origin1, "/script1.js"); |
492 data1.version_id = 1000; | 484 data1.version_uuid = "5e837d34-3ad6-4043-bcea-41bc02ec203e"; |
493 data1.resources_total_size_bytes = 100; | 485 data1.resources_total_size_bytes = 100; |
494 std::vector<Resource> resources1; | 486 std::vector<Resource> resources1; |
495 resources1.push_back(CreateResource(1, data1.script, 100)); | 487 resources1.push_back(CreateResource(1, data1.script, 100)); |
496 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 488 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
497 database->WriteRegistration(data1, resources1, &deleted_version, | 489 database->WriteRegistration(data1, resources1, &deleted_version, |
498 &newly_purgeable_resources)); | 490 &newly_purgeable_resources)); |
499 | 491 |
500 registrations.clear(); | 492 registrations.clear(); |
501 resources_list.clear(); | 493 resources_list.clear(); |
502 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 494 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
503 database->GetRegistrationsForOrigin(origin1, ®istrations, | 495 database->GetRegistrationsForOrigin(origin1, ®istrations, |
504 &resources_list)); | 496 &resources_list)); |
505 EXPECT_EQ(1U, registrations.size()); | 497 EXPECT_EQ(1U, registrations.size()); |
506 VerifyRegistrationData(data1, registrations[0]); | 498 VerifyRegistrationData(data1, registrations[0]); |
507 EXPECT_EQ(1U, resources_list.size()); | 499 EXPECT_EQ(1U, resources_list.size()); |
508 VerifyResourceRecords(resources1, resources_list[0]); | 500 VerifyResourceRecords(resources1, resources_list[0]); |
509 | 501 |
510 RegistrationData data2; | 502 RegistrationData data2; |
511 data2.registration_id = 200; | 503 data2.registration_id = 200; |
512 data2.scope = URL(origin2, "/bar"); | 504 data2.scope = URL(origin2, "/bar"); |
513 data2.script = URL(origin2, "/script2.js"); | 505 data2.script = URL(origin2, "/script2.js"); |
514 data2.version_id = 2000; | 506 data2.version_uuid = "9bb6c620-8ea3-4b17-9654-e0346a8fc2ce"; |
515 data2.resources_total_size_bytes = 200; | 507 data2.resources_total_size_bytes = 200; |
516 std::vector<Resource> resources2; | 508 std::vector<Resource> resources2; |
517 resources2.push_back(CreateResource(2, data2.script, 200)); | 509 resources2.push_back(CreateResource(2, data2.script, 200)); |
518 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 510 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
519 database->WriteRegistration(data2, resources2, &deleted_version, | 511 database->WriteRegistration(data2, resources2, &deleted_version, |
520 &newly_purgeable_resources)); | 512 &newly_purgeable_resources)); |
521 | 513 |
522 registrations.clear(); | 514 registrations.clear(); |
523 resources_list.clear(); | 515 resources_list.clear(); |
524 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 516 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
525 database->GetRegistrationsForOrigin(origin2, ®istrations, | 517 database->GetRegistrationsForOrigin(origin2, ®istrations, |
526 &resources_list)); | 518 &resources_list)); |
527 EXPECT_EQ(1U, registrations.size()); | 519 EXPECT_EQ(1U, registrations.size()); |
528 VerifyRegistrationData(data2, registrations[0]); | 520 VerifyRegistrationData(data2, registrations[0]); |
529 EXPECT_EQ(1U, resources_list.size()); | 521 EXPECT_EQ(1U, resources_list.size()); |
530 VerifyResourceRecords(resources2, resources_list[0]); | 522 VerifyResourceRecords(resources2, resources_list[0]); |
531 | 523 |
532 RegistrationData data3; | 524 RegistrationData data3; |
533 data3.registration_id = 300; | 525 data3.registration_id = 300; |
534 data3.scope = URL(origin3, "/hoge"); | 526 data3.scope = URL(origin3, "/hoge"); |
535 data3.script = URL(origin3, "/script3.js"); | 527 data3.script = URL(origin3, "/script3.js"); |
536 data3.version_id = 3000; | 528 data3.version_uuid = "afa0e540-8432-491e-af58-9461850477dd"; |
537 data3.resources_total_size_bytes = 300; | 529 data3.resources_total_size_bytes = 300; |
538 std::vector<Resource> resources3; | 530 std::vector<Resource> resources3; |
539 resources3.push_back(CreateResource(3, data3.script, 300)); | 531 resources3.push_back(CreateResource(3, data3.script, 300)); |
540 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 532 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
541 database->WriteRegistration(data3, resources3, &deleted_version, | 533 database->WriteRegistration(data3, resources3, &deleted_version, |
542 &newly_purgeable_resources)); | 534 &newly_purgeable_resources)); |
543 | 535 |
544 // |origin3| has two registrations. | 536 // |origin3| has two registrations. |
545 RegistrationData data4; | 537 RegistrationData data4; |
546 data4.registration_id = 400; | 538 data4.registration_id = 400; |
547 data4.scope = URL(origin3, "/fuga"); | 539 data4.scope = URL(origin3, "/fuga"); |
548 data4.script = URL(origin3, "/script4.js"); | 540 data4.script = URL(origin3, "/script4.js"); |
549 data4.version_id = 4000; | 541 data4.version_uuid = "142b546d-5b7c-4932-89b9-efca171bd28f"; |
550 data4.resources_total_size_bytes = 400; | 542 data4.resources_total_size_bytes = 400; |
551 std::vector<Resource> resources4; | 543 std::vector<Resource> resources4; |
552 resources4.push_back(CreateResource(4, data4.script, 400)); | 544 resources4.push_back(CreateResource(4, data4.script, 400)); |
553 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 545 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
554 database->WriteRegistration(data4, resources4, &deleted_version, | 546 database->WriteRegistration(data4, resources4, &deleted_version, |
555 &newly_purgeable_resources)); | 547 &newly_purgeable_resources)); |
556 | 548 |
557 registrations.clear(); | 549 registrations.clear(); |
558 resources_list.clear(); | 550 resources_list.clear(); |
559 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 551 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
(...skipping 25 matching lines...) Expand all Loading... |
585 EXPECT_TRUE(registrations.empty()); | 577 EXPECT_TRUE(registrations.empty()); |
586 | 578 |
587 ServiceWorkerDatabase::RegistrationData deleted_version; | 579 ServiceWorkerDatabase::RegistrationData deleted_version; |
588 std::vector<int64> newly_purgeable_resources; | 580 std::vector<int64> newly_purgeable_resources; |
589 | 581 |
590 GURL origin1("http://www1.example.com"); | 582 GURL origin1("http://www1.example.com"); |
591 RegistrationData data1; | 583 RegistrationData data1; |
592 data1.registration_id = 100; | 584 data1.registration_id = 100; |
593 data1.scope = URL(origin1, "/foo"); | 585 data1.scope = URL(origin1, "/foo"); |
594 data1.script = URL(origin1, "/script1.js"); | 586 data1.script = URL(origin1, "/script1.js"); |
595 data1.version_id = 1000; | 587 data1.version_uuid = "5e837d34-3ad6-4043-bcea-41bc02ec203e"; |
596 data1.resources_total_size_bytes = 100; | 588 data1.resources_total_size_bytes = 100; |
597 std::vector<Resource> resources1; | 589 std::vector<Resource> resources1; |
598 resources1.push_back(CreateResource(1, data1.script, 100)); | 590 resources1.push_back(CreateResource(1, data1.script, 100)); |
599 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 591 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
600 database->WriteRegistration(data1, resources1, &deleted_version, | 592 database->WriteRegistration(data1, resources1, &deleted_version, |
601 &newly_purgeable_resources)); | 593 &newly_purgeable_resources)); |
602 | 594 |
603 GURL origin2("http://www2.example.com"); | 595 GURL origin2("http://www2.example.com"); |
604 RegistrationData data2; | 596 RegistrationData data2; |
605 data2.registration_id = 200; | 597 data2.registration_id = 200; |
606 data2.scope = URL(origin2, "/bar"); | 598 data2.scope = URL(origin2, "/bar"); |
607 data2.script = URL(origin2, "/script2.js"); | 599 data2.script = URL(origin2, "/script2.js"); |
608 data2.version_id = 2000; | 600 data2.version_uuid = "9bb6c620-8ea3-4b17-9654-e0346a8fc2ce"; |
609 data2.resources_total_size_bytes = 200; | 601 data2.resources_total_size_bytes = 200; |
610 std::vector<Resource> resources2; | 602 std::vector<Resource> resources2; |
611 resources2.push_back(CreateResource(2, data2.script, 200)); | 603 resources2.push_back(CreateResource(2, data2.script, 200)); |
612 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 604 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
613 database->WriteRegistration(data2, resources2, &deleted_version, | 605 database->WriteRegistration(data2, resources2, &deleted_version, |
614 &newly_purgeable_resources)); | 606 &newly_purgeable_resources)); |
615 | 607 |
616 GURL origin3("http://www3.example.com"); | 608 GURL origin3("http://www3.example.com"); |
617 RegistrationData data3; | 609 RegistrationData data3; |
618 data3.registration_id = 300; | 610 data3.registration_id = 300; |
619 data3.scope = URL(origin3, "/hoge"); | 611 data3.scope = URL(origin3, "/hoge"); |
620 data3.script = URL(origin3, "/script3.js"); | 612 data3.script = URL(origin3, "/script3.js"); |
621 data3.version_id = 3000; | 613 data3.version_uuid = "afa0e540-8432-491e-af58-9461850477dd"; |
622 data3.resources_total_size_bytes = 300; | 614 data3.resources_total_size_bytes = 300; |
623 std::vector<Resource> resources3; | 615 std::vector<Resource> resources3; |
624 resources3.push_back(CreateResource(3, data3.script, 300)); | 616 resources3.push_back(CreateResource(3, data3.script, 300)); |
625 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 617 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
626 database->WriteRegistration(data3, resources3, &deleted_version, | 618 database->WriteRegistration(data3, resources3, &deleted_version, |
627 &newly_purgeable_resources)); | 619 &newly_purgeable_resources)); |
628 | 620 |
629 // |origin3| has two registrations. | 621 // |origin3| has two registrations. |
630 RegistrationData data4; | 622 RegistrationData data4; |
631 data4.registration_id = 400; | 623 data4.registration_id = 400; |
632 data4.scope = URL(origin3, "/fuga"); | 624 data4.scope = URL(origin3, "/fuga"); |
633 data4.script = URL(origin3, "/script4.js"); | 625 data4.script = URL(origin3, "/script4.js"); |
634 data4.version_id = 4000; | 626 data4.version_uuid = "142b546d-5b7c-4932-89b9-efca171bd28f"; |
635 data4.resources_total_size_bytes = 400; | 627 data4.resources_total_size_bytes = 400; |
636 std::vector<Resource> resources4; | 628 std::vector<Resource> resources4; |
637 resources4.push_back(CreateResource(4, data4.script, 400)); | 629 resources4.push_back(CreateResource(4, data4.script, 400)); |
638 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 630 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
639 database->WriteRegistration(data4, resources4, &deleted_version, | 631 database->WriteRegistration(data4, resources4, &deleted_version, |
640 &newly_purgeable_resources)); | 632 &newly_purgeable_resources)); |
641 | 633 |
642 registrations.clear(); | 634 registrations.clear(); |
643 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 635 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
644 database->GetAllRegistrations(®istrations)); | 636 database->GetAllRegistrations(®istrations)); |
645 EXPECT_EQ(4U, registrations.size()); | 637 EXPECT_EQ(4U, registrations.size()); |
646 VerifyRegistrationData(data1, registrations[0]); | 638 VerifyRegistrationData(data1, registrations[0]); |
647 VerifyRegistrationData(data2, registrations[1]); | 639 VerifyRegistrationData(data2, registrations[1]); |
648 VerifyRegistrationData(data3, registrations[2]); | 640 VerifyRegistrationData(data3, registrations[2]); |
649 VerifyRegistrationData(data4, registrations[3]); | 641 VerifyRegistrationData(data4, registrations[3]); |
650 } | 642 } |
651 | 643 |
652 TEST(ServiceWorkerDatabaseTest, Registration_Basic) { | 644 TEST(ServiceWorkerDatabaseTest, Registration_Basic) { |
653 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); | 645 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); |
654 | 646 |
655 GURL origin("http://example.com"); | 647 GURL origin("http://example.com"); |
656 RegistrationData data; | 648 RegistrationData data; |
657 data.registration_id = 100; | 649 data.registration_id = 100; |
658 data.scope = URL(origin, "/foo"); | 650 data.scope = URL(origin, "/foo"); |
659 data.script = URL(origin, "/script.js"); | 651 data.script = URL(origin, "/script.js"); |
660 data.version_id = 200; | 652 data.version_uuid = "663f73e1-37d6-4ec9-a809-01afdcb1634d"; |
661 data.resources_total_size_bytes = 10939 + 200; | 653 data.resources_total_size_bytes = 10939 + 200; |
662 | 654 |
663 std::vector<Resource> resources; | 655 std::vector<Resource> resources; |
664 resources.push_back(CreateResource(1, URL(origin, "/resource1"), 10939)); | 656 resources.push_back(CreateResource(1, URL(origin, "/resource1"), 10939)); |
665 resources.push_back(CreateResource(2, URL(origin, "/resource2"), 200)); | 657 resources.push_back(CreateResource(2, URL(origin, "/resource2"), 200)); |
666 | 658 |
667 // Write a resource to the uncommitted list to make sure that writing | 659 // Write a resource to the uncommitted list to make sure that writing |
668 // registration removes resource ids associated with the registration from | 660 // registration removes resource ids associated with the registration from |
669 // the uncommitted list. | 661 // the uncommitted list. |
670 std::set<int64> uncommitted_ids; | 662 std::set<int64> uncommitted_ids; |
671 uncommitted_ids.insert(resources[0].resource_id); | 663 uncommitted_ids.insert(resources[0].resource_id); |
672 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 664 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
673 database->WriteUncommittedResourceIds(uncommitted_ids)); | 665 database->WriteUncommittedResourceIds(uncommitted_ids)); |
674 std::set<int64> uncommitted_ids_out; | 666 std::set<int64> uncommitted_ids_out; |
675 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 667 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
676 database->GetUncommittedResourceIds(&uncommitted_ids_out)); | 668 database->GetUncommittedResourceIds(&uncommitted_ids_out)); |
677 EXPECT_EQ(uncommitted_ids, uncommitted_ids_out); | 669 EXPECT_EQ(uncommitted_ids, uncommitted_ids_out); |
678 | 670 |
679 ServiceWorkerDatabase::RegistrationData deleted_version; | 671 ServiceWorkerDatabase::RegistrationData deleted_version; |
680 deleted_version.version_id = 222; // Dummy initial value | 672 deleted_version.version_uuid = |
| 673 "0185fb13-bb72-42ad-8cdc-cbaabf794dc6"; // Dummy initial value |
681 std::vector<int64> newly_purgeable_resources; | 674 std::vector<int64> newly_purgeable_resources; |
682 | 675 |
683 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 676 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
684 database->WriteRegistration( | 677 database->WriteRegistration( |
685 data, resources, &deleted_version, &newly_purgeable_resources)); | 678 data, resources, &deleted_version, &newly_purgeable_resources)); |
686 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id); | 679 EXPECT_TRUE(deleted_version.version_uuid.empty()); |
687 EXPECT_TRUE(newly_purgeable_resources.empty()); | 680 EXPECT_TRUE(newly_purgeable_resources.empty()); |
688 | 681 |
689 // Make sure that the registration and resource records are stored. | 682 // Make sure that the registration and resource records are stored. |
690 RegistrationData data_out; | 683 RegistrationData data_out; |
691 std::vector<Resource> resources_out; | 684 std::vector<Resource> resources_out; |
692 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 685 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
693 database->ReadRegistration( | 686 database->ReadRegistration( |
694 data.registration_id, origin, &data_out, &resources_out)); | 687 data.registration_id, origin, &data_out, &resources_out)); |
695 VerifyRegistrationData(data, data_out); | 688 VerifyRegistrationData(data, data_out); |
696 VerifyResourceRecords(resources, resources_out); | 689 VerifyResourceRecords(resources, resources_out); |
697 GURL origin_out; | 690 GURL origin_out; |
698 EXPECT_EQ( | 691 EXPECT_EQ( |
699 ServiceWorkerDatabase::STATUS_OK, | 692 ServiceWorkerDatabase::STATUS_OK, |
700 database->ReadRegistrationOrigin(data.registration_id, &origin_out)); | 693 database->ReadRegistrationOrigin(data.registration_id, &origin_out)); |
701 EXPECT_EQ(origin, origin_out); | 694 EXPECT_EQ(origin, origin_out); |
702 | 695 |
703 // Make sure that the resource is removed from the uncommitted list. | 696 // Make sure that the resource is removed from the uncommitted list. |
704 uncommitted_ids_out.clear(); | 697 uncommitted_ids_out.clear(); |
705 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 698 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
706 database->GetUncommittedResourceIds(&uncommitted_ids_out)); | 699 database->GetUncommittedResourceIds(&uncommitted_ids_out)); |
707 EXPECT_TRUE(uncommitted_ids_out.empty()); | 700 EXPECT_TRUE(uncommitted_ids_out.empty()); |
708 | 701 |
709 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 702 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
710 database->DeleteRegistration(data.registration_id, | 703 database->DeleteRegistration(data.registration_id, |
711 origin, | 704 origin, |
712 &deleted_version, | 705 &deleted_version, |
713 &newly_purgeable_resources)); | 706 &newly_purgeable_resources)); |
714 EXPECT_EQ(data.version_id, deleted_version.version_id); | 707 EXPECT_EQ(data.version_uuid, deleted_version.version_uuid); |
715 ASSERT_EQ(resources.size(), newly_purgeable_resources.size()); | 708 ASSERT_EQ(resources.size(), newly_purgeable_resources.size()); |
716 for (size_t i = 0; i < resources.size(); ++i) | 709 for (size_t i = 0; i < resources.size(); ++i) |
717 EXPECT_EQ(newly_purgeable_resources[i], resources[i].resource_id); | 710 EXPECT_EQ(newly_purgeable_resources[i], resources[i].resource_id); |
718 | 711 |
719 // Make sure that the registration and resource records are gone. | 712 // Make sure that the registration and resource records are gone. |
720 resources_out.clear(); | 713 resources_out.clear(); |
721 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, | 714 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, |
722 database->ReadRegistration( | 715 database->ReadRegistration( |
723 data.registration_id, origin, &data_out, &resources_out)); | 716 data.registration_id, origin, &data_out, &resources_out)); |
724 EXPECT_TRUE(resources_out.empty()); | 717 EXPECT_TRUE(resources_out.empty()); |
(...skipping 11 matching lines...) Expand all Loading... |
736 } | 729 } |
737 | 730 |
738 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) { | 731 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) { |
739 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); | 732 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); |
740 | 733 |
741 GURL origin("http://example.com"); | 734 GURL origin("http://example.com"); |
742 RegistrationData data; | 735 RegistrationData data; |
743 data.registration_id = 100; | 736 data.registration_id = 100; |
744 data.scope = URL(origin, "/foo"); | 737 data.scope = URL(origin, "/foo"); |
745 data.script = URL(origin, "/script.js"); | 738 data.script = URL(origin, "/script.js"); |
746 data.version_id = 200; | 739 data.version_uuid = "c4684df5-39e2-4dde-ba61-793c17e61491"; |
747 data.resources_total_size_bytes = 19 + 29129; | 740 data.resources_total_size_bytes = 19 + 29129; |
748 | 741 |
749 std::vector<Resource> resources; | 742 std::vector<Resource> resources; |
750 resources.push_back(CreateResource(1, URL(origin, "/resource1"), 19)); | 743 resources.push_back(CreateResource(1, URL(origin, "/resource1"), 19)); |
751 resources.push_back(CreateResource(2, URL(origin, "/resource2"), 29129)); | 744 resources.push_back(CreateResource(2, URL(origin, "/resource2"), 29129)); |
752 | 745 |
753 const int64 kNonExistentRegistrationId = 999; | 746 const int64 kNonExistentRegistrationId = 999; |
754 const int64 kArbitraryVersionId = 222; // Used as a dummy initial value | 747 const std::string kArbitraryVersionId = |
| 748 "19682155-36a8-4a21-b8d0-9de545e645a6"; // Used as a dummy initial value |
755 | 749 |
756 ServiceWorkerDatabase::RegistrationData deleted_version; | 750 ServiceWorkerDatabase::RegistrationData deleted_version; |
757 deleted_version.version_id = kArbitraryVersionId; | 751 deleted_version.version_uuid = kArbitraryVersionId; |
758 std::vector<int64> newly_purgeable_resources; | 752 std::vector<int64> newly_purgeable_resources; |
759 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 753 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
760 database->WriteRegistration( | 754 database->WriteRegistration( |
761 data, resources, &deleted_version, &newly_purgeable_resources)); | 755 data, resources, &deleted_version, &newly_purgeable_resources)); |
762 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id); | 756 EXPECT_TRUE(deleted_version.version_uuid.empty()); |
763 EXPECT_TRUE(newly_purgeable_resources.empty()); | 757 EXPECT_TRUE(newly_purgeable_resources.empty()); |
764 | 758 |
765 // Delete from an origin that has a registration. | 759 // Delete from an origin that has a registration. |
766 deleted_version.version_id = kArbitraryVersionId; | 760 deleted_version.version_uuid = kArbitraryVersionId; |
767 newly_purgeable_resources.clear(); | 761 newly_purgeable_resources.clear(); |
768 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 762 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
769 database->DeleteRegistration(kNonExistentRegistrationId, | 763 database->DeleteRegistration(kNonExistentRegistrationId, |
770 origin, | 764 origin, |
771 &deleted_version, | 765 &deleted_version, |
772 &newly_purgeable_resources)); | 766 &newly_purgeable_resources)); |
773 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id); | 767 EXPECT_TRUE(deleted_version.version_uuid.empty()); |
774 EXPECT_TRUE(newly_purgeable_resources.empty()); | 768 EXPECT_TRUE(newly_purgeable_resources.empty()); |
775 | 769 |
776 // Delete from an origin that has no registration. | 770 // Delete from an origin that has no registration. |
777 deleted_version.version_id = kArbitraryVersionId; | 771 deleted_version.version_uuid = kArbitraryVersionId; |
778 newly_purgeable_resources.clear(); | 772 newly_purgeable_resources.clear(); |
779 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 773 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
780 database->DeleteRegistration(kNonExistentRegistrationId, | 774 database->DeleteRegistration(kNonExistentRegistrationId, |
781 GURL("http://example.net"), | 775 GURL("http://example.net"), |
782 &deleted_version, | 776 &deleted_version, |
783 &newly_purgeable_resources)); | 777 &newly_purgeable_resources)); |
784 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id); | 778 EXPECT_TRUE(deleted_version.version_uuid.empty()); |
785 EXPECT_TRUE(newly_purgeable_resources.empty()); | 779 EXPECT_TRUE(newly_purgeable_resources.empty()); |
786 } | 780 } |
787 | 781 |
788 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) { | 782 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) { |
789 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); | 783 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); |
790 | 784 |
791 GURL origin("http://example.com"); | 785 GURL origin("http://example.com"); |
792 RegistrationData data; | 786 RegistrationData data; |
793 data.registration_id = 100; | 787 data.registration_id = 100; |
794 data.scope = URL(origin, "/foo"); | 788 data.scope = URL(origin, "/foo"); |
795 data.script = URL(origin, "/script.js"); | 789 data.script = URL(origin, "/script.js"); |
796 data.version_id = 200; | 790 data.version_uuid = "b294411b-4a2c-4bf4-b072-6775a499bbd7"; |
797 data.resources_total_size_bytes = 10 + 11; | 791 data.resources_total_size_bytes = 10 + 11; |
798 | 792 |
799 std::vector<Resource> resources1; | 793 std::vector<Resource> resources1; |
800 resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 10)); | 794 resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 10)); |
801 resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 11)); | 795 resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 11)); |
802 | 796 |
803 ServiceWorkerDatabase::RegistrationData deleted_version; | 797 ServiceWorkerDatabase::RegistrationData deleted_version; |
804 deleted_version.version_id = 222; // Dummy inital value | 798 deleted_version.version_uuid = |
| 799 "904d263b-9872-49f2-bd33-147b98f6d1b8"; // Dummy inital value |
805 std::vector<int64> newly_purgeable_resources; | 800 std::vector<int64> newly_purgeable_resources; |
806 | 801 |
807 EXPECT_EQ( | 802 EXPECT_EQ( |
808 ServiceWorkerDatabase::STATUS_OK, | 803 ServiceWorkerDatabase::STATUS_OK, |
809 database->WriteRegistration( | 804 database->WriteRegistration( |
810 data, resources1, &deleted_version, &newly_purgeable_resources)); | 805 data, resources1, &deleted_version, &newly_purgeable_resources)); |
811 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id); | 806 EXPECT_TRUE(deleted_version.version_uuid.empty()); |
812 EXPECT_TRUE(newly_purgeable_resources.empty()); | 807 EXPECT_TRUE(newly_purgeable_resources.empty()); |
813 | 808 |
814 // Make sure that the registration and resource records are stored. | 809 // Make sure that the registration and resource records are stored. |
815 RegistrationData data_out; | 810 RegistrationData data_out; |
816 std::vector<Resource> resources_out; | 811 std::vector<Resource> resources_out; |
817 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration( | 812 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration( |
818 data.registration_id, origin, &data_out, &resources_out)); | 813 data.registration_id, origin, &data_out, &resources_out)); |
819 VerifyRegistrationData(data, data_out); | 814 VerifyRegistrationData(data, data_out); |
820 VerifyResourceRecords(resources1, resources_out); | 815 VerifyResourceRecords(resources1, resources_out); |
821 | 816 |
822 // Update the registration. | 817 // Update the registration. |
823 RegistrationData updated_data = data; | 818 RegistrationData updated_data = data; |
824 updated_data.version_id = data.version_id + 1; | 819 updated_data.version_uuid = |
| 820 "a504ba56-4f06-4c48-a904-474e25bca691"; // New version id |
825 updated_data.resources_total_size_bytes = 12 + 13; | 821 updated_data.resources_total_size_bytes = 12 + 13; |
826 std::vector<Resource> resources2; | 822 std::vector<Resource> resources2; |
827 resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 12)); | 823 resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 12)); |
828 resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 13)); | 824 resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 13)); |
829 | 825 |
830 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 826 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
831 database->WriteRegistration(updated_data, | 827 database->WriteRegistration(updated_data, |
832 resources2, | 828 resources2, |
833 &deleted_version, | 829 &deleted_version, |
834 &newly_purgeable_resources)); | 830 &newly_purgeable_resources)); |
835 EXPECT_EQ(data.version_id, deleted_version.version_id); | 831 EXPECT_EQ(data.version_uuid, deleted_version.version_uuid); |
836 ASSERT_EQ(resources1.size(), newly_purgeable_resources.size()); | 832 ASSERT_EQ(resources1.size(), newly_purgeable_resources.size()); |
837 for (size_t i = 0; i < resources1.size(); ++i) | 833 for (size_t i = 0; i < resources1.size(); ++i) |
838 EXPECT_EQ(newly_purgeable_resources[i], resources1[i].resource_id); | 834 EXPECT_EQ(newly_purgeable_resources[i], resources1[i].resource_id); |
839 | 835 |
840 // Make sure that |updated_data| is stored and resources referred from |data| | 836 // Make sure that |updated_data| is stored and resources referred from |data| |
841 // is moved to the purgeable list. | 837 // is moved to the purgeable list. |
842 resources_out.clear(); | 838 resources_out.clear(); |
843 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration( | 839 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration( |
844 updated_data.registration_id, origin, &data_out, &resources_out)); | 840 updated_data.registration_id, origin, &data_out, &resources_out)); |
845 VerifyRegistrationData(updated_data, data_out); | 841 VerifyRegistrationData(updated_data, data_out); |
(...skipping 12 matching lines...) Expand all Loading... |
858 GURL origin("http://example.com"); | 854 GURL origin("http://example.com"); |
859 | 855 |
860 ServiceWorkerDatabase::RegistrationData deleted_version; | 856 ServiceWorkerDatabase::RegistrationData deleted_version; |
861 std::vector<int64> newly_purgeable_resources; | 857 std::vector<int64> newly_purgeable_resources; |
862 | 858 |
863 // Add registration1. | 859 // Add registration1. |
864 RegistrationData data1; | 860 RegistrationData data1; |
865 data1.registration_id = 100; | 861 data1.registration_id = 100; |
866 data1.scope = URL(origin, "/foo"); | 862 data1.scope = URL(origin, "/foo"); |
867 data1.script = URL(origin, "/script1.js"); | 863 data1.script = URL(origin, "/script1.js"); |
868 data1.version_id = 200; | 864 data1.version_uuid = "f731439c-d7ea-423d-91e4-9fc910f439f2"; |
869 data1.resources_total_size_bytes = 1451 + 15234; | 865 data1.resources_total_size_bytes = 1451 + 15234; |
870 | 866 |
871 std::vector<Resource> resources1; | 867 std::vector<Resource> resources1; |
872 resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 1451)); | 868 resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 1451)); |
873 resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 15234)); | 869 resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 15234)); |
874 EXPECT_EQ( | 870 EXPECT_EQ( |
875 ServiceWorkerDatabase::STATUS_OK, | 871 ServiceWorkerDatabase::STATUS_OK, |
876 database->WriteRegistration( | 872 database->WriteRegistration( |
877 data1, resources1, &deleted_version, &newly_purgeable_resources)); | 873 data1, resources1, &deleted_version, &newly_purgeable_resources)); |
878 | 874 |
879 // Add registration2. | 875 // Add registration2. |
880 RegistrationData data2; | 876 RegistrationData data2; |
881 data2.registration_id = 101; | 877 data2.registration_id = 101; |
882 data2.scope = URL(origin, "/bar"); | 878 data2.scope = URL(origin, "/bar"); |
883 data2.script = URL(origin, "/script2.js"); | 879 data2.script = URL(origin, "/script2.js"); |
884 data2.version_id = 201; | 880 data2.version_uuid = "3eba69fd-38f3-4807-a5ac-329d22d91357"; |
885 data2.resources_total_size_bytes = 5 + 6; | 881 data2.resources_total_size_bytes = 5 + 6; |
886 | 882 |
887 std::vector<Resource> resources2; | 883 std::vector<Resource> resources2; |
888 resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 5)); | 884 resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 5)); |
889 resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 6)); | 885 resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 6)); |
890 EXPECT_EQ( | 886 EXPECT_EQ( |
891 ServiceWorkerDatabase::STATUS_OK, | 887 ServiceWorkerDatabase::STATUS_OK, |
892 database->WriteRegistration( | 888 database->WriteRegistration( |
893 data2, resources2, &deleted_version, &newly_purgeable_resources)); | 889 data2, resources2, &deleted_version, &newly_purgeable_resources)); |
894 | 890 |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
973 GURL origin_out; | 969 GURL origin_out; |
974 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, | 970 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, |
975 database->ReadRegistrationOrigin(100, &origin_out)); | 971 database->ReadRegistrationOrigin(100, &origin_out)); |
976 | 972 |
977 // Deleting non-existent registration should succeed. | 973 // Deleting non-existent registration should succeed. |
978 RegistrationData deleted_version; | 974 RegistrationData deleted_version; |
979 std::vector<int64> newly_purgeable_resources; | 975 std::vector<int64> newly_purgeable_resources; |
980 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 976 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
981 database->DeleteRegistration( | 977 database->DeleteRegistration( |
982 100, origin, &deleted_version, &newly_purgeable_resources)); | 978 100, origin, &deleted_version, &newly_purgeable_resources)); |
983 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id); | 979 EXPECT_TRUE(deleted_version.version_uuid.empty()); |
984 EXPECT_TRUE(newly_purgeable_resources.empty()); | 980 EXPECT_TRUE(newly_purgeable_resources.empty()); |
985 | 981 |
986 // Actually create a new database, but not initialized yet. | 982 // Actually create a new database, but not initialized yet. |
987 database->LazyOpen(true); | 983 database->LazyOpen(true); |
988 | 984 |
989 // Should be failed because the database is not initialized. | 985 // Should be failed because the database is not initialized. |
990 ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_); | 986 ASSERT_EQ(ServiceWorkerDatabase::UNINITIALIZED, database->state_); |
991 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, | 987 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, |
992 database->ReadRegistration( | 988 database->ReadRegistration( |
993 100, origin, &data_out, &resources_out)); | 989 100, origin, &data_out, &resources_out)); |
994 EXPECT_EQ(kInvalidServiceWorkerRegistrationId, data_out.registration_id); | 990 EXPECT_EQ(kInvalidServiceWorkerRegistrationId, data_out.registration_id); |
995 EXPECT_TRUE(resources_out.empty()); | 991 EXPECT_TRUE(resources_out.empty()); |
996 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, | 992 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, |
997 database->ReadRegistrationOrigin(100, &origin_out)); | 993 database->ReadRegistrationOrigin(100, &origin_out)); |
998 | 994 |
999 // Deleting non-existent registration should succeed. | 995 // Deleting non-existent registration should succeed. |
1000 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 996 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
1001 database->DeleteRegistration( | 997 database->DeleteRegistration( |
1002 100, origin, &deleted_version, &newly_purgeable_resources)); | 998 100, origin, &deleted_version, &newly_purgeable_resources)); |
1003 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version.version_id); | 999 EXPECT_TRUE(deleted_version.version_uuid.empty()); |
1004 EXPECT_TRUE(newly_purgeable_resources.empty()); | 1000 EXPECT_TRUE(newly_purgeable_resources.empty()); |
1005 } | 1001 } |
1006 | 1002 |
1007 TEST(ServiceWorkerDatabaseTest, UserData_Basic) { | 1003 TEST(ServiceWorkerDatabaseTest, UserData_Basic) { |
1008 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); | 1004 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); |
1009 const GURL kOrigin("http://example.com"); | 1005 const GURL kOrigin("http://example.com"); |
1010 | 1006 |
1011 // Add a registration. | 1007 // Add a registration. |
1012 RegistrationData data; | 1008 RegistrationData data; |
1013 data.registration_id = 100; | 1009 data.registration_id = 100; |
1014 data.scope = URL(kOrigin, "/foo"); | 1010 data.scope = URL(kOrigin, "/foo"); |
1015 data.script = URL(kOrigin, "/script.js"); | 1011 data.script = URL(kOrigin, "/script.js"); |
1016 data.version_id = 200; | 1012 data.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010"; |
1017 data.resources_total_size_bytes = 100; | 1013 data.resources_total_size_bytes = 100; |
1018 std::vector<Resource> resources; | 1014 std::vector<Resource> resources; |
1019 resources.push_back(CreateResource(1, data.script, 100)); | 1015 resources.push_back(CreateResource(1, data.script, 100)); |
1020 ServiceWorkerDatabase::RegistrationData deleted_version; | 1016 ServiceWorkerDatabase::RegistrationData deleted_version; |
1021 std::vector<int64> newly_purgeable_resources; | 1017 std::vector<int64> newly_purgeable_resources; |
1022 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 1018 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
1023 database->WriteRegistration( | 1019 database->WriteRegistration( |
1024 data, resources, &deleted_version, &newly_purgeable_resources)); | 1020 data, resources, &deleted_version, &newly_purgeable_resources)); |
1025 | 1021 |
1026 // Write user data associated with the stored registration. | 1022 // Write user data associated with the stored registration. |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1074 | 1070 |
1075 TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) { | 1071 TEST(ServiceWorkerDatabaseTest, UserData_DataIsolation) { |
1076 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); | 1072 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); |
1077 const GURL kOrigin("http://example.com"); | 1073 const GURL kOrigin("http://example.com"); |
1078 | 1074 |
1079 // Add registration 1. | 1075 // Add registration 1. |
1080 RegistrationData data1; | 1076 RegistrationData data1; |
1081 data1.registration_id = 100; | 1077 data1.registration_id = 100; |
1082 data1.scope = URL(kOrigin, "/foo"); | 1078 data1.scope = URL(kOrigin, "/foo"); |
1083 data1.script = URL(kOrigin, "/script1.js"); | 1079 data1.script = URL(kOrigin, "/script1.js"); |
1084 data1.version_id = 200; | 1080 data1.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010"; |
1085 data1.resources_total_size_bytes = 100; | 1081 data1.resources_total_size_bytes = 100; |
1086 std::vector<Resource> resources1; | 1082 std::vector<Resource> resources1; |
1087 resources1.push_back(CreateResource(1, data1.script, 100)); | 1083 resources1.push_back(CreateResource(1, data1.script, 100)); |
1088 | 1084 |
1089 // Add registration 2. | 1085 // Add registration 2. |
1090 RegistrationData data2; | 1086 RegistrationData data2; |
1091 data2.registration_id = 101; | 1087 data2.registration_id = 101; |
1092 data2.scope = URL(kOrigin, "/bar"); | 1088 data2.scope = URL(kOrigin, "/bar"); |
1093 data2.script = URL(kOrigin, "/script2.js"); | 1089 data2.script = URL(kOrigin, "/script2.js"); |
1094 data2.version_id = 201; | 1090 data2.version_uuid = "645ba1bc-bc64-4867-bfb8-71a909704254"; |
1095 data2.resources_total_size_bytes = 200; | 1091 data2.resources_total_size_bytes = 200; |
1096 std::vector<Resource> resources2; | 1092 std::vector<Resource> resources2; |
1097 resources2.push_back(CreateResource(2, data2.script, 200)); | 1093 resources2.push_back(CreateResource(2, data2.script, 200)); |
1098 | 1094 |
1099 ServiceWorkerDatabase::RegistrationData deleted_version; | 1095 ServiceWorkerDatabase::RegistrationData deleted_version; |
1100 std::vector<int64> newly_purgeable_resources; | 1096 std::vector<int64> newly_purgeable_resources; |
1101 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 1097 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
1102 database->WriteRegistration(data1, resources1, &deleted_version, | 1098 database->WriteRegistration(data1, resources1, &deleted_version, |
1103 &newly_purgeable_resources)); | 1099 &newly_purgeable_resources)); |
1104 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 1100 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1165 | 1161 |
1166 TEST(ServiceWorkerDatabaseTest, UserData_DeleteRegistration) { | 1162 TEST(ServiceWorkerDatabaseTest, UserData_DeleteRegistration) { |
1167 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); | 1163 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); |
1168 const GURL kOrigin("http://example.com"); | 1164 const GURL kOrigin("http://example.com"); |
1169 | 1165 |
1170 // Add registration 1. | 1166 // Add registration 1. |
1171 RegistrationData data1; | 1167 RegistrationData data1; |
1172 data1.registration_id = 100; | 1168 data1.registration_id = 100; |
1173 data1.scope = URL(kOrigin, "/foo"); | 1169 data1.scope = URL(kOrigin, "/foo"); |
1174 data1.script = URL(kOrigin, "/script1.js"); | 1170 data1.script = URL(kOrigin, "/script1.js"); |
1175 data1.version_id = 200; | 1171 data1.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010"; |
1176 data1.resources_total_size_bytes = 100; | 1172 data1.resources_total_size_bytes = 100; |
1177 std::vector<Resource> resources1; | 1173 std::vector<Resource> resources1; |
1178 resources1.push_back(CreateResource(1, data1.script, 100)); | 1174 resources1.push_back(CreateResource(1, data1.script, 100)); |
1179 | 1175 |
1180 // Add registration 2. | 1176 // Add registration 2. |
1181 RegistrationData data2; | 1177 RegistrationData data2; |
1182 data2.registration_id = 101; | 1178 data2.registration_id = 101; |
1183 data2.scope = URL(kOrigin, "/bar"); | 1179 data2.scope = URL(kOrigin, "/bar"); |
1184 data2.script = URL(kOrigin, "/script2.js"); | 1180 data2.script = URL(kOrigin, "/script2.js"); |
1185 data2.version_id = 201; | 1181 data2.version_uuid = "645ba1bc-bc64-4867-bfb8-71a909704254"; |
1186 data2.resources_total_size_bytes = 200; | 1182 data2.resources_total_size_bytes = 200; |
1187 std::vector<Resource> resources2; | 1183 std::vector<Resource> resources2; |
1188 resources2.push_back(CreateResource(2, data2.script, 200)); | 1184 resources2.push_back(CreateResource(2, data2.script, 200)); |
1189 | 1185 |
1190 ServiceWorkerDatabase::RegistrationData deleted_version; | 1186 ServiceWorkerDatabase::RegistrationData deleted_version; |
1191 std::vector<int64> newly_purgeable_resources; | 1187 std::vector<int64> newly_purgeable_resources; |
1192 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 1188 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
1193 database->WriteRegistration(data1, resources1, &deleted_version, | 1189 database->WriteRegistration(data1, resources1, &deleted_version, |
1194 &newly_purgeable_resources)); | 1190 &newly_purgeable_resources)); |
1195 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, | 1191 ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK, |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1281 | 1277 |
1282 // Should be false because a registration does not exist. | 1278 // Should be false because a registration does not exist. |
1283 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, | 1279 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, |
1284 database->UpdateVersionToActive(0, origin)); | 1280 database->UpdateVersionToActive(0, origin)); |
1285 | 1281 |
1286 // Add a registration. | 1282 // Add a registration. |
1287 RegistrationData data; | 1283 RegistrationData data; |
1288 data.registration_id = 100; | 1284 data.registration_id = 100; |
1289 data.scope = URL(origin, "/foo"); | 1285 data.scope = URL(origin, "/foo"); |
1290 data.script = URL(origin, "/script.js"); | 1286 data.script = URL(origin, "/script.js"); |
1291 data.version_id = 200; | 1287 data.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010"; |
1292 data.is_active = false; | 1288 data.is_active = false; |
1293 data.resources_total_size_bytes = 100; | 1289 data.resources_total_size_bytes = 100; |
1294 std::vector<Resource> resources; | 1290 std::vector<Resource> resources; |
1295 resources.push_back(CreateResource(1, data.script, 100)); | 1291 resources.push_back(CreateResource(1, data.script, 100)); |
1296 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 1292 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
1297 database->WriteRegistration(data, resources, &deleted_version, | 1293 database->WriteRegistration(data, resources, &deleted_version, |
1298 &newly_purgeable_resources)); | 1294 &newly_purgeable_resources)); |
1299 | 1295 |
1300 // Make sure that the registration is stored. | 1296 // Make sure that the registration is stored. |
1301 RegistrationData data_out; | 1297 RegistrationData data_out; |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1341 | 1337 |
1342 // Should be false because a registration does not exist. | 1338 // Should be false because a registration does not exist. |
1343 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, | 1339 EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND, |
1344 database->UpdateLastCheckTime(0, origin, base::Time::Now())); | 1340 database->UpdateLastCheckTime(0, origin, base::Time::Now())); |
1345 | 1341 |
1346 // Add a registration. | 1342 // Add a registration. |
1347 RegistrationData data; | 1343 RegistrationData data; |
1348 data.registration_id = 100; | 1344 data.registration_id = 100; |
1349 data.scope = URL(origin, "/foo"); | 1345 data.scope = URL(origin, "/foo"); |
1350 data.script = URL(origin, "/script.js"); | 1346 data.script = URL(origin, "/script.js"); |
1351 data.version_id = 200; | 1347 data.version_uuid = "85cf6e28-8c50-4abd-9ef5-5f425b893010"; |
1352 data.last_update_check = base::Time::Now(); | 1348 data.last_update_check = base::Time::Now(); |
1353 data.resources_total_size_bytes = 100; | 1349 data.resources_total_size_bytes = 100; |
1354 std::vector<Resource> resources; | 1350 std::vector<Resource> resources; |
1355 resources.push_back(CreateResource(1, data.script, 100)); | 1351 resources.push_back(CreateResource(1, data.script, 100)); |
1356 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, | 1352 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, |
1357 database->WriteRegistration(data, resources, &deleted_version, | 1353 database->WriteRegistration(data, resources, &deleted_version, |
1358 &newly_purgeable_resources)); | 1354 &newly_purgeable_resources)); |
1359 | 1355 |
1360 // Make sure that the registration is stored. | 1356 // Make sure that the registration is stored. |
1361 RegistrationData data_out; | 1357 RegistrationData data_out; |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1489 | 1485 |
1490 // Data associated with |origin1| will be removed. | 1486 // Data associated with |origin1| will be removed. |
1491 GURL origin1("http://example.com"); | 1487 GURL origin1("http://example.com"); |
1492 GURL origin2("http://example.org"); | 1488 GURL origin2("http://example.org"); |
1493 | 1489 |
1494 // |origin1| has two registrations (registration1 and registration2). | 1490 // |origin1| has two registrations (registration1 and registration2). |
1495 RegistrationData data1; | 1491 RegistrationData data1; |
1496 data1.registration_id = 10; | 1492 data1.registration_id = 10; |
1497 data1.scope = URL(origin1, "/foo"); | 1493 data1.scope = URL(origin1, "/foo"); |
1498 data1.script = URL(origin1, "/script1.js"); | 1494 data1.script = URL(origin1, "/script1.js"); |
1499 data1.version_id = 100; | 1495 data1.version_uuid = "8dba4236-45fc-4694-b451-c34b45a4666d"; |
1500 data1.resources_total_size_bytes = 2013 + 512; | 1496 data1.resources_total_size_bytes = 2013 + 512; |
1501 | 1497 |
1502 std::vector<Resource> resources1; | 1498 std::vector<Resource> resources1; |
1503 resources1.push_back(CreateResource(1, URL(origin1, "/resource1"), 2013)); | 1499 resources1.push_back(CreateResource(1, URL(origin1, "/resource1"), 2013)); |
1504 resources1.push_back(CreateResource(2, URL(origin1, "/resource2"), 512)); | 1500 resources1.push_back(CreateResource(2, URL(origin1, "/resource2"), 512)); |
1505 ASSERT_EQ( | 1501 ASSERT_EQ( |
1506 ServiceWorkerDatabase::STATUS_OK, | 1502 ServiceWorkerDatabase::STATUS_OK, |
1507 database->WriteRegistration( | 1503 database->WriteRegistration( |
1508 data1, resources1, &deleted_version, &newly_purgeable_resources)); | 1504 data1, resources1, &deleted_version, &newly_purgeable_resources)); |
1509 ASSERT_EQ( | 1505 ASSERT_EQ( |
1510 ServiceWorkerDatabase::STATUS_OK, | 1506 ServiceWorkerDatabase::STATUS_OK, |
1511 database->WriteUserData( | 1507 database->WriteUserData( |
1512 data1.registration_id, origin1, "key1", "data1")); | 1508 data1.registration_id, origin1, "key1", "data1")); |
1513 ASSERT_EQ( | 1509 ASSERT_EQ( |
1514 ServiceWorkerDatabase::STATUS_OK, | 1510 ServiceWorkerDatabase::STATUS_OK, |
1515 database->WriteUserData( | 1511 database->WriteUserData( |
1516 data1.registration_id, origin1, "key2", "data2")); | 1512 data1.registration_id, origin1, "key2", "data2")); |
1517 | 1513 |
1518 RegistrationData data2; | 1514 RegistrationData data2; |
1519 data2.registration_id = 11; | 1515 data2.registration_id = 11; |
1520 data2.scope = URL(origin1, "/bar"); | 1516 data2.scope = URL(origin1, "/bar"); |
1521 data2.script = URL(origin1, "/script2.js"); | 1517 data2.script = URL(origin1, "/script2.js"); |
1522 data2.version_id = 101; | 1518 data2.version_uuid = "9cdf4806-400b-4238-b890-f480273d4ea8"; |
1523 data2.resources_total_size_bytes = 4 + 5; | 1519 data2.resources_total_size_bytes = 4 + 5; |
1524 | 1520 |
1525 std::vector<Resource> resources2; | 1521 std::vector<Resource> resources2; |
1526 resources2.push_back(CreateResource(3, URL(origin1, "/resource3"), 4)); | 1522 resources2.push_back(CreateResource(3, URL(origin1, "/resource3"), 4)); |
1527 resources2.push_back(CreateResource(4, URL(origin1, "/resource4"), 5)); | 1523 resources2.push_back(CreateResource(4, URL(origin1, "/resource4"), 5)); |
1528 ASSERT_EQ( | 1524 ASSERT_EQ( |
1529 ServiceWorkerDatabase::STATUS_OK, | 1525 ServiceWorkerDatabase::STATUS_OK, |
1530 database->WriteRegistration( | 1526 database->WriteRegistration( |
1531 data2, resources2, &deleted_version, &newly_purgeable_resources)); | 1527 data2, resources2, &deleted_version, &newly_purgeable_resources)); |
1532 ASSERT_EQ( | 1528 ASSERT_EQ( |
1533 ServiceWorkerDatabase::STATUS_OK, | 1529 ServiceWorkerDatabase::STATUS_OK, |
1534 database->WriteUserData( | 1530 database->WriteUserData( |
1535 data2.registration_id, origin1, "key3", "data3")); | 1531 data2.registration_id, origin1, "key3", "data3")); |
1536 ASSERT_EQ( | 1532 ASSERT_EQ( |
1537 ServiceWorkerDatabase::STATUS_OK, | 1533 ServiceWorkerDatabase::STATUS_OK, |
1538 database->WriteUserData( | 1534 database->WriteUserData( |
1539 data2.registration_id, origin1, "key4", "data4")); | 1535 data2.registration_id, origin1, "key4", "data4")); |
1540 | 1536 |
1541 // |origin2| has one registration (registration3). | 1537 // |origin2| has one registration (registration3). |
1542 RegistrationData data3; | 1538 RegistrationData data3; |
1543 data3.registration_id = 12; | 1539 data3.registration_id = 12; |
1544 data3.scope = URL(origin2, "/hoge"); | 1540 data3.scope = URL(origin2, "/hoge"); |
1545 data3.script = URL(origin2, "/script3.js"); | 1541 data3.script = URL(origin2, "/script3.js"); |
1546 data3.version_id = 102; | 1542 data3.version_uuid = "743b5448-f6e3-4141-ad5b-2e40118bf07f"; |
1547 data3.resources_total_size_bytes = 6 + 7; | 1543 data3.resources_total_size_bytes = 6 + 7; |
1548 | 1544 |
1549 std::vector<Resource> resources3; | 1545 std::vector<Resource> resources3; |
1550 resources3.push_back(CreateResource(5, URL(origin2, "/resource5"), 6)); | 1546 resources3.push_back(CreateResource(5, URL(origin2, "/resource5"), 6)); |
1551 resources3.push_back(CreateResource(6, URL(origin2, "/resource6"), 7)); | 1547 resources3.push_back(CreateResource(6, URL(origin2, "/resource6"), 7)); |
1552 ASSERT_EQ( | 1548 ASSERT_EQ( |
1553 ServiceWorkerDatabase::STATUS_OK, | 1549 ServiceWorkerDatabase::STATUS_OK, |
1554 database->WriteRegistration( | 1550 database->WriteRegistration( |
1555 data3, resources3, &deleted_version, &newly_purgeable_resources)); | 1551 data3, resources3, &deleted_version, &newly_purgeable_resources)); |
1556 ASSERT_EQ( | 1552 ASSERT_EQ( |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1641 CreateDatabase(database_dir.path())); | 1637 CreateDatabase(database_dir.path())); |
1642 | 1638 |
1643 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true)); | 1639 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true)); |
1644 ASSERT_TRUE(base::DirectoryExists(database_dir.path())); | 1640 ASSERT_TRUE(base::DirectoryExists(database_dir.path())); |
1645 | 1641 |
1646 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase()); | 1642 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase()); |
1647 ASSERT_FALSE(base::DirectoryExists(database_dir.path())); | 1643 ASSERT_FALSE(base::DirectoryExists(database_dir.path())); |
1648 } | 1644 } |
1649 | 1645 |
1650 } // namespace content | 1646 } // namespace content |
OLD | NEW |