ServiceWorker: DB functions should return status code instead of boolean (3)

content/browser/service_worker/service_worker_database_unittest.cc

Index: content/browser/service_worker/service_worker_database_unittest.cc
diff --git a/content/browser/service_worker/service_worker_database_unittest.cc b/content/browser/service_worker/service_worker_database_unittest.cc
index bc41c7d652e614efa736d64eb6def5847e92e9ea..aa2cea29383f3824a113ab8f46f380c35c7945f8 100644
--- a/content/browser/service_worker/service_worker_database_unittest.cc
+++ b/content/browser/service_worker/service_worker_database_unittest.cc
@@ -119,7 +119,8 @@ TEST(ServiceWorkerDatabaseTest, DatabaseVersion) {
   // version.
   std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
   ServiceWorkerDatabase::RegistrationData data;
-  ASSERT_TRUE(database->WriteRegistration(data, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, resources));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
             database->ReadDatabaseVersion(&db_version));
@@ -156,7 +157,8 @@ TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) {
   data1.scope = URL(origin, "/foo");
   data1.script = URL(origin, "/script1.js");
   data1.version_id = 200;
-  ASSERT_TRUE(database->WriteRegistration(data1, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data1, resources));
 
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->GetNextAvailableIds(
       &ids.reg_id, &ids.ver_id, &ids.res_id));
@@ -171,7 +173,8 @@ TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) {
   data2.scope = URL(origin, "/bar");
   data2.script = URL(origin, "/script2.js");
   data2.version_id = 20;
-  ASSERT_TRUE(database->WriteRegistration(data2, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data2, resources));
 
   // Close and reopen the database to verify the stored values.
   database.reset(CreateDatabase(database_dir.path()));
@@ -199,7 +202,8 @@ TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   data1.scope = URL(origin1, "/foo");
   data1.script = URL(origin1, "/script1.js");
   data1.version_id = 456;
-  ASSERT_TRUE(database->WriteRegistration(data1, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data1, resources));
 
   GURL origin2("https://www.example.com");
   RegistrationData data2;
@@ -207,7 +211,8 @@ TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   data2.scope = URL(origin2, "/bar");
   data2.script = URL(origin2, "/script2.js");
   data2.version_id = 567;
-  ASSERT_TRUE(database->WriteRegistration(data2, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data2, resources));
 
   GURL origin3("https://example.org");
   RegistrationData data3;
@@ -215,7 +220,8 @@ TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   data3.scope = URL(origin3, "/hoge");
   data3.script = URL(origin3, "/script3.js");
   data3.version_id = 678;
-  ASSERT_TRUE(database->WriteRegistration(data3, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data3, resources));
 
   // |origin3| has two registrations.
   RegistrationData data4;
@@ -223,7 +229,8 @@ TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   data4.scope = URL(origin3, "/fuga");
   data4.script = URL(origin3, "/script4.js");
   data4.version_id = 789;
-  ASSERT_TRUE(database->WriteRegistration(data4, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data4, resources));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ -235,7 +242,8 @@ TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
 
   // |origin3| has another registration, so should not remove it from the
   // unique origin list.
-  ASSERT_TRUE(database->DeleteRegistration(data4.registration_id, origin3));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data4.registration_id, origin3));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ -246,7 +254,8 @@ TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   EXPECT_TRUE(ContainsKey(origins, origin3));
 
   // |origin3| should be removed from the unique origin list.
