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

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"
@@ skipping 70 matching lines @@
     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;
-  if (!database->ReadRegistration(registration_id, origin, &data, &resources)) {
-    status = database->is_disabled() ? SERVICE_WORKER_ERROR_FAILED
-                                     : SERVICE_WORKER_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)) {
+  ServiceWorkerStatusCode status =
+      database->DeleteRegistration(registration_id, origin);
+  if (status != SERVICE_WORKER_OK) {
     original_task_runner->PostTask(
         FROM_HERE, base::Bind(callback, false, SERVICE_WORKER_ERROR_FAILED));
     return;
   }
 
   // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the
   // unique origin list.
   std::vector<ServiceWorkerDatabase::RegistrationData> registrations;
-  ServiceWorkerStatusCode status =
-      database->GetRegistrationsForOrigin(origin, &registrations);
+  status = database->GetRegistrationsForOrigin(origin, &registrations);
   if (status != SERVICE_WORKER_OK) {
     original_task_runner->PostTask(
         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));
 }
 
-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));
-}
-
 }  // namespace
 
 ServiceWorkerStorage::InitialData::InitialData()
     : next_registration_id(kInvalidServiceWorkerRegistrationId),
       next_version_id(kInvalidServiceWorkerVersionId),
       next_resource_id(kInvalidServiceWorkerResourceId) {
 }
 
 ServiceWorkerStorage::InitialData::~InitialData() {
 }
@@ skipping 136 matching lines @@
     return;
   }
 
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(registration_id);
   if (registration) {
     CompleteFindNow(registration, SERVICE_WORKER_OK, callback);
     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(
     const GetAllRegistrationInfosCallback& callback) {
   if (!LazyInitialize(base::Bind(
           &ServiceWorkerStorage::GetAllRegistrations,
           weak_factory_.GetWeakPtr(), callback))) {
     if (state_ != INITIALIZING || !context_) {
       RunSoon(FROM_HERE, base::Bind(
           callback, std::vector<ServiceWorkerRegistrationInfo>()));
@@ skipping 53 matching lines @@
     ServiceWorkerRegistration* registration,
     const StatusCallback& callback) {
   DCHECK(registration);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED);
   if (state_ != INITIALIZED || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
     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::DidDatabaseOperation,
+                 weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ServiceWorkerStorage::DeleteRegistration(
     int64 registration_id,
     const GURL& origin,
     const StatusCallback& callback) {
   DCHECK(state_ == INITIALIZED || state_ == DISABLED);
   if (state_ != INITIALIZED || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
@@ skipping 190 matching lines @@
     callback.Run(SERVICE_WORKER_OK, installing_registration);
     return;
   }
 
   callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND,
                scoped_refptr<ServiceWorkerRegistration>());
 }
 
 void ServiceWorkerStorage::DidReadRegistrationForId(
     const FindRegistrationCallback& callback,
-    const ServiceWorkerDatabase::RegistrationData& registration,
-    const ResourceList& resources,
+    ServiceWorkerDatabase::RegistrationData* registration,
+    ResourceList* resources,
     ServiceWorkerStatusCode status) {
+  DCHECK(registration);
+  DCHECK(resources);
   if (status == SERVICE_WORKER_OK) {
-    callback.Run(status, CreateRegistration(registration));
+    callback.Run(status, CreateRegistration(*registration));
     return;
   }
 
   if (status == SERVICE_WORKER_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;
     }
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND,
                  scoped_refptr<ServiceWorkerRegistration>());
     return;
   }
 
+  // TODO(nhiroki): Handle database error (http://crbug.com/371675).
   callback.Run(status, scoped_refptr<ServiceWorkerRegistration>());
   return;
 }
 
 void ServiceWorkerStorage::DidGetAllRegistrations(
     const GetAllRegistrationInfosCallback& callback,
     RegistrationList* registrations,
     ServiceWorkerStatusCode status) {
   DCHECK(registrations);
   if (status != SERVICE_WORKER_OK) {
@@ skipping 33 matching lines @@
     if (pushed_registrations.insert(it->first).second)
       infos.push_back(it->second->GetInfo());
   }
 
   callback.Run(infos);
 }
 
 void ServiceWorkerStorage::DidStoreRegistration(
     const GURL& origin,
     const StatusCallback& callback,
-    bool success) {
-  if (!success) {
+    ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   registered_origins_.insert(origin);
-  callback.Run(SERVICE_WORKER_OK);
+  callback.Run(status);
 }
 
 void ServiceWorkerStorage::DidDeleteRegistration(
     const GURL& origin,
     const StatusCallback& callback,
     bool origin_is_deletable,
     ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
+    callback.Run(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
   if (origin_is_deletable)
     registered_origins_.erase(origin);
   callback.Run(status);
 }
 
+void ServiceWorkerStorage::DidDatabaseOperation(
+    const StatusCallback& callback,
+    ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK && status != SERVICE_WORKER_ERROR_NOT_FOUND) {
+    // TODO(nhiroki): Handle database error (http://crbug.com/371675).
+    callback.Run(SERVICE_WORKER_ERROR_FAILED);
+    return;
+  }
+  callback.Run(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 =
       context_->GetLiveVersion(data.version_id);
   if (!version) {
@@ skipping 59 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