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

content/browser/service_worker/service_worker_storage.cc

 // Copyright 2013 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_storage.h"
 
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_disk_cache.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 
 namespace content {
 
 namespace {
 
 typedef base::Callback<void(
     ServiceWorkerStorage::InitialData* data,
-    ServiceWorkerStatusCode status)> InitializeCallback;
+    ServiceWorkerDatabase::Status status)> InitializeCallback;
 typedef base::Callback<void(
     const ServiceWorkerDatabase::RegistrationData& data,
     const std::vector<ServiceWorkerDatabase::ResourceRecord>& resources,
-    ServiceWorkerStatusCode status)> ReadRegistrationCallback;
+    ServiceWorkerDatabase::Status status)> ReadRegistrationCallback;
 typedef base::Callback<void(
     bool origin_is_deletable,
-    ServiceWorkerStatusCode status)> DeleteRegistrationCallback;
+    ServiceWorkerDatabase::Status status)> DeleteRegistrationCallback;
 
 void RunSoon(const tracked_objects::Location& from_here,
              const base::Closure& closure) {
   base::MessageLoop::current()->PostTask(from_here, closure);
 }
 
 void CompleteFindNow(
     const scoped_refptr<ServiceWorkerRegistration>& registration,
     ServiceWorkerStatusCode status,
     const ServiceWorkerStorage::FindRegistrationCallback& callback) {
@@ skipping 10 matching lines @@
 
 const base::FilePath::CharType kServiceWorkerDirectory[] =
     FILE_PATH_LITERAL("Service Worker");
 const base::FilePath::CharType kDatabaseName[] =
     FILE_PATH_LITERAL("Database");
 
 const int kMaxMemDiskCacheSize = 10 * 1024 * 1024;
 
 void EmptyCompletionCallback(int) {}
 
+ServiceWorkerStatusCode DatabaseStatusToStatusCode(
+    ServiceWorkerDatabase::Status status) {
+  switch (status) {
+    case ServiceWorkerDatabase::STATUS_OK:
+      return SERVICE_WORKER_OK;
+    case ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND:
+      return SERVICE_WORKER_ERROR_NOT_FOUND;
+    default:
+      return SERVICE_WORKER_ERROR_FAILED;
+  }
+}
+
 void ReadInitialDataFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const InitializeCallback& callback) {
   DCHECK(database);
   scoped_ptr<ServiceWorkerStorage::InitialData> data(
       new ServiceWorkerStorage::InitialData());
 
-  ServiceWorkerStatusCode status =
+  ServiceWorkerDatabase::Status status =
       database->GetNextAvailableIds(&data->next_registration_id,
                                     &data->next_version_id,
                                     &data->next_resource_id);
-  if (status != SERVICE_WORKER_OK) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, base::Owned(data.release()), status));
     return;
   }
 
   status = database->GetOriginsWithRegistrations(&data->origins);
   original_task_runner->PostTask(
       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.
-  ServiceWorkerStatusCode status = SERVICE_WORKER_OK;
+  ServiceWorkerDatabase::Status status = ServiceWorkerDatabase::STATUS_OK;
   if (!database->ReadRegistration(registration_id, origin, &data, &resources)) {
-    status = database->is_disabled() ? SERVICE_WORKER_ERROR_FAILED
-                                     : SERVICE_WORKER_ERROR_NOT_FOUND;
+    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,
     int64 registration_id,
     const GURL& origin,
     const DeleteRegistrationCallback& callback) {
   DCHECK(database);
   if (!database->DeleteRegistration(registration_id, origin)) {
     original_task_runner->PostTask(
-        FROM_HERE, base::Bind(callback, false, SERVICE_WORKER_ERROR_FAILED));
+        FROM_HERE, base::Bind(callback, false,
+                              ServiceWorkerDatabase::STATUS_ERROR_FAILED));
     return;
   }
 
   // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the
   // unique origin list.
   std::vector<ServiceWorkerDatabase::RegistrationData> registrations;
-  if (!database->GetRegistrationsForOrigin(origin, &registrations)) {
+  ServiceWorkerDatabase::Status status =
+      database->GetRegistrationsForOrigin(origin, &registrations);
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
     original_task_runner->PostTask(
-        FROM_HERE, base::Bind(callback, false, SERVICE_WORKER_ERROR_FAILED));
+        FROM_HERE, base::Bind(callback, false, status));
     return;
   }
 
   bool deletable = registrations.empty();
   original_task_runner->PostTask(
-      FROM_HERE, base::Bind(callback, deletable, SERVICE_WORKER_OK));
+      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);
 