-  ASSERT_TRUE(database->DeleteRegistration(data3.registration_id, origin3));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data3.registration_id, origin3));
 
   origins.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ -275,21 +284,24 @@ TEST(ServiceWorkerDatabaseTest, GetRegistrationsForOrigin) {
   data1.scope = URL(origin1, "/foo");
   data1.script = URL(origin1, "/script1.js");
   data1.version_id = 1000;
-  ASSERT_TRUE(database->WriteRegistration(data1, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data1, resources));
 
   RegistrationData data2;
   data2.registration_id = 200;
   data2.scope = URL(origin2, "/bar");
   data2.script = URL(origin2, "/script2.js");
   data2.version_id = 2000;
-  ASSERT_TRUE(database->WriteRegistration(data2, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data2, resources));
 
   RegistrationData data3;
   data3.registration_id = 300;
   data3.scope = URL(origin3, "/hoge");
   data3.script = URL(origin3, "/script3.js");
   data3.version_id = 3000;
-  ASSERT_TRUE(database->WriteRegistration(data3, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data3, resources));
 
   // |origin3| has two registrations.
   RegistrationData data4;
@@ -297,7 +309,8 @@ TEST(ServiceWorkerDatabaseTest, GetRegistrationsForOrigin) {
   data4.scope = URL(origin3, "/fuga");
   data4.script = URL(origin3, "/script4.js");
   data4.version_id = 4000;
-  ASSERT_TRUE(database->WriteRegistration(data4, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data4, resources));
 
   registrations.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ -323,7 +336,8 @@ TEST(ServiceWorkerDatabaseTest, GetAllRegistrations) {
   data1.scope = URL(origin1, "/foo");
   data1.script = URL(origin1, "/script1.js");
   data1.version_id = 1000;
-  ASSERT_TRUE(database->WriteRegistration(data1, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data1, resources));
 
   GURL origin2("http://www2.example.com");
   RegistrationData data2;
@@ -331,7 +345,8 @@ TEST(ServiceWorkerDatabaseTest, GetAllRegistrations) {
   data2.scope = URL(origin2, "/bar");
   data2.script = URL(origin2, "/script2.js");
   data2.version_id = 2000;
-  ASSERT_TRUE(database->WriteRegistration(data2, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data2, resources));
 
   GURL origin3("http://www3.example.com");
   RegistrationData data3;
@@ -339,7 +354,8 @@ TEST(ServiceWorkerDatabaseTest, GetAllRegistrations) {
   data3.scope = URL(origin3, "/hoge");
   data3.script = URL(origin3, "/script3.js");
   data3.version_id = 3000;
-  ASSERT_TRUE(database->WriteRegistration(data3, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data3, resources));
 
   // |origin3| has two registrations.
   RegistrationData data4;
@@ -347,7 +363,8 @@ TEST(ServiceWorkerDatabaseTest, GetAllRegistrations) {
   data4.scope = URL(origin3, "/fuga");
   data4.script = URL(origin3, "/script4.js");
   data4.version_id = 4000;
-  ASSERT_TRUE(database->WriteRegistration(data4, resources));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data4, resources));
 
   registrations.clear();
   EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
@@ -378,37 +395,45 @@ TEST(ServiceWorkerDatabaseTest, Registration_Basic) {
   // the uncommitted list.
   std::set<int64> uncommitted_ids;
   uncommitted_ids.insert(resources[0].resource_id);
-  EXPECT_TRUE(database->WriteUncommittedResourceIds(uncommitted_ids));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUncommittedResourceIds(uncommitted_ids));
   std::set<int64> uncommitted_ids_out;
-  EXPECT_TRUE(database->GetUncommittedResourceIds(&uncommitted_ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetUncommittedResourceIds(&uncommitted_ids_out));
   EXPECT_EQ(uncommitted_ids, uncommitted_ids_out);
 
-  EXPECT_TRUE(database->WriteRegistration(data, resources));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, resources));
 
   // Make sure that the registration and resource records are stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
-  EXPECT_TRUE(database->ReadRegistration(
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ReadRegistration(
       data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data, data_out);
   VerifyResourceRecords(resources, resources_out);
 
   // Make sure that the resource is removed from the uncommitted list.
   uncommitted_ids_out.clear();
-  EXPECT_TRUE(database->GetUncommittedResourceIds(&uncommitted_ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetUncommittedResourceIds(&uncommitted_ids_out));
   EXPECT_TRUE(uncommitted_ids_out.empty());
 
-  EXPECT_TRUE(database->DeleteRegistration(data.registration_id, origin));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data.registration_id, origin));
 
   // Make sure that the registration and resource records are gone.
   resources_out.clear();
-  EXPECT_FALSE(database->ReadRegistration(
-      data.registration_id, origin, &data_out, &resources_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->ReadRegistration(
+                data.registration_id, origin, &data_out, &resources_out));
   EXPECT_TRUE(resources_out.empty());
 
   // Resources should be purgeable because these are no longer referred.
   std::set<int64> purgeable_ids_out;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(2u, purgeable_ids_out.size());
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[0].resource_id));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources[1].resource_id));
@@ -428,12 +453,13 @@ TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) {
   resources1.push_back(CreateResource(1, URL(origin, "/resource1")));
   resources1.push_back(CreateResource(2, URL(origin, "/resource2")));
 
-  EXPECT_TRUE(database->WriteRegistration(data, resources1));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, resources1));
 
   // Make sure that the registration and resource records are stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
