Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(245)

Side by Side Diff: content/browser/service_worker/service_worker_database_unittest.cc

Issue 647953003: Service Worker script sizes in database. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git/+/master
Patch Set: Fixed crash where writer_ was null Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 19 matching lines...) Expand all
30 }; 30 };
31 31
32 GURL URL(const GURL& origin, const std::string& path) { 32 GURL URL(const GURL& origin, const std::string& path) {
33 EXPECT_TRUE(origin.is_valid()); 33 EXPECT_TRUE(origin.is_valid());
34 EXPECT_EQ(origin, origin.GetOrigin()); 34 EXPECT_EQ(origin, origin.GetOrigin());
35 GURL out(origin.spec() + path); 35 GURL out(origin.spec() + path);
36 EXPECT_TRUE(out.is_valid()); 36 EXPECT_TRUE(out.is_valid());
37 return out; 37 return out;
38 } 38 }
39 39
40 Resource CreateResource(int64 resource_id, const GURL& url) { 40 Resource CreateResource(int64 resource_id, const GURL& url, uint64 size_bytes) {
41 EXPECT_TRUE(url.is_valid()); 41 EXPECT_TRUE(url.is_valid());
42 Resource resource; 42 return Resource(resource_id, url, size_bytes);
43 resource.resource_id = resource_id;
44 resource.url = url;
45 return resource;
46 } 43 }
47 44
48 ServiceWorkerDatabase* CreateDatabase(const base::FilePath& path) { 45 ServiceWorkerDatabase* CreateDatabase(const base::FilePath& path) {
49 return new ServiceWorkerDatabase(path); 46 return new ServiceWorkerDatabase(path);
50 } 47 }
51 48
52 ServiceWorkerDatabase* CreateDatabaseInMemory() { 49 ServiceWorkerDatabase* CreateDatabaseInMemory() {
53 return new ServiceWorkerDatabase(base::FilePath()); 50 return new ServiceWorkerDatabase(base::FilePath());
54 } 51 }
55 52
56 void VerifyRegistrationData(const RegistrationData& expected, 53 void VerifyRegistrationData(const RegistrationData& expected,
57 const RegistrationData& actual) { 54 const RegistrationData& actual) {
58 EXPECT_EQ(expected.registration_id, actual.registration_id); 55 EXPECT_EQ(expected.registration_id, actual.registration_id);
59 EXPECT_EQ(expected.scope, actual.scope); 56 EXPECT_EQ(expected.scope, actual.scope);
60 EXPECT_EQ(expected.script, actual.script); 57 EXPECT_EQ(expected.script, actual.script);
61 EXPECT_EQ(expected.version_id, actual.version_id); 58 EXPECT_EQ(expected.version_id, actual.version_id);
62 EXPECT_EQ(expected.is_active, actual.is_active); 59 EXPECT_EQ(expected.is_active, actual.is_active);
63 EXPECT_EQ(expected.has_fetch_handler, actual.has_fetch_handler); 60 EXPECT_EQ(expected.has_fetch_handler, actual.has_fetch_handler);
64 EXPECT_EQ(expected.last_update_check, actual.last_update_check); 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);
65 } 64 }
66 65
67 void VerifyResourceRecords(const std::vector<Resource>& expected, 66 void VerifyResourceRecords(const std::vector<Resource>& expected,
68 const std::vector<Resource>& actual) { 67 const std::vector<Resource>& actual) {
69 ASSERT_EQ(expected.size(), actual.size()); 68 ASSERT_EQ(expected.size(), actual.size());
70 for (size_t i = 0; i < expected.size(); ++i) { 69 for (size_t i = 0; i < expected.size(); ++i) {
71 EXPECT_EQ(expected[i].resource_id, actual[i].resource_id); 70 EXPECT_EQ(expected[i].resource_id, actual[i].resource_id);
72 EXPECT_EQ(expected[i].url, actual[i].url); 71 EXPECT_EQ(expected[i].url, actual[i].url);
72 EXPECT_EQ(expected[i].size_bytes, actual[i].size_bytes);
73 } 73 }
74 } 74 }
75 75
76 } // namespace 76 } // namespace
77 77
78 TEST(ServiceWorkerDatabaseTest, OpenDatabase) { 78 TEST(ServiceWorkerDatabaseTest, OpenDatabase) {
79 base::ScopedTempDir database_dir; 79 base::ScopedTempDir database_dir;
80 ASSERT_TRUE(database_dir.CreateUniqueTempDir()); 80 ASSERT_TRUE(database_dir.CreateUniqueTempDir());
81 scoped_ptr<ServiceWorkerDatabase> database( 81 scoped_ptr<ServiceWorkerDatabase> database(
82 CreateDatabase(database_dir.path())); 82 CreateDatabase(database_dir.path()));
(...skipping 375 matching lines...) Expand 10 before | Expand all | Expand 10 after
458 458
459 TEST(ServiceWorkerDatabaseTest, Registration_Basic) { 459 TEST(ServiceWorkerDatabaseTest, Registration_Basic) {
460 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); 460 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
461 461
462 GURL origin("http://example.com"); 462 GURL origin("http://example.com");
463 RegistrationData data; 463 RegistrationData data;
464 data.registration_id = 100; 464 data.registration_id = 100;
465 data.scope = URL(origin, "/foo"); 465 data.scope = URL(origin, "/foo");
466 data.script = URL(origin, "/script.js"); 466 data.script = URL(origin, "/script.js");
467 data.version_id = 200; 467 data.version_id = 200;
468 data.resources_total_size_bytes = 10939 + 200;
468 469
469 std::vector<Resource> resources; 470 std::vector<Resource> resources;
470 resources.push_back(CreateResource(1, URL(origin, "/resource1"))); 471 resources.push_back(CreateResource(1, URL(origin, "/resource1"), 10939));
471 resources.push_back(CreateResource(2, URL(origin, "/resource2"))); 472 resources.push_back(CreateResource(2, URL(origin, "/resource2"), 200));
472 473
473 // Write a resource to the uncommitted list to make sure that writing 474 // Write a resource to the uncommitted list to make sure that writing
474 // registration removes resource ids associated with the registration from 475 // registration removes resource ids associated with the registration from
475 // the uncommitted list. 476 // the uncommitted list.
476 std::set<int64> uncommitted_ids; 477 std::set<int64> uncommitted_ids;
477 uncommitted_ids.insert(resources[0].resource_id); 478 uncommitted_ids.insert(resources[0].resource_id);
478 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, 479 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
479 database->WriteUncommittedResourceIds(uncommitted_ids)); 480 database->WriteUncommittedResourceIds(uncommitted_ids));
480 std::set<int64> uncommitted_ids_out; 481 std::set<int64> uncommitted_ids_out;
481 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, 482 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
535 536
536 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) { 537 TEST(ServiceWorkerDatabaseTest, DeleteNonExistentRegistration) {
537 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); 538 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
538 539
539 GURL origin("http://example.com"); 540 GURL origin("http://example.com");
540 RegistrationData data; 541 RegistrationData data;
541 data.registration_id = 100; 542 data.registration_id = 100;
542 data.scope = URL(origin, "/foo"); 543 data.scope = URL(origin, "/foo");
543 data.script = URL(origin, "/script.js"); 544 data.script = URL(origin, "/script.js");
544 data.version_id = 200; 545 data.version_id = 200;
546 data.resources_total_size_bytes = 19 + 29129;
545 547
546 std::vector<Resource> resources; 548 std::vector<Resource> resources;
547 resources.push_back(CreateResource(1, URL(origin, "/resource1"))); 549 resources.push_back(CreateResource(1, URL(origin, "/resource1"), 19));
548 resources.push_back(CreateResource(2, URL(origin, "/resource2"))); 550 resources.push_back(CreateResource(2, URL(origin, "/resource2"), 29129));
549 551
550 const int64 kNonExistentRegistrationId = 999; 552 const int64 kNonExistentRegistrationId = 999;
551 const int64 kArbitraryVersionId = 222; // Used as a dummy initial value 553 const int64 kArbitraryVersionId = 222; // Used as a dummy initial value
552 554
553 int64 deleted_version_id = kArbitraryVersionId; 555 int64 deleted_version_id = kArbitraryVersionId;
554 std::vector<int64> newly_purgeable_resources; 556 std::vector<int64> newly_purgeable_resources;
555 EXPECT_EQ( 557 EXPECT_EQ(
556 ServiceWorkerDatabase::STATUS_OK, 558 ServiceWorkerDatabase::STATUS_OK,
557 database->WriteRegistration( 559 database->WriteRegistration(
558 data, resources, &deleted_version_id, &newly_purgeable_resources)); 560 data, resources, &deleted_version_id, &newly_purgeable_resources));
(...skipping 25 matching lines...) Expand all
584 586
585 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) { 587 TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) {
586 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory()); 588 scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
587 589
588 GURL origin("http://example.com"); 590 GURL origin("http://example.com");
589 RegistrationData data; 591 RegistrationData data;
590 data.registration_id = 100; 592 data.registration_id = 100;
591 data.scope = URL(origin, "/foo"); 593 data.scope = URL(origin, "/foo");
592 data.script = URL(origin, "/script.js"); 594 data.script = URL(origin, "/script.js");
593 data.version_id = 200; 595 data.version_id = 200;
596 data.resources_total_size_bytes = 10 + 11;
594 597
595 std::vector<Resource> resources1; 598 std::vector<Resource> resources1;
596 resources1.push_back(CreateResource(1, URL(origin, "/resource1"))); 599 resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 10));
597 resources1.push_back(CreateResource(2, URL(origin, "/resource2"))); 600 resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 11));
598 601
599 int64 deleted_version_id = 222; // Dummy inital value 602 int64 deleted_version_id = 222; // Dummy inital value
600 std::vector<int64> newly_purgeable_resources; 603 std::vector<int64> newly_purgeable_resources;
601 604
602 EXPECT_EQ( 605 EXPECT_EQ(
603 ServiceWorkerDatabase::STATUS_OK, 606 ServiceWorkerDatabase::STATUS_OK,
604 database->WriteRegistration( 607 database->WriteRegistration(
605 data, resources1, &deleted_version_id, &newly_purgeable_resources)); 608 data, resources1, &deleted_version_id, &newly_purgeable_resources));
606 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version_id); 609 EXPECT_EQ(kInvalidServiceWorkerVersionId, deleted_version_id);
607 EXPECT_TRUE(newly_purgeable_resources.empty()); 610 EXPECT_TRUE(newly_purgeable_resources.empty());
608 611
609 // Make sure that the registration and resource records are stored. 612 // Make sure that the registration and resource records are stored.
610 RegistrationData data_out; 613 RegistrationData data_out;
611 std::vector<Resource> resources_out; 614 std::vector<Resource> resources_out;
612 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration( 615 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
613 data.registration_id, origin, &data_out, &resources_out)); 616 data.registration_id, origin, &data_out, &resources_out));
614 VerifyRegistrationData(data, data_out); 617 VerifyRegistrationData(data, data_out);
615 VerifyResourceRecords(resources1, resources_out); 618 VerifyResourceRecords(resources1, resources_out);
616 619
617 // Update the registration. 620 // Update the registration.
618 RegistrationData updated_data = data; 621 RegistrationData updated_data = data;
619 updated_data.version_id = data.version_id + 1; 622 updated_data.version_id = data.version_id + 1;
623 updated_data.resources_total_size_bytes = 12 + 13;
620 std::vector<Resource> resources2; 624 std::vector<Resource> resources2;
621 resources2.push_back(CreateResource(3, URL(origin, "/resource3"))); 625 resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 12));
622 resources2.push_back(CreateResource(4, URL(origin, "/resource4"))); 626 resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 13));
623 627
624 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, 628 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
625 database->WriteRegistration(updated_data, 629 database->WriteRegistration(updated_data,
626 resources2, 630 resources2,
627 &deleted_version_id, 631 &deleted_version_id,
628 &newly_purgeable_resources)); 632 &newly_purgeable_resources));
629 EXPECT_EQ(data.version_id, deleted_version_id); 633 EXPECT_EQ(data.version_id, deleted_version_id);
630 ASSERT_EQ(resources1.size(), newly_purgeable_resources.size()); 634 ASSERT_EQ(resources1.size(), newly_purgeable_resources.size());
631 for (size_t i = 0; i < resources1.size(); ++i) 635 for (size_t i = 0; i < resources1.size(); ++i)
632 EXPECT_EQ(newly_purgeable_resources[i], resources1[i].resource_id); 636 EXPECT_EQ(newly_purgeable_resources[i], resources1[i].resource_id);
(...skipping 20 matching lines...) Expand all
653 657
654 int64 deleted_version_id; 658 int64 deleted_version_id;
655 std::vector<int64> newly_purgeable_resources; 659 std::vector<int64> newly_purgeable_resources;
656 660
657 // Add registration1. 661 // Add registration1.
658 RegistrationData data1; 662 RegistrationData data1;
659 data1.registration_id = 100; 663 data1.registration_id = 100;
660 data1.scope = URL(origin, "/foo"); 664 data1.scope = URL(origin, "/foo");
661 data1.script = URL(origin, "/script1.js"); 665 data1.script = URL(origin, "/script1.js");
662 data1.version_id = 200; 666 data1.version_id = 200;
667 data1.resources_total_size_bytes = 1451 + 15234;
663 668
664 std::vector<Resource> resources1; 669 std::vector<Resource> resources1;
665 resources1.push_back(CreateResource(1, URL(origin, "/resource1"))); 670 resources1.push_back(CreateResource(1, URL(origin, "/resource1"), 1451));
666 resources1.push_back(CreateResource(2, URL(origin, "/resource2"))); 671 resources1.push_back(CreateResource(2, URL(origin, "/resource2"), 15234));
667 EXPECT_EQ( 672 EXPECT_EQ(
668 ServiceWorkerDatabase::STATUS_OK, 673 ServiceWorkerDatabase::STATUS_OK,
669 database->WriteRegistration( 674 database->WriteRegistration(
670 data1, resources1, &deleted_version_id, &newly_purgeable_resources)); 675 data1, resources1, &deleted_version_id, &newly_purgeable_resources));
671 676
672 // Add registration2. 677 // Add registration2.
673 RegistrationData data2; 678 RegistrationData data2;
674 data2.registration_id = 101; 679 data2.registration_id = 101;
675 data2.scope = URL(origin, "/bar"); 680 data2.scope = URL(origin, "/bar");
676 data2.script = URL(origin, "/script2.js"); 681 data2.script = URL(origin, "/script2.js");
677 data2.version_id = 201; 682 data2.version_id = 201;
683 data2.resources_total_size_bytes = 5 + 6;
678 684
679 std::vector<Resource> resources2; 685 std::vector<Resource> resources2;
680 resources2.push_back(CreateResource(3, URL(origin, "/resource3"))); 686 resources2.push_back(CreateResource(3, URL(origin, "/resource3"), 5));
681 resources2.push_back(CreateResource(4, URL(origin, "/resource4"))); 687 resources2.push_back(CreateResource(4, URL(origin, "/resource4"), 6));
682 EXPECT_EQ( 688 EXPECT_EQ(
683 ServiceWorkerDatabase::STATUS_OK, 689 ServiceWorkerDatabase::STATUS_OK,
684 database->WriteRegistration( 690 database->WriteRegistration(
685 data2, resources2, &deleted_version_id, &newly_purgeable_resources)); 691 data2, resources2, &deleted_version_id, &newly_purgeable_resources));
686 692
687 // Make sure that registration1 is stored. 693 // Make sure that registration1 is stored.
688 RegistrationData data_out; 694 RegistrationData data_out;
689 std::vector<Resource> resources_out; 695 std::vector<Resource> resources_out;
690 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration( 696 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
691 data1.registration_id, origin, &data_out, &resources_out)); 697 data1.registration_id, origin, &data_out, &resources_out));
(...skipping 258 matching lines...) Expand 10 before | Expand all | Expand 10 after
950 // Data associated with |origin1| will be removed. 956 // Data associated with |origin1| will be removed.
951 GURL origin1("http://example.com"); 957 GURL origin1("http://example.com");
952 GURL origin2("http://example.org"); 958 GURL origin2("http://example.org");
953 959
954 // |origin1| has two registrations. 960 // |origin1| has two registrations.
955 RegistrationData data1; 961 RegistrationData data1;
956 data1.registration_id = 10; 962 data1.registration_id = 10;
957 data1.scope = URL(origin1, "/foo"); 963 data1.scope = URL(origin1, "/foo");
958 data1.script = URL(origin1, "/script1.js"); 964 data1.script = URL(origin1, "/script1.js");
959 data1.version_id = 100; 965 data1.version_id = 100;
966 data1.resources_total_size_bytes = 2013 + 512;
960 967
961 std::vector<Resource> resources1; 968 std::vector<Resource> resources1;
962 resources1.push_back(CreateResource(1, URL(origin1, "/resource1"))); 969 resources1.push_back(CreateResource(1, URL(origin1, "/resource1"), 2013));
963 resources1.push_back(CreateResource(2, URL(origin1, "/resource2"))); 970 resources1.push_back(CreateResource(2, URL(origin1, "/resource2"), 512));
964 ASSERT_EQ( 971 ASSERT_EQ(
965 ServiceWorkerDatabase::STATUS_OK, 972 ServiceWorkerDatabase::STATUS_OK,
966 database->WriteRegistration( 973 database->WriteRegistration(
967 data1, resources1, &deleted_version_id, &newly_purgeable_resources)); 974 data1, resources1, &deleted_version_id, &newly_purgeable_resources));
968 975
969 RegistrationData data2; 976 RegistrationData data2;
970 data2.registration_id = 11; 977 data2.registration_id = 11;
971 data2.scope = URL(origin1, "/bar"); 978 data2.scope = URL(origin1, "/bar");
972 data2.script = URL(origin1, "/script2.js"); 979 data2.script = URL(origin1, "/script2.js");
973 data2.version_id = 101; 980 data2.version_id = 101;
981 data2.resources_total_size_bytes = 4 + 5;
974 982
975 std::vector<Resource> resources2; 983 std::vector<Resource> resources2;
976 resources2.push_back(CreateResource(3, URL(origin1, "/resource3"))); 984 resources2.push_back(CreateResource(3, URL(origin1, "/resource3"), 4));
977 resources2.push_back(CreateResource(4, URL(origin1, "/resource4"))); 985 resources2.push_back(CreateResource(4, URL(origin1, "/resource4"), 5));
978 ASSERT_EQ( 986 ASSERT_EQ(
979 ServiceWorkerDatabase::STATUS_OK, 987 ServiceWorkerDatabase::STATUS_OK,
980 database->WriteRegistration( 988 database->WriteRegistration(
981 data2, resources2, &deleted_version_id, &newly_purgeable_resources)); 989 data2, resources2, &deleted_version_id, &newly_purgeable_resources));
982 990
983 // |origin2| has one registration. 991 // |origin2| has one registration.
984 RegistrationData data3; 992 RegistrationData data3;
985 data3.registration_id = 12; 993 data3.registration_id = 12;
986 data3.scope = URL(origin2, "/hoge"); 994 data3.scope = URL(origin2, "/hoge");
987 data3.script = URL(origin2, "/script3.js"); 995 data3.script = URL(origin2, "/script3.js");
988 data3.version_id = 102; 996 data3.version_id = 102;
997 data3.resources_total_size_bytes = 6 + 7;
989 998
990 std::vector<Resource> resources3; 999 std::vector<Resource> resources3;
991 resources3.push_back(CreateResource(5, URL(origin2, "/resource5"))); 1000 resources3.push_back(CreateResource(5, URL(origin2, "/resource5"), 6));
992 resources3.push_back(CreateResource(6, URL(origin2, "/resource6"))); 1001 resources3.push_back(CreateResource(6, URL(origin2, "/resource6"), 7));
993 ASSERT_EQ( 1002 ASSERT_EQ(
994 ServiceWorkerDatabase::STATUS_OK, 1003 ServiceWorkerDatabase::STATUS_OK,
995 database->WriteRegistration( 1004 database->WriteRegistration(
996 data3, resources3, &deleted_version_id, &newly_purgeable_resources)); 1005 data3, resources3, &deleted_version_id, &newly_purgeable_resources));
997 1006
998 std::set<GURL> origins_to_delete; 1007 std::set<GURL> origins_to_delete;
999 origins_to_delete.insert(origin1); 1008 origins_to_delete.insert(origin1);
1000 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, 1009 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
1001 database->DeleteAllDataForOrigins(origins_to_delete, 1010 database->DeleteAllDataForOrigins(origins_to_delete,
1002 &newly_purgeable_resources)); 1011 &newly_purgeable_resources));
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
1040 CreateDatabase(database_dir.path())); 1049 CreateDatabase(database_dir.path()));
1041 1050
1042 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true)); 1051 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->LazyOpen(true));
1043 ASSERT_TRUE(base::DirectoryExists(database_dir.path())); 1052 ASSERT_TRUE(base::DirectoryExists(database_dir.path()));
1044 1053
1045 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase()); 1054 EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->DestroyDatabase());
1046 ASSERT_FALSE(base::DirectoryExists(database_dir.path())); 1055 ASSERT_FALSE(base::DirectoryExists(database_dir.path()));
1047 } 1056 }
1048 1057
1049 } // namespace content 1058 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698