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

Part1: https://codereview.chromium.org/275103004/
Part2: https://codereview.chromium.org/287843002/

This change makes all remaining functions return status code instead of boolean.


BUG=372704
TEST=should pass all existing tests

Review URL: https://codereview.chromium.org/284123003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@271342 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/service_worker/service_worker_database.cc

@@ -384,7 +384,7 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetAllRegistrations(
   return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::ReadRegistration(
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadRegistration(
     int64 registration_id,
     const GURL& origin,
     RegistrationData* registration,
@@ -395,25 +395,28 @@ bool ServiceWorkerDatabase::ReadRegistration(
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status) || status != STATUS_OK)
-    return false;
+    return status;
 
   RegistrationData value;
-  if (!ReadRegistrationData(registration_id, origin, &value))
-    return false;
+  status = ReadRegistrationData(registration_id, origin, &value);
+  if (status != STATUS_OK)
+    return status;
 
-  if (!ReadResourceRecords(value.version_id, resources))
-    return false;
+  status = ReadResourceRecords(value.version_id, resources);
+  if (status != STATUS_OK)
+    return status;
 
   *registration = value;
-  return true;
+  return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::WriteRegistration(
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteRegistration(
     const RegistrationData& registration,
     const std::vector<ResourceRecord>& resources) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-  if (LazyOpen(true) != STATUS_OK)
-    return false;
+  Status status = LazyOpen(true);
+  if (status != STATUS_OK)
+    return status;
 
   leveldb::WriteBatch batch;
   BumpNextRegistrationIdIfNeeded(registration.registration_id, &batch);
@@ -427,20 +430,20 @@ bool ServiceWorkerDatabase::WriteRegistration(
 
   // Retrieve a previous version to sweep purgeable resources.
   RegistrationData old_registration;
-  if (!ReadRegistrationData(registration.registration_id,
-                            registration.scope.GetOrigin(),
-                            &old_registration)) {
-    if (is_disabled_)
-      return false;
-    // Just not found.
-  } else {
+  status = ReadRegistrationData(registration.registration_id,
+                                registration.scope.GetOrigin(),
+                                &old_registration);
+  if (status != STATUS_OK && status != STATUS_ERROR_NOT_FOUND)
+    return status;
+  if (status == STATUS_OK) {
     DCHECK_LT(old_registration.version_id, registration.version_id);
     // Currently resource sharing across versions and registrations is not
     // suppported, so resource ids should not be overlapped between
     // |registration| and |old_registration|.
     // TODO(nhiroki): Add DCHECK to make sure the overlap does not exist.
-    if (!DeleteResourceRecords(old_registration.version_id, &batch))
-      return false;
+    status = DeleteResourceRecords(old_registration.version_id, &batch);
+    if (status != STATUS_OK)
+      return status;
   }
 
   // Used for avoiding multiple writes for the same resource id or url.
@@ -449,7 +452,7 @@ bool ServiceWorkerDatabase::WriteRegistration(
   for (std::vector<ResourceRecord>::const_iterator itr = resources.begin();
        itr != resources.end(); ++itr) {
     if (!itr->url.is_valid())
-      return false;
+      return STATUS_ERROR_FAILED;
 
     // Duplicated resource id or url should not exist.
     DCHECK(pushed_resources.insert(itr->resource_id).second);
@@ -465,16 +468,22 @@ bool ServiceWorkerDatabase::WriteRegistration(
   return WriteBatch(&batch);
 }
 
-bool ServiceWorkerDatabase::UpdateVersionToActive(int64 registration_id,
-                                                  const GURL& origin) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::UpdateVersionToActive(
+    int64 registration_id,
+    const GURL& origin) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   ServiceWorkerDatabase::Status status = LazyOpen(false);
-  if (IsNewOrNonexistentDatabase(status) || status != STATUS_OK)
-    return false;
+  if (IsNewOrNonexistentDatabase(status))
+    return STATUS_ERROR_NOT_FOUND;
+  if (status != STATUS_OK)
+    return status;
+  if (!origin.is_valid())
+    return STATUS_ERROR_FAILED;
 
   RegistrationData registration;
-  if (!ReadRegistrationData(registration_id, origin, &registration))
-    return false;
+  status = ReadRegistrationData(registration_id, origin, &registration);
+  if (status != STATUS_OK)
+    return status;
 
   registration.is_active = true;
 
@@ -483,17 +492,23 @@ bool ServiceWorkerDatabase::UpdateVersionToActive(int64 registration_id,
   return WriteBatch(&batch);
 }
 
-bool ServiceWorkerDatabase::UpdateLastCheckTime(int64 registration_id,
-                                                const GURL& origin,
-                                                const base::Time& time) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::UpdateLastCheckTime(
+    int64 registration_id,
+    const GURL& origin,
+    const base::Time& time) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   ServiceWorkerDatabase::Status status = LazyOpen(false);
-  if (IsNewOrNonexistentDatabase(status) || status != STATUS_OK)
-    return false;
+  if (IsNewOrNonexistentDatabase(status))
+    return STATUS_ERROR_NOT_FOUND;
+  if (status != STATUS_OK)
+    return status;
+  if (!origin.is_valid())
+    return STATUS_ERROR_FAILED;
 
   RegistrationData registration;
-  if (!ReadRegistrationData(registration_id, origin, &registration))
-    return false;
+  status = ReadRegistrationData(registration_id, origin, &registration);
+  if (status != STATUS_OK)
+    return status;
 
   registration.last_update_check = time;
 
@@ -502,14 +517,17 @@ bool ServiceWorkerDatabase::UpdateLastCheckTime(int64 registration_id,
   return WriteBatch(&batch);
 }
 
-bool ServiceWorkerDatabase::DeleteRegistration(int64 registration_id,
-                                               const GURL& origin) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteRegistration(
+    int64 registration_id,
+    const GURL& origin) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
-  if (status != STATUS_OK || !origin.is_valid())
-    return false;
+  if (status != STATUS_OK)
+    return status;
+  if (!origin.is_valid())
+    return STATUS_ERROR_FAILED;
 
   leveldb::WriteBatch batch;
 
@@ -517,8 +535,10 @@ bool ServiceWorkerDatabase::DeleteRegistration(int64 registration_id,
   // |registration_id| is the only one for |origin|.
   // TODO(nhiroki): Check the uniqueness by more efficient way.
   std::vector<RegistrationData> registrations;
-  if (GetRegistrationsForOrigin(origin, &registrations) != STATUS_OK)
-    return false;
+  status = GetRegistrationsForOrigin(origin, &registrations);
+  if (status != STATUS_OK)
+    return status;
+
   if (registrations.size() == 1 &&
       registrations[0].registration_id == registration_id) {
     batch.Delete(CreateUniqueOriginKey(origin));
@@ -531,8 +551,9 @@ bool ServiceWorkerDatabase::DeleteRegistration(int64 registration_id,
   for (std::vector<RegistrationData>::const_iterator itr =
            registrations.begin(); itr != registrations.end(); ++itr) {
     if (itr->registration_id == registration_id) {
-      if (!DeleteResourceRecords(itr->version_id, &batch))
-        return false;
+      status = DeleteResourceRecords(itr->version_id, &batch);
+      if (status != STATUS_OK)
+        return status;
       break;
     }
   }
@@ -540,41 +561,46 @@ bool ServiceWorkerDatabase::DeleteRegistration(int64 registration_id,
   return WriteBatch(&batch);
 }
 
-bool ServiceWorkerDatabase::GetUncommittedResourceIds(std::set<int64>* ids) {
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::GetUncommittedResourceIds(std::set<int64>* ids) {
   return ReadResourceIds(kUncommittedResIdKeyPrefix, ids);
 }
 
-bool ServiceWorkerDatabase::WriteUncommittedResourceIds(
-    const std::set<int64>& ids) {
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::WriteUncommittedResourceIds(const std::set<int64>& ids) {
   return WriteResourceIds(kUncommittedResIdKeyPrefix, ids);
 }
 
-bool ServiceWorkerDatabase::ClearUncommittedResourceIds(
-    const std::set<int64>& ids) {
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::ClearUncommittedResourceIds(const std::set<int64>& ids) {
   return DeleteResourceIds(kUncommittedResIdKeyPrefix, ids);
 }
 
-bool ServiceWorkerDatabase::GetPurgeableResourceIds(std::set<int64>* ids) {
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::GetPurgeableResourceIds(std::set<int64>* ids) {
   return ReadResourceIds(kPurgeableResIdKeyPrefix, ids);
 }
 
-bool ServiceWorkerDatabase::WritePurgeableResourceIds(
-    const std::set<int64>& ids) {
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::WritePurgeableResourceIds(const std::set<int64>& ids) {
   return WriteResourceIds(kPurgeableResIdKeyPrefix, ids);
 }
 
-bool ServiceWorkerDatabase::ClearPurgeableResourceIds(
-    const std::set<int64>& ids) {
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::ClearPurgeableResourceIds(const std::set<int64>& ids) {
   return DeleteResourceIds(kPurgeableResIdKeyPrefix, ids);
 }
 
-bool ServiceWorkerDatabase::DeleteAllDataForOrigin(const GURL& origin) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteAllDataForOrigin(
+    const GURL& origin) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
     return STATUS_OK;
-  if (status != STATUS_OK || !origin.is_valid())
-    return false;
+  if (status != STATUS_OK)
+    return status;
+  if (!origin.is_valid())
+    return STATUS_ERROR_FAILED;
 
   leveldb::WriteBatch batch;
 
@@ -582,15 +608,17 @@ bool ServiceWorkerDatabase::DeleteAllDataForOrigin(const GURL& origin) {
   batch.Delete(CreateUniqueOriginKey(origin));
 
   std::vector<RegistrationData> registrations;
-  if (GetRegistrationsForOrigin(origin, &registrations) != STATUS_OK)
-    return false;
+  status = GetRegistrationsForOrigin(origin, &registrations);
+  if (status != STATUS_OK)
+    return status;
 
   // Delete registrations and resource records.
   for (std::vector<RegistrationData>::const_iterator itr =
            registrations.begin(); itr != registrations.end(); ++itr) {
     batch.Delete(CreateRegistrationKey(itr->registration_id, origin));
-    if (!DeleteResourceRecords(itr->version_id, &batch))
-      return false;
+    status = DeleteResourceRecords(itr->version_id, &batch);
+    if (status != STATUS_OK)
+      return status;
   }
 
   return WriteBatch(&batch);
@@ -684,7 +712,7 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadNextAvailableId(
   return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::ReadRegistrationData(
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadRegistrationData(
     int64 registration_id,
     const GURL& origin,
     RegistrationData* registration) {
@@ -697,20 +725,20 @@ bool ServiceWorkerDatabase::ReadRegistrationData(
   if (!status.ok()) {
     if (!status.IsNotFound())
       HandleError(FROM_HERE, status);
-    return false;
+    return LevelDBStatusToStatus(status);
   }
 
   RegistrationData parsed;
   if (!ParseRegistrationData(value, &parsed)) {
     HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
-    return false;
+    return STATUS_ERROR_CORRUPTED;
   }
 
   *registration = parsed;
-  return true;
+  return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::ReadResourceRecords(
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceRecords(
     int64 version_id,
     std::vector<ResourceRecord>* resources) {
   DCHECK(resources);
@@ -721,7 +749,7 @@ bool ServiceWorkerDatabase::ReadResourceRecords(
     if (!itr->status().ok()) {
       HandleError(FROM_HERE, itr->status());
       resources->clear();
-      return false;
+      return LevelDBStatusToStatus(itr->status());
     }
 
     if (!RemovePrefix(itr->key().ToString(), prefix, NULL))
@@ -731,14 +759,14 @@ bool ServiceWorkerDatabase::ReadResourceRecords(
     if (!ParseResourceRecord(itr->value().ToString(), &resource)) {
       HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
       resources->clear();
-      return false;
+      return STATUS_ERROR_CORRUPTED;
     }
     resources->push_back(resource);
   }
-  return true;
+  return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::DeleteResourceRecords(
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceRecords(
     int64 version_id,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
@@ -748,7 +776,7 @@ bool ServiceWorkerDatabase::DeleteResourceRecords(
   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
     if (!itr->status().ok()) {
       HandleError(FROM_HERE, itr->status());
-      return false;
+      return LevelDBStatusToStatus(itr->status());
     }
 
     std::string key = itr->key().ToString();
@@ -759,7 +787,7 @@ bool ServiceWorkerDatabase::DeleteResourceRecords(
     int64 resource_id;
     if (!base::StringToInt64(unprefixed, &resource_id)) {
       HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
-      return false;
+      return STATUS_ERROR_CORRUPTED;
     }
 
     // Remove a resource record.
@@ -769,27 +797,28 @@ bool ServiceWorkerDatabase::DeleteResourceRecords(
     // supported, so we can purge this without caring about it.
     PutPurgeableResourceIdToBatch(resource_id, batch);
   }
-  return true;
+  return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::ReadResourceIds(const char* id_key_prefix,
-                                            std::set<int64>* ids) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceIds(
+    const char* id_key_prefix,
+    std::set<int64>* ids) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(id_key_prefix);
   DCHECK(ids->empty());
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
-    return true;
+    return STATUS_OK;
   if (status != STATUS_OK)
-    return false;
+    return status;
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->Seek(id_key_prefix); itr->Valid(); itr->Next()) {
     if (!itr->status().ok()) {
       HandleError(FROM_HERE, itr->status());
       ids->clear();
-      return false;
+      return LevelDBStatusToStatus(itr->status());
     }
 
     std::string unprefixed;
@@ -800,22 +829,24 @@ bool ServiceWorkerDatabase::ReadResourceIds(const char* id_key_prefix,
     if (!base::StringToInt64(unprefixed, &resource_id)) {
       HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
       ids->clear();
-      return false;
+      return STATUS_ERROR_CORRUPTED;
     }
     ids->insert(resource_id);
   }
-  return true;
+  return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::WriteResourceIds(const char* id_key_prefix,
-                                             const std::set<int64>& ids) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteResourceIds(
+    const char* id_key_prefix,
+    const std::set<int64>& ids) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(id_key_prefix);
 
-  if (LazyOpen(true) != STATUS_OK)
-    return false;
+  Status status = LazyOpen(true);
+  if (status != STATUS_OK)
+    return status;
   if (ids.empty())
-    return true;
+    return STATUS_OK;
 
   leveldb::WriteBatch batch;
   for (std::set<int64>::const_iterator itr = ids.begin();
@@ -823,28 +854,30 @@ bool ServiceWorkerDatabase::WriteResourceIds(const char* id_key_prefix,
     // Value should be empty.
     batch.Put(CreateResourceIdKey(id_key_prefix, *itr), "");
   }
+
   return WriteBatch(&batch);
 }
 
-bool ServiceWorkerDatabase::DeleteResourceIds(const char* id_key_prefix,
-                                              const std::set<int64>& ids) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceIds(
+    const char* id_key_prefix,
+    const std::set<int64>& ids) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(id_key_prefix);
 
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
-    return true;
+    return STATUS_OK;
   if (status != STATUS_OK)
-    return false;
-
+    return status;
   if (ids.empty())
-    return true;
+    return STATUS_OK;
 
   leveldb::WriteBatch batch;
   for (std::set<int64>::const_iterator itr = ids.begin();
        itr != ids.end(); ++itr) {
     batch.Delete(CreateResourceIdKey(id_key_prefix, *itr));
   }
+
   return WriteBatch(&batch);
 }
 
@@ -879,7 +912,8 @@ ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadDatabaseVersion(
   return STATUS_OK;
 }
 
-bool ServiceWorkerDatabase::WriteBatch(leveldb::WriteBatch* batch) {
+ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteBatch(
+    leveldb::WriteBatch* batch) {
   DCHECK(batch);
   DCHECK(!is_disabled_);
 
@@ -890,11 +924,9 @@ bool ServiceWorkerDatabase::WriteBatch(leveldb::WriteBatch* batch) {
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), batch);
-  if (!status.ok()) {
+  if (!status.ok())
     HandleError(FROM_HERE, status);
-    return false;
-  }
-  return true;
+  return LevelDBStatusToStatus(status);
 }
 
 void ServiceWorkerDatabase::BumpNextRegistrationIdIfNeeded(

content/browser/service_worker/service_worker_database.h

@@ -97,20 +97,44 @@ class CONTENT_EXPORT ServiceWorkerDatabase {
   // (resource ids will be added/removed from the uncommitted/purgeable
   // lists as needed)
 
-  bool ReadRegistration(int64 registration_id,
-                        const GURL& origin,
-                        RegistrationData* registration,
-                        std::vector<ResourceRecord>* resources);
-  bool WriteRegistration(const RegistrationData& registration,
-                         const std::vector<ResourceRecord>& resources);
-
-  bool UpdateVersionToActive(int64 registration_id,
-                             const GURL& origin);
-  bool UpdateLastCheckTime(int64 registration_id,
-                           const GURL& origin,
-                           const base::Time& time);
-  bool DeleteRegistration(int64 registration_id,
-                          const GURL& origin);
+  // Reads a registration for |registration_id| and resource records associated
+  // with it from the database. Returns OK if they are successfully read.
+  // Otherwise, returns an error.
+  Status ReadRegistration(
+      int64 registration_id,
+      const GURL& origin,
+      RegistrationData* registration,
+      std::vector<ResourceRecord>* resources);
+
+  // Writes |registration| and |resources| into the database and does following
+  // things:
+  //   - Deletes an old version of the registration if exists.
+  //   - Bumps the next registration id and the next version id if needed.
+  //   - Removes |resources| from the uncommitted list if exist.
+  // Returns OK they are successfully written. Otherwise, returns an error.
+  Status WriteRegistration(
+      const RegistrationData& registration,
+      const std::vector<ResourceRecord>& resources);
+
+  // Updates a registration for |registration_id| to an active state. Returns OK
+  // if it's successfully updated. Otherwise, returns an error.
+  Status UpdateVersionToActive(
+      int64 registration_id,
+      const GURL& origin);
+
+  // Updates last check time of a registration for |registration_id| by |time|.
+  // Returns OK if it's successfully updated. Otherwise, returns an error.
+  Status UpdateLastCheckTime(
+      int64 registration_id,
+      const GURL& origin,
+      const base::Time& time);
+
+  // Deletes a registration for |registration_id| and moves resource records
+  // associated with it into the purgeable list. Returns OK if it's successfully
+  // deleted or not found in the database. Otherwise, returns an error.
+  Status DeleteRegistration(
+      int64 registration_id,
+      const GURL& origin);
 
   // As new resources are put into the diskcache, they go into an uncommitted
   // list. When a registration is saved that refers to those ids, they're
@@ -119,33 +143,35 @@ class CONTENT_EXPORT ServiceWorkerDatabase {
   // the purgeable list can be purged from the diskcache. At system startup, all
   // uncommitted ids are moved to the purgeable list.
 
-  // Reads uncommitted resource ids from the database. Returns true on success.
-  // Otherwise clears |ids| and returns false.
-  bool GetUncommittedResourceIds(std::set<int64>* ids);
+  // Reads uncommitted resource ids from the database. Returns OK on success.
+  // Otherwise clears |ids| and returns an error.
+  Status GetUncommittedResourceIds(std::set<int64>* ids);
 
-  // Writes |ids| into the database as uncommitted resources. Returns true on
-  // success. Otherwise writes nothing and returns false.
-  bool WriteUncommittedResourceIds(const std::set<int64>& ids);
+  // Writes |ids| into the database as uncommitted resources. Returns OK on
+  // success. Otherwise writes nothing and returns an error.
+  Status WriteUncommittedResourceIds(const std::set<int64>& ids);
 
   // Deletes uncommitted resource ids specified by |ids| from the database.
-  // Returns true on success. Otherwise deletes nothing and returns false.
-  bool ClearUncommittedResourceIds(const std::set<int64>& ids);
+  // Returns OK on success. Otherwise deletes nothing and returns an error.
+  Status ClearUncommittedResourceIds(const std::set<int64>& ids);
 
-  // Reads purgeable resource ids from the database. Returns true on success.
-  // Otherwise clears |ids| and returns false.
-  bool GetPurgeableResourceIds(std::set<int64>* ids);
+  // Reads purgeable resource ids from the database. Returns OK on success.
+  // Otherwise clears |ids| and returns an error.
+  Status GetPurgeableResourceIds(std::set<int64>* ids);
 
-  // Writes |ids| into the database as purgeable resources. Returns true on
-  // success. Otherwise writes nothing and returns false.
-  bool WritePurgeableResourceIds(const std::set<int64>& ids);
+  // Writes |ids| into the database as purgeable resources. Returns OK on
+  // success. Otherwise writes nothing and returns an error.
+  Status WritePurgeableResourceIds(const std::set<int64>& ids);
 
   // Deletes purgeable resource ids specified by |ids| from the database.
-  // Returns true on success. Otherwise deletes nothing and returns false.
-  bool ClearPurgeableResourceIds(const std::set<int64>& ids);
+  // Returns OK on success. Otherwise deletes nothing and returns an error.
+  Status ClearPurgeableResourceIds(const std::set<int64>& ids);
 
-  // Delete all data for |origin|, namely, unique origin, registrations and
-  // resource records. Resources are moved to the purgeable list.
-  bool DeleteAllDataForOrigin(const GURL& origin);
+  // Deletes all data for |origin|, namely, unique origin, registrations and
+  // resource records. Resources are moved to the purgeable list. Returns OK if
+  // they are successfully deleted or not found in the database. Otherwise,
+  // returns an error.
+  Status DeleteAllDataForOrigin(const GURL& origin);
 
   bool is_disabled() const { return is_disabled_; }
   bool was_corruption_detected() const { return was_corruption_detected_; }
@@ -169,40 +195,70 @@ class CONTENT_EXPORT ServiceWorkerDatabase {
       const char* id_key,
       int64* next_avail_id);
 
-  bool ReadRegistrationData(int64 registration_id,
-                            const GURL& origin,
-                            RegistrationData* registration);
-  bool ReadResourceRecords(int64 version_id,
-                           std::vector<ResourceRecord>* resources);
-  bool DeleteResourceRecords(int64 version_id,
-                             leveldb::WriteBatch* batch);
-  bool ReadResourceIds(const char* id_key_prefix,
-                       std::set<int64>* ids);
-  bool WriteResourceIds(const char* id_key_prefix,
-                        const std::set<int64>& ids);
-  bool DeleteResourceIds(const char* id_key_prefix,
-                         const std::set<int64>& ids);
+  // Reads registration data for |registration_id| from the database. Returns OK
+  // if successfully reads. Otherwise, returns an error.
+  Status ReadRegistrationData(
+      int64 registration_id,
+      const GURL& origin,
+      RegistrationData* registration);
+
+  // Reads resource records for |version_id| from the database. Returns OK if
+  // it's successfully read or not found in the database. Otherwise, returns an
+  // error.
+  Status ReadResourceRecords(
+      int64 version_id,
+      std::vector<ResourceRecord>* resources);
+
+  // Deletes resource records for |version_id| from the database. Returns OK if
+  // they are successfully deleted or not found in the database. Otherwise,
+  // returns an error.
+  Status DeleteResourceRecords(
+      int64 version_id,
+      leveldb::WriteBatch* batch);
+
+  // Reads resource ids for |id_key_prefix| from the database. Returns OK if
+  // it's successfully read or not found in the database. Otherwise, returns an
+  // error.
+  Status ReadResourceIds(
+      const char* id_key_prefix,
+      std::set<int64>* ids);
+
+  // Write resource ids for |id_key_prefix| into the database. Returns OK on
+  // success. Otherwise, returns writes nothing and returns an error.
+  Status WriteResourceIds(
+      const char* id_key_prefix,
+      const std::set<int64>& ids);
+
+  // Deletes resource ids for |id_key_prefix| from the database. Returns OK if
+  // it's successfully deleted or not found in the database. Otherwise, returns
+  // an error.
+  Status DeleteResourceIds(
+      const char* id_key_prefix,
+      const std::set<int64>& ids);
 
   // Reads the current schema version from the database. If the database hasn't
   // been written anything yet, sets |db_version| to 0 and returns OK.
   Status ReadDatabaseVersion(int64* db_version);
 
-  // Write a batch into the database.
+  // Writes a batch into the database.
   // NOTE: You must call this when you want to put something into the database
   // because this initializes the database if needed.
-  bool WriteBatch(leveldb::WriteBatch* batch);
+  Status WriteBatch(leveldb::WriteBatch* batch);
 
   // Bumps the next available id if |used_id| is greater than or equal to the
   // cached one.
-  void BumpNextRegistrationIdIfNeeded(int64 used_id,
-                                      leveldb::WriteBatch* batch);
-  void BumpNextVersionIdIfNeeded(int64 used_id,
-                                 leveldb::WriteBatch* batch);
+  void BumpNextRegistrationIdIfNeeded(
+      int64 used_id,
+      leveldb::WriteBatch* batch);
+  void BumpNextVersionIdIfNeeded(
+      int64 used_id,
+      leveldb::WriteBatch* batch);
 
   bool IsOpen();
 
-  void HandleError(const tracked_objects::Location& from_here,
-                   const leveldb::Status& status);
+  void HandleError(
+      const tracked_objects::Location& from_here,
+      const leveldb::Status& status);
 
   base::FilePath path_;
   scoped_ptr<leveldb::Env> env_;

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));

content/browser/service_worker/service_worker_storage.cc

@@ -100,28 +100,6 @@ void ReadInitialDataFromDB(
       FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
 }
 
-void ReadRegistrationFromDB(
-    ServiceWorkerDatabase* database,
-    scoped_refptr<base::SequencedTaskRunner> original_task_runner,
-    int64 registration_id,
-    const GURL& origin,
-    const ReadRegistrationCallback& callback) {
-  DCHECK(database);
-  ServiceWorkerDatabase::RegistrationData data;
-  std::vector<ServiceWorkerDatabase::ResourceRecord> resources;
-
-  // TODO(nhiroki): The database should return more detailed status like
-  // ServiceWorkerStatusCode instead of bool value.
-  ServiceWorkerDatabase::Status status = ServiceWorkerDatabase::STATUS_OK;
-  if (!database->ReadRegistration(registration_id, origin, &data, &resources)) {
-    status = database->is_disabled()
-        ? ServiceWorkerDatabase::STATUS_ERROR_FAILED
-        : ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND;
-  }
-  original_task_runner->PostTask(
-      FROM_HERE, base::Bind(callback, data, resources, status));
-}
-
 void DeleteRegistrationFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
@@ -129,18 +107,18 @@ void DeleteRegistrationFromDB(
     const GURL& origin,
     const DeleteRegistrationCallback& callback) {
   DCHECK(database);
-  if (!database->DeleteRegistration(registration_id, origin)) {
+  ServiceWorkerDatabase::Status status =
+      database->DeleteRegistration(registration_id, origin);
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
-        FROM_HERE, base::Bind(callback, false,
-                              ServiceWorkerDatabase::STATUS_ERROR_FAILED));
+        FROM_HERE, base::Bind(callback, false, status));
     return;
   }
 
   // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the
   // unique origin list.
   std::vector<ServiceWorkerDatabase::RegistrationData> registrations;
-  ServiceWorkerDatabase::Status status =
-      database->GetRegistrationsForOrigin(origin, &registrations);
+  status = database->GetRegistrationsForOrigin(origin, &registrations);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, false, status));
@@ -149,26 +127,7 @@ void DeleteRegistrationFromDB(
 
   bool deletable = registrations.empty();
   original_task_runner->PostTask(
-      FROM_HERE, base::Bind(callback, deletable,
-                            ServiceWorkerDatabase::STATUS_OK));
-}
-
-void UpdateToActiveStateInDB(
-    ServiceWorkerDatabase* database,
-    scoped_refptr<base::SequencedTaskRunner> original_task_runner,
-    int64 registration_id,
-    const GURL& origin,
-    const ServiceWorkerStorage::StatusCallback& callback) {
-  DCHECK(database);
-
-  // TODO(nhiroki): The database should return more detailed status like
-  // ServiceWorkerStatusCode instead of bool value.
-  ServiceWorkerStatusCode status = SERVICE_WORKER_OK;
-  if (!database->UpdateVersionToActive(registration_id, origin)) {
-    status = database->is_disabled() ? SERVICE_WORKER_ERROR_FAILED
-                                     : SERVICE_WORKER_ERROR_NOT_FOUND;
-  }
-  original_task_runner->PostTask(FROM_HERE, base::Bind(callback, status));
+      FROM_HERE, base::Bind(callback, deletable, status));
 }
 
 }  // namespace
@@ -327,14 +286,20 @@ void ServiceWorkerStorage::FindRegistrationForId(
     return;
   }
 
-  database_task_runner_->PostTask(
+  ServiceWorkerDatabase::RegistrationData* data =
+      new ServiceWorkerDatabase::RegistrationData;
+  ResourceList* resources = new ResourceList;
+  PostTaskAndReplyWithResult(
+      database_task_runner_,
       FROM_HERE,
-      base::Bind(&ReadRegistrationFromDB,
-                 database_.get(),
-                 base::MessageLoopProxy::current(),
+      base::Bind(&ServiceWorkerDatabase::ReadRegistration,
+                 base::Unretained(database_.get()),
                  registration_id, origin,
-                 base::Bind(&ServiceWorkerStorage::DidReadRegistrationForId,
-                            weak_factory_.GetWeakPtr(), callback)));
+                 base::Unretained(data),
+                 base::Unretained(resources)),
+      base::Bind(&ServiceWorkerStorage::DidReadRegistrationForId,
+                 weak_factory_.GetWeakPtr(),
+                 callback, base::Owned(data), base::Owned(resources)));
 }
 
 void ServiceWorkerStorage::GetAllRegistrations(
@@ -408,13 +373,15 @@ void ServiceWorkerStorage::UpdateToActiveState(
     return;
   }
 
-  database_task_runner_->PostTask(
+  PostTaskAndReplyWithResult(
+      database_task_runner_,
       FROM_HERE,
-      base::Bind(&UpdateToActiveStateInDB,
-                 database_.get(),
-                 base::MessageLoopProxy::current(),
+      base::Bind(&ServiceWorkerDatabase::UpdateVersionToActive,
+                 base::Unretained(database_.get()),
                  registration->id(),
-                 registration->script_url().GetOrigin(),
+                 registration->script_url().GetOrigin()),
+      base::Bind(&ServiceWorkerStorage::DidUpdateToActiveState,
+                 weak_factory_.GetWeakPtr(),
                  callback));
 }
 
@@ -624,18 +591,21 @@ void ServiceWorkerStorage::DidGetRegistrationsForDocument(
 
 void ServiceWorkerStorage::DidReadRegistrationForId(
     const FindRegistrationCallback& callback,
-    const ServiceWorkerDatabase::RegistrationData& registration,
-    const ResourceList& resources,
+    ServiceWorkerDatabase::RegistrationData* registration,
+    ResourceList* resources,
     ServiceWorkerDatabase::Status status) {
+  DCHECK(registration);
+  DCHECK(resources);
+
   if (status == ServiceWorkerDatabase::STATUS_OK) {
-    callback.Run(SERVICE_WORKER_OK, CreateRegistration(registration));
+    callback.Run(SERVICE_WORKER_OK, CreateRegistration(*registration));
     return;
   }
 
   if (status == ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     // Look for somthing currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
-        FindInstallingRegistrationForId(registration.registration_id);
+        FindInstallingRegistrationForId(registration->registration_id);
     if (installing_registration) {
       callback.Run(SERVICE_WORKER_OK, installing_registration);
       return;
@@ -645,6 +615,7 @@ void ServiceWorkerStorage::DidReadRegistrationForId(
     return;
   }
 
+  // TODO(nhiroki): Handle database error (http://crbug.com/371675).
   callback.Run(DatabaseStatusToStatusCode(status),
                scoped_refptr<ServiceWorkerRegistration>());
   return;
@@ -699,23 +670,36 @@ void ServiceWorkerStorage::DidGetAllRegistrations(
 void ServiceWorkerStorage::DidStoreRegistration(
     const GURL& origin,
     const StatusCallback& callback,
-    bool success) {
-  if (!success) {
-    callback.Run(SERVICE_WORKER_ERROR_FAILED);
+    ServiceWorkerDatabase::Status status) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
+    callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
   registered_origins_.insert(origin);
   callback.Run(SERVICE_WORKER_OK);
 }
 
+void ServiceWorkerStorage::DidUpdateToActiveState(
+    const StatusCallback& callback,
+    ServiceWorkerDatabase::Status status) {
+  // TODO(nhiroki): Handle database error (http://crbug.com/371675).
+  callback.Run(DatabaseStatusToStatusCode(status));
+}
+
 void ServiceWorkerStorage::DidDeleteRegistration(
     const GURL& origin,
     const StatusCallback& callback,
     bool origin_is_deletable,
     ServiceWorkerDatabase::Status status) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
+    callback.Run(DatabaseStatusToStatusCode(status));
+    return;
+  }
   if (origin_is_deletable)
     registered_origins_.erase(origin);
-  callback.Run(DatabaseStatusToStatusCode(status));
+  callback.Run(SERVICE_WORKER_OK);
 }
 
 scoped_refptr<ServiceWorkerRegistration>

content/browser/service_worker/service_worker_storage.h

@@ -151,8 +151,8 @@ class CONTENT_EXPORT ServiceWorkerStorage {
       ServiceWorkerDatabase::Status status);
   void DidReadRegistrationForId(
       const FindRegistrationCallback& callback,
-      const ServiceWorkerDatabase::RegistrationData& registration,
-      const ResourceList& resources,
+      ServiceWorkerDatabase::RegistrationData* registration,
+      ResourceList* resources,
       ServiceWorkerDatabase::Status status);
   void DidGetAllRegistrations(
       const GetAllRegistrationInfosCallback& callback,
@@ -161,7 +161,10 @@ class CONTENT_EXPORT ServiceWorkerStorage {
   void DidStoreRegistration(
       const GURL& origin,
       const StatusCallback& callback,
-      bool success);
+      ServiceWorkerDatabase::Status status);
+  void DidUpdateToActiveState(
+      const StatusCallback& callback,
+      ServiceWorkerDatabase::Status status);
   void DidDeleteRegistration(
       const GURL& origin,
       const StatusCallback& callback,