-  EXPECT_TRUE(database->ReadRegistration(
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data, data_out);
   VerifyResourceRecords(resources1, resources_out);
@@ -445,18 +471,20 @@ TEST(ServiceWorkerDatabaseTest, Registration_Overwrite) {
   resources2.push_back(CreateResource(3, URL(origin, "/resource3")));
   resources2.push_back(CreateResource(4, URL(origin, "/resource4")));
 
-  EXPECT_TRUE(database->WriteRegistration(updated_data, resources2));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(updated_data, resources2));
 
   // Make sure that |updated_data| is stored and resources referred from |data|
   // is moved to the purgeable list.
   resources_out.clear();
-  EXPECT_TRUE(database->ReadRegistration(
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       updated_data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(updated_data, data_out);
   VerifyResourceRecords(resources2, resources_out);
 
   std::set<int64> purgeable_ids_out;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(2u, purgeable_ids_out.size());
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
@@ -476,7 +504,8 @@ TEST(ServiceWorkerDatabaseTest, Registration_Multiple) {
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, URL(origin, "/resource1")));
   resources1.push_back(CreateResource(2, URL(origin, "/resource2")));
-  EXPECT_TRUE(database->WriteRegistration(data1, resources1));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data1, resources1));
 
   // Add registration2.
   RegistrationData data2;
@@ -488,45 +517,50 @@ TEST(ServiceWorkerDatabaseTest, Registration_Multiple) {
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(3, URL(origin, "/resource3")));
   resources2.push_back(CreateResource(4, URL(origin, "/resource4")));
-  EXPECT_TRUE(database->WriteRegistration(data2, resources2));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data2, resources2));
 
   // Make sure that registration1 is stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
-  EXPECT_TRUE(database->ReadRegistration(
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data1.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data1, data_out);
   VerifyResourceRecords(resources1, resources_out);
 
   // Make sure that registration2 is also stored.
   resources_out.clear();
-  EXPECT_TRUE(database->ReadRegistration(
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data2.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data2, data_out);
   VerifyResourceRecords(resources2, resources_out);
 
   std::set<int64> purgeable_ids_out;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_TRUE(purgeable_ids_out.empty());
 
   // Delete registration1.
-  EXPECT_TRUE(database->DeleteRegistration(data1.registration_id, origin));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data1.registration_id, origin));
 
   // Make sure that registration1 is gone.
   resources_out.clear();
-  EXPECT_FALSE(database->ReadRegistration(
-      data1.registration_id, origin, &data_out, &resources_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->ReadRegistration(
+                data1.registration_id, origin, &data_out, &resources_out));
   EXPECT_TRUE(resources_out.empty());
 
   purgeable_ids_out.clear();
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(2u, purgeable_ids_out.size());
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[0].resource_id));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, resources1[1].resource_id));
 
   // Make sure that registration2 is still alive.
   resources_out.clear();
-  EXPECT_TRUE(database->ReadRegistration(
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data2.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data2, data_out);
   VerifyResourceRecords(resources2, resources_out);
@@ -537,7 +571,8 @@ TEST(ServiceWorkerDatabaseTest, UpdateVersionToActive) {
   GURL origin("http://example.com");
 
   // Should be false because a registration does not exist.
-  EXPECT_FALSE(database->UpdateVersionToActive(0, origin));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->UpdateVersionToActive(0, origin));
 
   // Add a registration.
   RegistrationData data;
@@ -546,33 +581,39 @@ TEST(ServiceWorkerDatabaseTest, UpdateVersionToActive) {
   data.script = URL(origin, "/script.js");
   data.version_id = 200;
   data.is_active = false;
-  EXPECT_TRUE(database->WriteRegistration(data, std::vector<Resource>()));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, std::vector<Resource>()));
 
   // Make sure that the registration is stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
