Change BackgroundSyncContextImpl to use StrongBindingSet.

content/browser/background_sync/background_sync_service_impl.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 "background_sync_registration_handle.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
-#include "content/browser/background_sync/background_sync_context_impl.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
 
 // TODO(iclelland): Move these converters to mojo::TypeConverter template
 // specializations.
 
 BackgroundSyncRegistrationOptions ToBackgroundSyncRegistrationOptions(
@@ skipping 62 matching lines @@
 
 COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_PERIODICITY_PERIODIC,
                              SyncPeriodicity::SYNC_PERIODIC);
 COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_PERIODICITY_ONE_SHOT,
                              SyncPeriodicity::SYNC_ONE_SHOT);
 COMPILE_ASSERT_MATCHING_ENUM(BACKGROUND_SYNC_PERIODICITY_MAX,
                              SyncPeriodicity::SYNC_ONE_SHOT);
 
 BackgroundSyncServiceImpl::~BackgroundSyncServiceImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(background_sync_context_->background_sync_manager());
 }
 
 BackgroundSyncServiceImpl::BackgroundSyncServiceImpl(
-    BackgroundSyncContextImpl* background_sync_context,
-    mojo::InterfaceRequest<BackgroundSyncService> request)
-    : background_sync_context_(background_sync_context),
-      binding_(this, request.Pass()),
+    BackgroundSyncManager* background_sync_manager)
+    : background_sync_manager_(background_sync_manager),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(background_sync_context);
-
-  binding_.set_connection_error_handler(
-      base::Bind(&BackgroundSyncServiceImpl::OnConnectionError,
-                 base::Unretained(this) /* the channel is owned by this */));
-}
-
-void BackgroundSyncServiceImpl::OnConnectionError() {
-  background_sync_context_->ServiceHadConnectionError(this);
-  // |this| is now deleted.
+  DCHECK(background_sync_manager);
 }
 
 void BackgroundSyncServiceImpl::Register(content::SyncRegistrationPtr options,
                                          int64_t sw_registration_id,
                                          bool requested_from_service_worker,
                                          const RegisterCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BackgroundSyncRegistrationOptions mgr_options =
       ToBackgroundSyncRegistrationOptions(options);
 
-  BackgroundSyncManager* background_sync_manager =
-      background_sync_context_->background_sync_manager();
-  DCHECK(background_sync_manager);
-  background_sync_manager->Register(
+  background_sync_manager_->Register(
       sw_registration_id, mgr_options, requested_from_service_worker,
       base::Bind(&BackgroundSyncServiceImpl::OnRegisterResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::Unregister(
     BackgroundSyncRegistrationHandle::HandleId handle_id,
     int64_t sw_registration_id,
     const UnregisterCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 10 matching lines @@
       base::Bind(&BackgroundSyncServiceImpl::OnUnregisterResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::GetRegistration(
     BackgroundSyncPeriodicity periodicity,
     const mojo::String& tag,
     int64_t sw_registration_id,
     const GetRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BackgroundSyncManager* background_sync_manager =
-      background_sync_context_->background_sync_manager();
-  DCHECK(background_sync_manager);
-  background_sync_manager->GetRegistration(
+  background_sync_manager_->GetRegistration(
       sw_registration_id, tag.get(), static_cast<SyncPeriodicity>(periodicity),
       base::Bind(&BackgroundSyncServiceImpl::OnRegisterResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::GetRegistrations(
     BackgroundSyncPeriodicity periodicity,
     int64_t sw_registration_id,
     const GetRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BackgroundSyncManager* background_sync_manager =
-      background_sync_context_->background_sync_manager();
-  DCHECK(background_sync_manager);
-  background_sync_manager->GetRegistrations(
+  background_sync_manager_->GetRegistrations(
       sw_registration_id, static_cast<SyncPeriodicity>(periodicity),
       base::Bind(&BackgroundSyncServiceImpl::OnGetRegistrationsResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::GetPermissionStatus(
     BackgroundSyncPeriodicity periodicity,
     int64_t sw_registration_id,
     const GetPermissionStatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(iclelland): Implement a real policy. This is a stub implementation.
   // OneShot: crbug.com/482091
   // Periodic: crbug.com/482093
   callback.Run(BACKGROUND_SYNC_ERROR_NONE, PERMISSION_STATUS_GRANTED);
 }
 
 void BackgroundSyncServiceImpl::DuplicateRegistrationHandle(
     BackgroundSyncRegistrationHandle::HandleId handle_id,
     const DuplicateRegistrationHandleCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BackgroundSyncManager* background_sync_manager =
-      background_sync_context_->background_sync_manager();
-  DCHECK(background_sync_manager);
 
   scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle =
-      background_sync_manager->DuplicateRegistrationHandle(handle_id);
+      background_sync_manager_->DuplicateRegistrationHandle(handle_id);
 
   BackgroundSyncRegistrationHandle* handle_ptr = registration_handle.get();
 
   if (!registration_handle) {
     callback.Run(BACKGROUND_SYNC_ERROR_NOT_FOUND,
                  SyncRegistrationPtr(content::SyncRegistration::New()));
     return;
   }
 
   active_handles_.AddWithID(registration_handle.release(),
@@ skipping 76 matching lines @@
 
 void BackgroundSyncServiceImpl::OnNotifyWhenFinishedResult(
     const NotifyWhenFinishedCallback& callback,
     BackgroundSyncStatus status,
     BackgroundSyncState sync_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(static_cast<content::BackgroundSyncError>(status), sync_state);
 }
 
 }  // namespace content