@@ skipping 345 matching lines @@
       base::Bind(&ReadInitialDataFromDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
                  base::Bind(&ServiceWorkerStorage::DidReadInitialData,
                             weak_factory_.GetWeakPtr())));
   return false;
 }
 
 void ServiceWorkerStorage::DidReadInitialData(
     InitialData* data,
-    ServiceWorkerStatusCode status) {
+    ServiceWorkerDatabase::Status status) {
   DCHECK(data);
   DCHECK_EQ(INITIALIZING, state_);
 
-  if (status == SERVICE_WORKER_OK) {
+  if (status == ServiceWorkerDatabase::STATUS_OK) {
     next_registration_id_ = data->next_registration_id;
     next_version_id_ = data->next_version_id;
     next_resource_id_ = data->next_resource_id;
     registered_origins_.swap(data->origins);
     state_ = INITIALIZED;
   } else {
-    // TODO(nhiroki): If status==SERVICE_WORKER_ERROR_DB_CORRUPTED, do
-    // corruption recovery (http://crbug.com/371675).
-    DLOG(WARNING) << "Failed to initialize: "
-                  << ServiceWorkerStatusToString(status);
+    // TODO(nhiroki): If status==STATUS_ERROR_CORRUPTED, do corruption recovery
+    // (http://crbug.com/371675).
+    DLOG(WARNING) << "Failed to initialize: " << status;
     state_ = DISABLED;
   }
 
   for (std::vector<base::Closure>::const_iterator it = pending_tasks_.begin();
        it != pending_tasks_.end(); ++it) {
     RunSoon(FROM_HERE, *it);
   }
   pending_tasks_.clear();
 }
 
 void ServiceWorkerStorage::DidGetRegistrationsForPattern(
     const GURL& scope,
     const FindRegistrationCallback& callback,
     RegistrationList* registrations,
-    bool success) {
+    ServiceWorkerDatabase::Status status) {
   DCHECK(registrations);
-  if (!success) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
     callback.Run(SERVICE_WORKER_ERROR_FAILED,
                  scoped_refptr<ServiceWorkerRegistration>());
     return;
   }
 
   // Find one with a matching scope.
   for (RegistrationList::const_iterator it = registrations->begin();
        it != registrations->end(); ++it) {
     if (scope == it->scope) {
       scoped_refptr<ServiceWorkerRegistration> registration =
@@ skipping 14 matching lines @@
   }
 
   callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND,
                scoped_refptr<ServiceWorkerRegistration>());
 }
 
 void ServiceWorkerStorage::DidGetRegistrationsForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback,
     RegistrationList* registrations,
-    bool success) {
+    ServiceWorkerDatabase::Status status) {
   DCHECK(registrations);
-  if (!success) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
     callback.Run(SERVICE_WORKER_ERROR_FAILED,
                  scoped_refptr<ServiceWorkerRegistration>());
     return;
   }
 
   // Find one with a pattern match.
   for (RegistrationList::const_iterator it = registrations->begin();
        it != registrations->end(); ++it) {
     // TODO(michaeln): if there are multiple matches the one with
     // the longest scope should win.
@@ skipping 20 matching lines @@
   }
 
   callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND,
                scoped_refptr<ServiceWorkerRegistration>());
 }
 
 void ServiceWorkerStorage::DidReadRegistrationForId(
     const FindRegistrationCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& registration,
     const ResourceList& resources,
-    ServiceWorkerStatusCode status) {
-  if (status == SERVICE_WORKER_OK) {
-    callback.Run(status, CreateRegistration(registration));
+    ServiceWorkerDatabase::Status status) {
+  if (status == ServiceWorkerDatabase::STATUS_OK) {
+    callback.Run(SERVICE_WORKER_OK, CreateRegistration(registration));
     return;
   }
 
-  if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
+  if (status == ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     // Look for somthing currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
         FindInstallingRegistrationForId(registration.registration_id);
     if (installing_registration) {
       callback.Run(SERVICE_WORKER_OK, installing_registration);
       return;
     }
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND,
                  scoped_refptr<ServiceWorkerRegistration>());
     return;
   }
 
-  callback.Run(status, scoped_refptr<ServiceWorkerRegistration>());
+  callback.Run(DatabaseStatusToStatusCode(status),
+               scoped_refptr<ServiceWorkerRegistration>());
   return;
 }
 
 void ServiceWorkerStorage::DidGetAllRegistrations(
     const GetAllRegistrationInfosCallback& callback,
     RegistrationList* registrations,
-    bool success) {
+    ServiceWorkerDatabase::Status status) {
   DCHECK(registrations);
-  if (!success) {
+  if (status != ServiceWorkerDatabase::STATUS_OK) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
     callback.Run(std::vector<ServiceWorkerRegistrationInfo>());
     return;
   }
 
   // Add all stored registrations.
   std::set<int64> pushed_registrations;
   std::vector<ServiceWorkerRegistrationInfo> infos;
   for (RegistrationList::const_iterator it = registrations->begin();
        it != registrations->end(); ++it) {
     DCHECK(pushed_registrations.insert(it->registration_id).second);
@@ skipping 35 matching lines @@
     return;
   }
   registered_origins_.insert(origin);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerStorage::DidDeleteRegistration(
     const GURL& origin,
     const StatusCallback& callback,
     bool origin_is_deletable,
-    ServiceWorkerStatusCode status) {
+    ServiceWorkerDatabase::Status status) {
   if (origin_is_deletable)
     registered_origins_.erase(origin);
-  callback.Run(status);
+  callback.Run(DatabaseStatusToStatusCode(status));
 }
 
 scoped_refptr<ServiceWorkerRegistration>
 ServiceWorkerStorage::CreateRegistration(
     const ServiceWorkerDatabase::RegistrationData& data) {
   scoped_refptr<ServiceWorkerRegistration> registration(
       new ServiceWorkerRegistration(
           data.scope, data.script, data.registration_id, context_));
 
   scoped_refptr<ServiceWorkerVersion> version =
@@ skipping 62 matching lines @@
   // TODO(michaeln): Store data on disk and do error checking.
   disk_cache_.reset(new ServiceWorkerDiskCache);
   int rv = disk_cache_->InitWithMemBackend(
       kMaxMemDiskCacheSize,
       base::Bind(&EmptyCompletionCallback));
   DCHECK_EQ(net::OK, rv);
   return disk_cache_.get();
 }
 
 }  // namespace content