[BackgroundSync] Add browser side support for SyncRegistration.done

content/browser/background_sync/background_sync_service_impl_unittest.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/browser/background_sync/background_sync_service_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/power_monitor/power_monitor.h"
@@ skipping 41 matching lines @@
 void ErrorAndRegistrationCallback(bool* called,
                                   BackgroundSyncError* out_error,
                                   SyncRegistrationPtr* out_registration,
                                   BackgroundSyncError error,
                                   const SyncRegistrationPtr& registration) {
   *called = true;
   *out_error = error;
   *out_registration = registration.Clone();
 }
 
+void ErrorAndStateCallback(bool* called,
+                           BackgroundSyncError* out_error,
+                           BackgroundSyncState* out_state,
+                           BackgroundSyncError error,
+                           BackgroundSyncState state) {
+  *called = true;
+  *out_error = error;
+  *out_state = state;
+}
+
 void ErrorCallback(bool* called,
                    BackgroundSyncError* out_error,
                    BackgroundSyncError error) {
   *called = true;
   *out_error = error;
 }
 
 void ErrorAndRegistrationListCallback(
     bool* called,
     BackgroundSyncError* out_error,
@@ skipping 118 matching lines @@
   void RegisterOneShotFromDocument(
       SyncRegistrationPtr sync,
       const BackgroundSyncService::RegisterCallback& callback) {
     service_impl_->Register(sync.Pass(), sw_registration_id_,
                             false /* requested_from_service_worker */,
                             callback);
     base::RunLoop().RunUntilIdle();
   }
 
   void UnregisterOneShot(
-      SyncRegistrationPtr sync,
+      int32 handle_id,
       const BackgroundSyncService::UnregisterCallback& callback) {
     service_impl_->Unregister(
         BackgroundSyncPeriodicity::BACKGROUND_SYNC_PERIODICITY_ONE_SHOT,
-        sync->handle_id, sw_registration_id_, callback);
+        handle_id, sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
   void GetRegistrationOneShot(
       const mojo::String& tag,
       const BackgroundSyncService::RegisterCallback& callback) {
     service_impl_->GetRegistration(
         BackgroundSyncPeriodicity::BACKGROUND_SYNC_PERIODICITY_ONE_SHOT, tag,
         sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
   void GetRegistrationsOneShot(
       const BackgroundSyncService::GetRegistrationsCallback& callback) {
     service_impl_->GetRegistrations(
         BackgroundSyncPeriodicity::BACKGROUND_SYNC_PERIODICITY_ONE_SHOT,
         sw_registration_id_, callback);
     base::RunLoop().RunUntilIdle();
   }
 
+  void NotifyWhenDone(
+      int32 handle_id,
+      const BackgroundSyncService::NotifyWhenDoneCallback& callback) {
+    service_impl_->NotifyWhenDone(handle_id, callback);
+    base::RunLoop().RunUntilIdle();
+  }
+
   scoped_ptr<TestBrowserThreadBundle> thread_bundle_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   scoped_ptr<EmbeddedWorkerTestHelper> embedded_worker_helper_;
   scoped_ptr<base::PowerMonitor> power_monitor_;
   scoped_refptr<BackgroundSyncContextImpl> background_sync_context_;
   scoped_ptr<ServiceWorkerProviderHost> provider_host_;
   int64 sw_registration_id_;
   scoped_refptr<ServiceWorkerRegistration> sw_registration_;
   BackgroundSyncServicePtr service_ptr_;
   BackgroundSyncServiceImpl*
@@ skipping 50 matching lines @@
   EXPECT_TRUE(called);
   EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NONE, error);
   EXPECT_EQ("", reg->tag);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, Unregister) {
   bool unregister_called = false;
   BackgroundSyncError unregister_error;
   SyncRegistrationPtr reg;
   UnregisterOneShot(
-      default_sync_registration_.Clone(),
+      default_sync_registration_->handle_id,
       base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
   EXPECT_TRUE(unregister_called);
   EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NOT_ALLOWED,
             unregister_error);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, UnregisterWithRegisteredSync) {
   bool register_called = false;
   bool unregister_called = false;
   BackgroundSyncError register_error;
   BackgroundSyncError unregister_error;
   SyncRegistrationPtr reg;
   RegisterOneShot(default_sync_registration_.Clone(),
                   base::Bind(&ErrorAndRegistrationCallback, &register_called,
                              &register_error, &reg));
   EXPECT_TRUE(register_called);
   EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NONE, register_error);
-  UnregisterOneShot(reg.Pass(), base::Bind(&ErrorCallback, &unregister_called,
-                                           &unregister_error));
+  UnregisterOneShot(
+      reg->handle_id,
+      base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
   EXPECT_TRUE(unregister_called);
   EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NONE, unregister_error);
 }
 
 TEST_F(BackgroundSyncServiceImplTest, GetRegistration) {
   bool called = false;
   BackgroundSyncError error;
   SyncRegistrationPtr reg;
   GetRegistrationOneShot(
       "", base::Bind(&ErrorAndRegistrationCallback, &called, &error, &reg));
@@ skipping 47 matching lines @@
   EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NONE, register_error);
   GetRegistrationsOneShot(base::Bind(&ErrorAndRegistrationListCallback,
                                      &getregistrations_called,
                                      &getregistrations_error, &array_size));
   EXPECT_TRUE(getregistrations_called);
   EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NONE,
             getregistrations_error);
   EXPECT_EQ(1UL, array_size);
 }
 
+TEST_F(BackgroundSyncServiceImplTest, NotifyWhenDone) {
+  // Register a sync event.
+  bool register_called = false;
+  BackgroundSyncError register_error;
+  SyncRegistrationPtr reg;
+  RegisterOneShot(default_sync_registration_.Clone(),
+                  base::Bind(&ErrorAndRegistrationCallback, &register_called,
+                             &register_error, &reg));
+  EXPECT_TRUE(register_called);
+  EXPECT_EQ(BACKGROUND_SYNC_ERROR_NONE, register_error);
+
+  // Unregister it.
+  bool unregister_called = false;
+  BackgroundSyncError unregister_error;
+  UnregisterOneShot(
+      reg->handle_id,
+      base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
+  EXPECT_TRUE(unregister_called);
+  EXPECT_EQ(BACKGROUND_SYNC_ERROR_NONE, unregister_error);
+
+  // Call NotifyWhenDone and verify that it calls back with unregistered.
+  bool notify_done_called = false;
+  BackgroundSyncError notify_done_error = BACKGROUND_SYNC_ERROR_NONE;
+  BackgroundSyncState notify_done_sync_state = BACKGROUND_SYNC_STATE_SUCCESS;
+
+  NotifyWhenDone(reg->handle_id,
+                 base::Bind(&ErrorAndStateCallback, &notify_done_called,
+                            &notify_done_error, &notify_done_sync_state));
+  EXPECT_TRUE(notify_done_called);
+  EXPECT_EQ(BACKGROUND_SYNC_ERROR_NONE, notify_done_error);
+  EXPECT_EQ(BACKGROUND_SYNC_STATE_UNREGISTERED, notify_done_sync_state);
+}
+
 }  // namespace content