-  EXPECT_TRUE(database->ReadRegistration(
-      data.registration_id, origin, &data_out, &resources_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ReadRegistration(
+                data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data, data_out);
   EXPECT_TRUE(resources_out.empty());
 
   // Activate the registration.
-  EXPECT_TRUE(database->UpdateVersionToActive(data.registration_id, origin));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->UpdateVersionToActive(data.registration_id, origin));
 
   // Make sure that the registration is activated.
   resources_out.clear();
-  EXPECT_TRUE(database->ReadRegistration(
-      data.registration_id, origin, &data_out, &resources_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ReadRegistration(
+                data.registration_id, origin, &data_out, &resources_out));
   RegistrationData expected_data = data;
   expected_data.is_active = true;
   VerifyRegistrationData(expected_data, data_out);
   EXPECT_TRUE(resources_out.empty());
 
   // Delete the registration.
-  EXPECT_TRUE(database->DeleteRegistration(data.registration_id, origin));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data.registration_id, origin));
 
   // Should be false because the registration is gone.
-  EXPECT_FALSE(database->UpdateVersionToActive(data.registration_id, origin));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->UpdateVersionToActive(data.registration_id, origin));
 }
 
 TEST(ServiceWorkerDatabaseTest, UpdateLastCheckTime) {
@@ -580,7 +621,8 @@ TEST(ServiceWorkerDatabaseTest, UpdateLastCheckTime) {
   GURL origin("http://example.com");
 
   // Should be false because a registration does not exist.
-  EXPECT_FALSE(database->UpdateLastCheckTime(0, origin, base::Time::Now()));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->UpdateLastCheckTime(0, origin, base::Time::Now()));
 
   // Add a registration.
   RegistrationData data;
@@ -589,36 +631,42 @@ TEST(ServiceWorkerDatabaseTest, UpdateLastCheckTime) {
   data.script = URL(origin, "/script.js");
   data.version_id = 200;
   data.last_update_check = base::Time::Now();
-  EXPECT_TRUE(database->WriteRegistration(data, std::vector<Resource>()));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data, std::vector<Resource>()));
 
   // Make sure that the registration is stored.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
-  EXPECT_TRUE(database->ReadRegistration(
-      data.registration_id, origin, &data_out, &resources_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ReadRegistration(
+                data.registration_id, origin, &data_out, &resources_out));
   VerifyRegistrationData(data, data_out);
   EXPECT_TRUE(resources_out.empty());
 
   // Update the last check time.
   base::Time updated_time = base::Time::Now();
-  EXPECT_TRUE(database->UpdateLastCheckTime(
-      data.registration_id, origin, updated_time));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->UpdateLastCheckTime(
+                data.registration_id, origin, updated_time));
 
   // Make sure that the registration is updated.
   resources_out.clear();
-  EXPECT_TRUE(database->ReadRegistration(
-      data.registration_id, origin, &data_out, &resources_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ReadRegistration(
+                data.registration_id, origin, &data_out, &resources_out));
   RegistrationData expected_data = data;
   expected_data.last_update_check = updated_time;
   VerifyRegistrationData(expected_data, data_out);
   EXPECT_TRUE(resources_out.empty());
 
   // Delete the registration.
-  EXPECT_TRUE(database->DeleteRegistration(data.registration_id, origin));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteRegistration(data.registration_id, origin));
 
   // Should be false because the registration is gone.
-  EXPECT_FALSE(database->UpdateLastCheckTime(
-      data.registration_id, origin, base::Time::Now()));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND,
+            database->UpdateLastCheckTime(
+                data.registration_id, origin, base::Time::Now()));
 }
 
 TEST(ServiceWorkerDatabaseTest, UncommittedResourceIds) {
@@ -629,20 +677,24 @@ TEST(ServiceWorkerDatabaseTest, UncommittedResourceIds) {
   ids1.insert(1);
   ids1.insert(2);
   ids1.insert(3);
-  EXPECT_TRUE(database->WriteUncommittedResourceIds(ids1));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUncommittedResourceIds(ids1));
 
   std::set<int64> ids_out;
-  EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetUncommittedResourceIds(&ids_out));
   EXPECT_EQ(ids1, ids_out);
 
   // Write {2, 4}.
   std::set<int64> ids2;
   ids2.insert(2);
   ids2.insert(4);
-  EXPECT_TRUE(database->WriteUncommittedResourceIds(ids2));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteUncommittedResourceIds(ids2));
 
   ids_out.clear();
-  EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetUncommittedResourceIds(&ids_out));
   std::set<int64> expected = base::STLSetUnion<std::set<int64> >(ids1, ids2);
   EXPECT_EQ(expected, ids_out);
 
