ServiceWorker: Database functions should return status code instead of boolean

content/browser/service_worker/service_worker_database_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_database.h"
 
 #include <string>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/stl_util.h"
@@ skipping 113 matching lines @@
 TEST(ServiceWorkerDatabaseTest, GetNextAvailableIds) {
   base::ScopedTempDir database_dir;
   ASSERT_TRUE(database_dir.CreateUniqueTempDir());
   scoped_ptr<ServiceWorkerDatabase> database(
       CreateDatabase(database_dir.path()));
 
   GURL origin("http://example.com");
 
   // The database has never been used, so returns initial values.
   AvailableIds ids;
-  EXPECT_TRUE(database->GetNextAvailableIds(
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetNextAvailableIds(
       &ids.reg_id, &ids.ver_id, &ids.res_id));
   EXPECT_EQ(0, ids.reg_id);
   EXPECT_EQ(0, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
 
   ASSERT_TRUE(database->LazyOpen(true));
-  EXPECT_TRUE(database->GetNextAvailableIds(
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetNextAvailableIds(
       &ids.reg_id, &ids.ver_id, &ids.res_id));
   EXPECT_EQ(0, ids.reg_id);
   EXPECT_EQ(0, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
 
   // Writing a registration bumps the next available ids.
   std::vector<Resource> resources;
   RegistrationData data1;
   data1.registration_id = 100;
   data1.scope = URL(origin, "/foo");
   data1.script = URL(origin, "/script1.js");
   data1.version_id = 200;
   ASSERT_TRUE(database->WriteRegistration(data1, resources));
 
-  EXPECT_TRUE(database->GetNextAvailableIds(
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetNextAvailableIds(
       &ids.reg_id, &ids.ver_id, &ids.res_id));
   EXPECT_EQ(101, ids.reg_id);
   EXPECT_EQ(201, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
 
   // Writing a registration whose ids are lower than the stored ones should not
   // bump the next available ids.
   RegistrationData data2;
   data2.registration_id = 10;
   data2.scope = URL(origin, "/bar");
   data2.script = URL(origin, "/script2.js");
   data2.version_id = 20;
   ASSERT_TRUE(database->WriteRegistration(data2, resources));
 
   // Close and reopen the database to verify the stored values.
   database.reset(CreateDatabase(database_dir.path()));
 
-  EXPECT_TRUE(database->GetNextAvailableIds(
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetNextAvailableIds(
       &ids.reg_id, &ids.ver_id, &ids.res_id));
   EXPECT_EQ(101, ids.reg_id);
   EXPECT_EQ(201, ids.ver_id);
   EXPECT_EQ(0, ids.res_id);
 }
 
 TEST(ServiceWorkerDatabaseTest, GetOriginsWithRegistrations) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   std::set<GURL> origins;
-  EXPECT_TRUE(database->GetOriginsWithRegistrations(&origins));
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetOriginsWithRegistrations(&origins));
   EXPECT_TRUE(origins.empty());
 
   std::vector<Resource> resources;
 
   GURL origin1("http://example.com");
   RegistrationData data1;
   data1.registration_id = 123;
   data1.scope = URL(origin1, "/foo");
   data1.script = URL(origin1, "/script1.js");
   data1.version_id = 456;
@@ skipping 17 matching lines @@
 
   // |origin3| has two registrations.
   RegistrationData data4;
   data4.registration_id = 456;
   data4.scope = URL(origin3, "/fuga");
   data4.script = URL(origin3, "/script4.js");
   data4.version_id = 789;
   ASSERT_TRUE(database->WriteRegistration(data4, resources));
 
   origins.clear();
-  EXPECT_TRUE(database->GetOriginsWithRegistrations(&origins));
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetOriginsWithRegistrations(&origins));
   EXPECT_EQ(3U, origins.size());
   EXPECT_TRUE(ContainsKey(origins, origin1));
   EXPECT_TRUE(ContainsKey(origins, origin2));
   EXPECT_TRUE(ContainsKey(origins, origin3));
 
   // |origin3| has another registration, so should not remove it from the
   // unique origin list.
   ASSERT_TRUE(database->DeleteRegistration(data4.registration_id, origin3));
 
   origins.clear();
-  EXPECT_TRUE(database->GetOriginsWithRegistrations(&origins));
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetOriginsWithRegistrations(&origins));
   EXPECT_EQ(3U, origins.size());
   EXPECT_TRUE(ContainsKey(origins, origin1));
   EXPECT_TRUE(ContainsKey(origins, origin2));
   EXPECT_TRUE(ContainsKey(origins, origin3));
 
   // |origin3| should be removed from the unique origin list.
   ASSERT_TRUE(database->DeleteRegistration(data3.registration_id, origin3));
 
   origins.clear();
-  EXPECT_TRUE(database->GetOriginsWithRegistrations(&origins));
+  EXPECT_EQ(SERVICE_WORKER_OK, database->GetOriginsWithRegistrations(&origins));
   EXPECT_EQ(2U, origins.size());
   EXPECT_TRUE(ContainsKey(origins, origin1));
   EXPECT_TRUE(ContainsKey(origins, origin2));
 }
 
 TEST(ServiceWorkerDatabaseTest, GetRegistrationsForOrigin) {
   scoped_ptr<ServiceWorkerDatabase> database(CreateDatabaseInMemory());
 
   GURL origin1("http://example.com");
   GURL origin2("https://www.example.com");
@@ skipping 377 matching lines @@
 
   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));
 
   EXPECT_TRUE(database->DeleteAllDataForOrigin(origin1));
 
   // |origin1| should be removed from the unique origin list.
   std::set<GURL> unique_origins;
-  EXPECT_TRUE(database->GetOriginsWithRegistrations(&unique_origins));
+  EXPECT_EQ(SERVICE_WORKER_OK,
+            database->GetOriginsWithRegistrations(&unique_origins));
   EXPECT_EQ(1u, unique_origins.size());
   EXPECT_TRUE(ContainsKey(unique_origins, origin2));
 
   // The registrations for |origin1| should be removed.
   std::vector<RegistrationData> registrations;
   EXPECT_TRUE(database->GetRegistrationsForOrigin(origin1, &registrations));
   EXPECT_TRUE(registrations.empty());
 
   // The registration for |origin2| should not be removed.
   RegistrationData data_out;
   std::vector<Resource> resources_out;
   EXPECT_TRUE(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(4u, purgeable_ids_out.size());
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 1));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 2));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 3));
   EXPECT_TRUE(ContainsKey(purgeable_ids_out, 4));
 }
 
 }  // namespace content