ServiceWorker: Database functions should return status code instead of boolean

content/browser/service_worker/service_worker_database.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/file_util.h"
 #include "base/location.h"
@@ skipping 193 matching lines @@
   GURL url(record.url());
   if (!url.is_valid())
     return false;
 
   // Convert ServiceWorkerResourceRecord to ResourceRecord.
   out->resource_id = record.resource_id();
   out->url = url;
   return true;
 }
 
+ServiceWorkerStatusCode LevelDBStatusToServiceWorkerStatusCode(
+    const leveldb::Status& status) {
+  if (status.ok())
+    return SERVICE_WORKER_OK;
+  else if (status.IsNotFound())
+    return SERVICE_WORKER_ERROR_NOT_FOUND;
+  else if (status.IsCorruption())
+    return SERVICE_WORKER_ERROR_DB_CORRUPTED;
+  else
+    return SERVICE_WORKER_ERROR_FAILED;
+}
+
 }  // namespace
 
 ServiceWorkerDatabase::RegistrationData::RegistrationData()
     : registration_id(-1),
       version_id(-1),
       is_active(false),
       has_fetch_handler(false) {
 }
 
 ServiceWorkerDatabase::RegistrationData::~RegistrationData() {
 }
 
 ServiceWorkerDatabase::ServiceWorkerDatabase(const base::FilePath& path)
     : path_(path),
       next_avail_registration_id_(0),
       next_avail_resource_id_(0),
       next_avail_version_id_(0),
       is_disabled_(false),
       was_corruption_detected_(false),
       is_initialized_(false) {
   sequence_checker_.DetachFromSequence();
 }
 
 ServiceWorkerDatabase::~ServiceWorkerDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   db_.reset();
 }
 
-bool ServiceWorkerDatabase::GetNextAvailableIds(
+ServiceWorkerStatusCode ServiceWorkerDatabase::GetNextAvailableIds(
     int64* next_avail_registration_id,
     int64* next_avail_version_id,
     int64* next_avail_resource_id) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(next_avail_registration_id);
   DCHECK(next_avail_version_id);
   DCHECK(next_avail_resource_id);
 
   if (!LazyOpen(false)) {
     if (is_disabled_)
-      return false;
+      return SERVICE_WORKER_ERROR_FAILED;
     // Database has never been used.
     *next_avail_registration_id = 0;
     *next_avail_version_id = 0;
     *next_avail_resource_id = 0;
-    return true;
+    return SERVICE_WORKER_OK;
   }
 
-  if (!ReadNextAvailableId(kNextRegIdKey, &next_avail_registration_id_) ||
-      !ReadNextAvailableId(kNextVerIdKey, &next_avail_version_id_) ||
-      !ReadNextAvailableId(kNextResIdKey, &next_avail_resource_id_)) {
-    return false;
-  }
+  ServiceWorkerStatusCode status =
+      ReadNextAvailableId(kNextRegIdKey, &next_avail_registration_id_);
+  if (status != SERVICE_WORKER_OK)
+    return status;
+  status = ReadNextAvailableId(kNextVerIdKey, &next_avail_version_id_);
+  if (status != SERVICE_WORKER_OK)
+    return status;
+  status = ReadNextAvailableId(kNextResIdKey, &next_avail_resource_id_);
+  if (status != SERVICE_WORKER_OK)
+    return status;
 
   *next_avail_registration_id = next_avail_registration_id_;
   *next_avail_version_id = next_avail_version_id_;
   *next_avail_resource_id = next_avail_resource_id_;
-  return true;
+  return SERVICE_WORKER_OK;
 }
 
-bool ServiceWorkerDatabase::GetOriginsWithRegistrations(
+ServiceWorkerStatusCode ServiceWorkerDatabase::GetOriginsWithRegistrations(
     std::set<GURL>* origins) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(origins);
 
   if (!LazyOpen(false)) {
     if (is_disabled_)
-      return false;
+      return SERVICE_WORKER_ERROR_FAILED;
     // Database has never been used.
     origins->clear();
-    return true;
+    return SERVICE_WORKER_OK;
   }
 
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   for (itr->Seek(kUniqueOriginKey); itr->Valid(); itr->Next()) {
     if (!itr->status().ok()) {
       HandleError(FROM_HERE, itr->status());
       origins->clear();
-      return false;
+      return LevelDBStatusToServiceWorkerStatusCode(itr->status());
     }
 
     std::string origin;
     if (!RemovePrefix(itr->key().ToString(), kUniqueOriginKey, &origin))
       break;
     origins->insert(GURL(origin));
   }
-  return true;
+  return SERVICE_WORKER_OK;
 }
 
 bool ServiceWorkerDatabase::GetRegistrationsForOrigin(
     const GURL& origin,
     std::vector<RegistrationData>* registrations) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(registrations);
 
   if (!LazyOpen(false)) {
     if (is_disabled_)
@@ skipping 307 matching lines @@
   db_.reset(db);
 
   int64 db_version;
   if (!ReadDatabaseVersion(&db_version))
     return false;
   if (db_version > 0)
     is_initialized_ = true;
   return true;
 }
 
-bool ServiceWorkerDatabase::ReadNextAvailableId(
-    const char* id_key, int64* next_avail_id) {
+ServiceWorkerStatusCode ServiceWorkerDatabase::ReadNextAvailableId(
+    const char* id_key,
+    int64* next_avail_id) {
   DCHECK(id_key);
   DCHECK(next_avail_id);
 
   std::string value;
   leveldb::Status status = db_->Get(leveldb::ReadOptions(), id_key, &value);
   if (status.IsNotFound()) {
     // Nobody has gotten the next resource id for |id_key|.
     *next_avail_id = 0;
-    return true;
+    return SERVICE_WORKER_OK;
   }
 
   if (!status.ok()) {
     HandleError(FROM_HERE, status);
-    return false;
+    return LevelDBStatusToServiceWorkerStatusCode(status);
   }
 
   int64 parsed;
   if (!base::StringToInt64(value, &parsed)) {
     HandleError(FROM_HERE, leveldb::Status::Corruption("failed to parse"));
-    return false;
+    return SERVICE_WORKER_ERROR_DB_CORRUPTED;
   }
 
   *next_avail_id = parsed;
-  return true;
+  return SERVICE_WORKER_OK;
 }
 
 bool ServiceWorkerDatabase::ReadRegistrationData(
     int64 registration_id,
     const GURL& origin,
     RegistrationData* registration) {
   DCHECK(registration);
 
   std::string key = CreateRegistrationKey(registration_id, origin);
 
@@ skipping 222 matching lines @@
   // TODO(nhiroki): Add an UMA histogram.
   DLOG(ERROR) << "Failed at: " << from_here.ToString()
               << " with error: " << status.ToString();
   is_disabled_ = true;
   if (status.IsCorruption())
     was_corruption_detected_ = true;
   db_.reset();
 }
 
 }  // namespace content