@@ -650,10 +702,12 @@ TEST(ServiceWorkerDatabaseTest, UncommittedResourceIds) {
   std::set<int64> ids3;
   ids3.insert(2);
   ids3.insert(3);
-  EXPECT_TRUE(database->ClearUncommittedResourceIds(ids3));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ClearUncommittedResourceIds(ids3));
 
   ids_out.clear();
-  EXPECT_TRUE(database->GetUncommittedResourceIds(&ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetUncommittedResourceIds(&ids_out));
   expected = base::STLSetDifference<std::set<int64> >(expected, ids3);
   EXPECT_EQ(expected, ids_out);
 }
@@ -666,20 +720,24 @@ TEST(ServiceWorkerDatabaseTest, PurgeableResourceIds) {
   ids1.insert(1);
   ids1.insert(2);
   ids1.insert(3);
-  EXPECT_TRUE(database->WritePurgeableResourceIds(ids1));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WritePurgeableResourceIds(ids1));
 
   std::set<int64> ids_out;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&ids_out));
   EXPECT_EQ(ids1, ids_out);
 
   // Write {2, 4}.
   std::set<int64> ids2;
   ids2.insert(2);
   ids2.insert(4);
-  EXPECT_TRUE(database->WritePurgeableResourceIds(ids2));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WritePurgeableResourceIds(ids2));
 
   ids_out.clear();
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&ids_out));
   std::set<int64> expected = base::STLSetUnion<std::set<int64> >(ids1, ids2);
   EXPECT_EQ(expected, ids_out);
 
@@ -687,10 +745,12 @@ TEST(ServiceWorkerDatabaseTest, PurgeableResourceIds) {
   std::set<int64> ids3;
   ids3.insert(2);
   ids3.insert(3);
-  EXPECT_TRUE(database->ClearPurgeableResourceIds(ids3));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->ClearPurgeableResourceIds(ids3));
 
   ids_out.clear();
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&ids_out));
   expected = base::STLSetDifference<std::set<int64> >(expected, ids3);
   EXPECT_EQ(expected, ids_out);
 }
@@ -712,7 +772,8 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   std::vector<Resource> resources1;
   resources1.push_back(CreateResource(1, URL(origin1, "/resource1")));
   resources1.push_back(CreateResource(2, URL(origin1, "/resource2")));
-  ASSERT_TRUE(database->WriteRegistration(data1, resources1));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data1, resources1));
 
   RegistrationData data2;
   data2.registration_id = 11;
@@ -723,7 +784,8 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   std::vector<Resource> resources2;
   resources2.push_back(CreateResource(3, URL(origin1, "/resource3")));
   resources2.push_back(CreateResource(4, URL(origin1, "/resource4")));
-  ASSERT_TRUE(database->WriteRegistration(data2, resources2));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data2, resources2));
 
   // |origin2| has one registration.
   RegistrationData data3;
@@ -735,9 +797,11 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   std::vector<Resource> resources3;
   resources3.push_back(CreateResource(5, URL(origin2, "/resource5")));
   resources3.push_back(CreateResource(6, URL(origin2, "/resource6")));
-  ASSERT_TRUE(database->WriteRegistration(data3, resources3));
+  ASSERT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->WriteRegistration(data3, resources3));
 
-  EXPECT_TRUE(database->DeleteAllDataForOrigin(origin1));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->DeleteAllDataForOrigin(origin1));
 
   // |origin1| should be removed from the unique origin list.
   std::set<GURL> unique_origins;
@@ -755,14 +819,15 @@ TEST(ServiceWorkerDatabaseTest, DeleteAllDataForOrigin) {
   // The registration for |origin2| should not be removed.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
-  EXPECT_TRUE(database->ReadRegistration(
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK, database->ReadRegistration(
       data3.registration_id, origin2, &data_out, &resources_out));
   VerifyRegistrationData(data3, data_out);
   VerifyResourceRecords(resources3, resources_out);
 
   // The resources associated with |origin1| should be purgeable.
   std::set<int64> purgeable_ids_out;
-  EXPECT_TRUE(database->GetPurgeableResourceIds(&purgeable_ids_out));
+  EXPECT_EQ(ServiceWorkerDatabase::STATUS_OK,
+            database->GetPurgeableResourceIds(&purgeable_ids_out));
   EXPECT_EQ(4u, purgeable_ids_out.size());
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 1));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 2));