[Background Sync] Add proper error status to API calls and callbacks

content/child/background_sync/background_sync_provider.cc

 // Copyright 2015 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/child/background_sync/background_sync_provider.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/child/background_sync/background_sync_type_converters.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
@@ skipping 75 matching lines @@
   DCHECK(callbacks);
   int64 service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacksPtr(callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->GetRegistration(
       mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity), tag.utf8(),
       service_worker_registration_id,
-      base::Bind(&BackgroundSyncProvider::RegisterCallback,
+      base::Bind(&BackgroundSyncProvider::GetRegistrationCallback,
                  base::Unretained(this), base::Passed(callbacksPtr.Pass())));
 }
 
 void BackgroundSyncProvider::getRegistrations(
     blink::WebSyncRegistration::Periodicity periodicity,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebSyncGetRegistrationsCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
   int64 service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   scoped_ptr<blink::WebSyncGetRegistrationsCallbacks> callbacksPtr(callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->GetRegistrations(
       mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity),
       service_worker_registration_id,
       base::Bind(&BackgroundSyncProvider::GetRegistrationsCallback,
                  base::Unretained(this), base::Passed(callbacksPtr.Pass())));
 }
 
 void BackgroundSyncProvider::RegisterCallback(
     scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
+    BackgroundSyncError error,
     const SyncRegistrationPtr& options) {
-  // TODO(iclelland): Pass through the various errors from the manager to here
-  // and handle them appropriately.
+  // TODO(iclelland): Determine the correct error message to return in each case
   scoped_ptr<blink::WebSyncRegistration> result;
-  if (!options.is_null())
-    result = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
-
-  callbacks->onSuccess(result.release());
+  switch (error) {
+    case BACKGROUND_SYNC_ERROR_NONE:
+      if (!options.is_null())
+        result =
+            mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
+      callbacks->onSuccess(result.release());
+      break;
+    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+      NOTREACHED();
+      break;
+    case BACKGROUND_SYNC_ERROR_STORAGE:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "Background Sync is disabled."));
+      break;
+    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "No service worker is active."));
+      break;
+  }
 }
 
 void BackgroundSyncProvider::UnregisterCallback(
     scoped_ptr<blink::WebSyncUnregistrationCallbacks> callbacks,
-    bool success) {
-  // TODO(iclelland): Pass through the various errors from the manager to here
-  // and handle them appropriately.
-  if (success) {
-    callbacks->onSuccess(new bool(success));
-  } else {
-    callbacks->onError(
-        new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
-                                "Sync registration does not exist"));
+    BackgroundSyncError error) {
+  // TODO(iclelland): Determine the correct error message to return in each case
+  switch (error) {
+    case BACKGROUND_SYNC_ERROR_NONE:
+      callbacks->onSuccess(new bool(true));
+      break;
+    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+      callbacks->onSuccess(new bool(false));
+      break;
+    case BACKGROUND_SYNC_ERROR_STORAGE:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "Background Sync is disabled."));
+      break;
+    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "No service worker is active."));
+      break;
+  }
+}
+
+void BackgroundSyncProvider::GetRegistrationCallback(
+    scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
+    BackgroundSyncError error,
+    const SyncRegistrationPtr& options) {
+  // TODO(iclelland): Determine the correct error message to return in each case
+  scoped_ptr<blink::WebSyncRegistration> result;
+  switch (error) {
+    case BACKGROUND_SYNC_ERROR_NONE:
+      if (!options.is_null())
+        result =
+            mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
+      callbacks->onSuccess(result.release());
+      break;
+    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+      callbacks->onSuccess(nullptr);
+      break;
+    case BACKGROUND_SYNC_ERROR_STORAGE:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "Background Sync is disabled."));
+      break;
+    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "No service worker is active."));
+      break;
   }
 }
 
 void BackgroundSyncProvider::GetRegistrationsCallback(
     scoped_ptr<blink::WebSyncGetRegistrationsCallbacks> callbacks,
+    BackgroundSyncError error,
     const mojo::Array<SyncRegistrationPtr>& registrations) {
-  // TODO(iclelland): Pass through the various errors from the manager to here
-  // and handle them appropriately.
-  blink::WebVector<blink::WebSyncRegistration*>* results =
-      new blink::WebVector<blink::WebSyncRegistration*>(registrations.size());
-  for (size_t i = 0; i < registrations.size(); ++i) {
-    (*results)[i] = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(
-                        registrations[i]).release();
+  // TODO(iclelland): Determine the correct error message to return in each case
+  blink::WebVector<blink::WebSyncRegistration*>* results;
+  switch (error) {
+    case BACKGROUND_SYNC_ERROR_NONE:
+      results = new blink::WebVector<blink::WebSyncRegistration*>(
+          registrations.size());
+      for (size_t i = 0; i < registrations.size(); ++i) {
+        (*results)[i] = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(
+                            registrations[i]).release();
+      }
+      callbacks->onSuccess(results);
+    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+      // This error should never be returned from
+      // BackgroundSyncManager::GetRegistrations
+      NOTREACHED();
+      break;
+    case BACKGROUND_SYNC_ERROR_STORAGE:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "Background Sync is disabled."));
+      break;
+    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+      callbacks->onError(
+          new blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                                  "No service worker is active."));
+      break;
   }
-  callbacks->onSuccess(results);
 }
 
 BackgroundSyncServicePtr&
 BackgroundSyncProvider::GetBackgroundSyncServicePtr() {
   if (!background_sync_service_.get())
     service_registry_->ConnectToRemoteService(&background_sync_service_);
   return background_sync_service_;
 }
 
 }  // namespace content