BackgroundSyncManager tracks client registrations

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 153 matching lines @@
   void RemoveWindowClient() {
     sw_registration_->active_version()->RemoveControllee(provider_host_.get());
   }
 
   void CreateBackgroundSyncServiceImpl() {
     // Create a dummy mojo channel so that the BackgroundSyncServiceImpl can be
     // instantiated
     mojo::InterfaceRequest<BackgroundSyncService> service_request =
         mojo::GetProxy(&service_ptr_);
     // Create a new BackgroundSyncServiceImpl bound to the dummy channel
-    service_impl_.reset(new BackgroundSyncServiceImpl(
-        background_sync_context_.get(), service_request.Pass()));
+    background_sync_context_->CreateService(service_request.Pass());
     base::RunLoop().RunUntilIdle();
+
+    service_impl_ = *background_sync_context_->services_.begin();
+    ASSERT_TRUE(service_impl_);
   }
 
   // Helpers for testing BackgroundSyncServiceImpl methods
   void RegisterOneShot(
       SyncRegistrationPtr sync,
       const BackgroundSyncService::RegisterCallback& callback) {
     service_impl_->Register(sync.Pass(), sw_registration_id_,
                             true /* requested_from_service_worker */, callback);
     base::RunLoop().RunUntilIdle();
   }
 
   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,
       const BackgroundSyncService::UnregisterCallback& callback) {
     service_impl_->Unregister(
         BackgroundSyncPeriodicity::BACKGROUND_SYNC_PERIODICITY_ONE_SHOT,
-        sync->id, sync->tag, sw_registration_id_, callback);
+        sync->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();
   }
 
   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_;
-  scoped_ptr<BackgroundSyncServiceImpl> service_impl_;
+  BackgroundSyncServiceImpl*
+      service_impl_;  // Owned by background_sync_context_
   SyncRegistrationPtr default_sync_registration_;
 };
 
 // Tests
 
 TEST_F(BackgroundSyncServiceImplTest, Register) {
   bool called = false;
   BackgroundSyncError error;
   SyncRegistrationPtr reg;
   RegisterOneShot(
@@ skipping 42 matching lines @@
 }
 
 TEST_F(BackgroundSyncServiceImplTest, Unregister) {
   bool unregister_called = false;
   BackgroundSyncError unregister_error;
   SyncRegistrationPtr reg;
   UnregisterOneShot(
       default_sync_registration_.Clone(),
       base::Bind(&ErrorCallback, &unregister_called, &unregister_error));
   EXPECT_TRUE(unregister_called);
-  EXPECT_EQ(BackgroundSyncError::BACKGROUND_SYNC_ERROR_NOT_FOUND,
+  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(),
@@ skipping 64 matching lines @@
   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);
 }
 
 }  // namespace content