[BackgroundSync] Add browser side support for SyncRegistration.done

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 125 matching lines @@
       mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity),
       service_worker_registration_id,
       base::Bind(&BackgroundSyncProvider::GetPermissionStatusCallback,
                  base::Unretained(this), base::Passed(callbacksPtr.Pass())));
 }
 
 void BackgroundSyncProvider::releaseRegistration(int64_t handle_id) {
   GetBackgroundSyncServicePtr()->ReleaseRegistration(handle_id);
 }
 
+void BackgroundSyncProvider::notifyWhenDone(
+    int64_t handle_id,
+    blink::WebSyncNotifyWhenDoneCallbacks* callbacks) {
+  DCHECK(callbacks);
+
+  scoped_ptr<blink::WebSyncNotifyWhenDoneCallbacks> callbacksPtr(callbacks);

[michaeln, 2015/09/17 21:44:12]

nit: callbacks_ptr

[jkarlin, 2015/09/18 12:03:20]

Done.

+
+  // base::Unretained is safe here, as the mojo channel will be deleted (and
+  // will wipe its callbacks) before 'this' is deleted.
+  GetBackgroundSyncServicePtr()->NotifyWhenDone(
+      handle_id,
+      base::Bind(&BackgroundSyncProvider::NotifyWhenDoneCallback,
+                 base::Unretained(this), base::Passed(callbacksPtr.Pass())));
+}
+
 void BackgroundSyncProvider::DuplicateRegistrationHandle(
     int handle_id,
     const BackgroundSyncService::DuplicateRegistrationHandleCallback&
         callback) {
   GetBackgroundSyncServicePtr()->DuplicateRegistrationHandle(handle_id,
                                                              callback);
 }
 
 void BackgroundSyncProvider::RegisterCallback(
     scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
@@ skipping 159 matching lines @@
                               "Background Sync is disabled."));
       break;
     case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
+void BackgroundSyncProvider::NotifyWhenDoneCallback(
+    scoped_ptr<blink::WebSyncNotifyWhenDoneCallbacks> callbacks,
+    BackgroundSyncError error,
+    BackgroundSyncState state) {
+  switch (error) {
+    case BACKGROUND_SYNC_ERROR_NONE:
+      switch (state) {
+        case BACKGROUND_SYNC_STATE_PENDING:
+        case BACKGROUND_SYNC_STATE_FIRING:
+        case BACKGROUND_SYNC_STATE_UNREGISTERED_WHILE_FIRING:
+          NOTREACHED();
+          break;
+        case BACKGROUND_SYNC_STATE_SUCCESS:
+          callbacks->onSuccess(true);
+          break;
+        case BACKGROUND_SYNC_STATE_FAILED:
+        case BACKGROUND_SYNC_STATE_UNREGISTERED:
+          callbacks->onSuccess(false);
+          break;
+      }
+      break;
+    case BACKGROUND_SYNC_ERROR_NOT_FOUND:
+    case BACKGROUND_SYNC_ERROR_NOT_ALLOWED:
+      NOTREACHED();
+      break;
+    case BACKGROUND_SYNC_ERROR_STORAGE:
+      callbacks->onError(
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "Background Sync is disabled."));
+      break;
+    case BACKGROUND_SYNC_ERROR_NO_SERVICE_WORKER:
+      callbacks->onError(
+          blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
+                              "No service worker is active."));
+      break;
+  }
+}
+
 BackgroundSyncServicePtr&
 BackgroundSyncProvider::GetBackgroundSyncServicePtr() {
   if (!background_sync_service_.get()) {
     service_registry_->ConnectToRemoteService(
         mojo::GetProxy(&background_sync_service_));
   }
   return background_sync_service_;
 }
 
 }  // namespace content