[BackgroundSync] Remove BackgroundSyncRegistrationHandle

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 <utility>
 
-#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(
     const SyncRegistrationPtr& in) {
   BackgroundSyncRegistrationOptions out;
 
   out.tag = in->tag;
   out.network_state = static_cast<SyncNetworkState>(in->network_state);
   return out;
 }
 
-SyncRegistrationPtr ToMojoRegistration(
-    const BackgroundSyncRegistrationHandle& in) {
+SyncRegistrationPtr ToMojoRegistration(const BackgroundSyncRegistration& in) {
   SyncRegistrationPtr out(content::SyncRegistration::New());
-  out->handle_id = in.handle_id();
+  out->id = in.id();
   out->tag = in.options()->tag;
   out->network_state = static_cast<content::BackgroundSyncNetworkState>(
       in.options()->network_state);
   return out;
 }
 
 }  // namespace
 
 #define COMPILE_ASSERT_MATCHING_ENUM(mojo_name, manager_name) \
   static_assert(static_cast<int>(content::mojo_name) ==       \
@@ skipping 71 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
   background_sync_manager->GetRegistrations(
       sw_registration_id,
       base::Bind(&BackgroundSyncServiceImpl::OnGetRegistrationsResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
-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);
-
-  BackgroundSyncRegistrationHandle* handle_ptr = registration_handle.get();
-
-  if (!registration_handle) {
-    callback.Run(BackgroundSyncError::NOT_FOUND,
-                 SyncRegistrationPtr(content::SyncRegistration::New()));
-    return;
-  }
-
-  active_handles_.AddWithID(registration_handle.release(),
-                            handle_ptr->handle_id());
-  SyncRegistrationPtr mojoResult = ToMojoRegistration(*handle_ptr);
-  callback.Run(BackgroundSyncError::NONE, std::move(mojoResult));
-}
-
-void BackgroundSyncServiceImpl::ReleaseRegistration(
-    BackgroundSyncRegistrationHandle::HandleId handle_id) {
-  if (!active_handles_.Lookup(handle_id)) {
-    // TODO(jkarlin): Abort client.
-    LOG(WARNING) << "Client attempted to release non-existing registration";
-    return;
-  }
-
-  active_handles_.Remove(handle_id);
-}
-
 void BackgroundSyncServiceImpl::OnRegisterResult(
     const RegisterCallback& callback,
     BackgroundSyncStatus status,
-    scoped_ptr<BackgroundSyncRegistrationHandle> result) {
+    scoped_ptr<BackgroundSyncRegistration> result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  BackgroundSyncRegistrationHandle* result_ptr = result.get();
 
   if (status != BACKGROUND_SYNC_STATUS_OK) {
     callback.Run(static_cast<content::BackgroundSyncError>(status),
                  SyncRegistrationPtr(content::SyncRegistration::New()));
     return;
   }
 
   DCHECK(result);
-  active_handles_.AddWithID(result.release(), result_ptr->handle_id());
-  SyncRegistrationPtr mojoResult = ToMojoRegistration(*result_ptr);
+  SyncRegistrationPtr mojoResult = ToMojoRegistration(*result);
   callback.Run(static_cast<content::BackgroundSyncError>(status),
                std::move(mojoResult));
 }
 
 void BackgroundSyncServiceImpl::OnGetRegistrationsResult(
     const GetRegistrationsCallback& callback,
     BackgroundSyncStatus status,
-    scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
-        result_registrations) {
+    scoped_ptr<ScopedVector<BackgroundSyncRegistration>> result_registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(result_registrations);
 
   mojo::Array<content::SyncRegistrationPtr> mojo_registrations;
-  for (BackgroundSyncRegistrationHandle* registration : *result_registrations) {
-    active_handles_.AddWithID(registration, registration->handle_id());
+  for (const BackgroundSyncRegistration* registration : *result_registrations)
     mojo_registrations.push_back(ToMojoRegistration(*registration));
-  }
-
-  result_registrations->weak_clear();
 
   callback.Run(static_cast<content::BackgroundSyncError>(status),
                std::move(mojo_registrations));
 }
 
 }  // namespace content