BackgroundSyncManager tracks client registrations

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/browser/background_sync/background_sync_registration.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.min_period = in->min_period_ms;
   out.power_state = static_cast<SyncPowerState>(in->power_state);
   out.network_state = static_cast<SyncNetworkState>(in->network_state);
   out.periodicity = static_cast<SyncPeriodicity>(in->periodicity);
   return out;
 }
 
-SyncRegistrationPtr ToMojoRegistration(const BackgroundSyncRegistration& in) {
+SyncRegistrationPtr ToMojoRegistration(
+    const BackgroundSyncRegistrationHandle& in) {
   SyncRegistrationPtr out(content::SyncRegistration::New());
-  out->id = in.id();
+  out->id = in.handle_id();
   out->tag = in.options()->tag;
   out->min_period_ms = in.options()->min_period;
   out->periodicity = static_cast<content::BackgroundSyncPeriodicity>(
       in.options()->periodicity);
   out->power_state =
       static_cast<content::BackgroundSyncPowerState>(in.options()->power_state);
   out->network_state = static_cast<content::BackgroundSyncNetworkState>(
       in.options()->network_state);
   return out.Pass();
 }
@@ skipping 37 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);
+  BackgroundSyncManager* background_sync_manager =
+      background_sync_context_->background_sync_manager();
+  DCHECK(background_sync_manager);

[michaeln, 2015/08/21 02:39:24]

You could put this larger expression inside the dcheck so the dtor is obviously
and completely empty in release builds.

DCHECK(background_sync_context_->background_sync_manager());

[jkarlin, 2015/08/25 17:32:58]

Done.

 }
 
 BackgroundSyncServiceImpl::BackgroundSyncServiceImpl(
     BackgroundSyncContextImpl* background_sync_context,
     mojo::InterfaceRequest<BackgroundSyncService> request)
     : background_sync_context_(background_sync_context),
       binding_(this, request.Pass()),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(background_sync_context);
@@ skipping 21 matching lines @@
   DCHECK(background_sync_manager);
   background_sync_manager->Register(
       sw_registration_id, mgr_options,
       base::Bind(&BackgroundSyncServiceImpl::OnRegisterResult,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncServiceImpl::Unregister(
     BackgroundSyncPeriodicity periodicity,
     int64_t id,
-    const mojo::String& tag,
     int64_t sw_registration_id,
     const UnregisterCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BackgroundSyncManager* background_sync_manager =
       background_sync_context_->background_sync_manager();
   DCHECK(background_sync_manager);
-  background_sync_manager->Unregister(
-      sw_registration_id, tag, content::SYNC_ONE_SHOT, id,
+
+  BackgroundSyncRegistrationHandle* registration =
+      hosted_registrations_.Lookup(id);
+  if (!registration) {
+    callback.Run(BACKGROUND_SYNC_ERROR_NOT_ALLOWED);
+    return;
+  }
+
+  registration->Unregister(
+      sw_registration_id,
       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);
@@ skipping 25 matching lines @@
     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::TrackRegistration(
+    SyncRegistrationPtr sync_registration) {
+  // TODO(jkarlin): We dont need the whole SyncRegistrationPtr here, just the id
+  // would do.
+
+  // Registrations that the client acquires without the
+  // BackgroundSyncServiceImpl's knowing are registered here.
+  BackgroundSyncManager* background_sync_manager =
+      background_sync_context_->background_sync_manager();
+  DCHECK(background_sync_manager);
+
+  if (hosted_registrations_.Lookup(sync_registration->id)) {

[michaeln, 2015/08/21 02:39:24]

This is actually using a 'handle_id' to lookup a 'handle' but its hard to tell
that just by reading this one line of code.

if (handles_in_use_.Lookup(xxx->handle_id))
  // ohh nooo mr bill, trying to adopt a handle that's already in use!!

[jkarlin, 2015/08/25 17:32:58]

This method is gone now.

+    // TODO(jkarlin): Abort client.
+    LOG(WARNING) << "Client attempted to track an already tracked registration";
+    return;
+  }
+
+  scoped_ptr<BackgroundSyncRegistrationHandle> registration(

[michaeln, 2015/08/21 02:39:24]

nit: put 'handle' somewhere in the local variable name, maybe just call it
'handle'?

[jkarlin, 2015/08/25 17:32:58]

This method is gone now.

+      new BackgroundSyncRegistrationHandle(background_sync_manager,
+                                           sync_registration->id));
+
+  if (!registration->IsValid()) {
+    // TODO(jkarlin): Abort client.
+    LOG(WARNING) << "Client attempted to track a non-existent registration";
+    return;
+  }
+
+  hosted_registrations_.AddWithID(registration.release(),
+                                  sync_registration->id);
+}
+
+void BackgroundSyncServiceImpl::ReleaseRegistration(int64_t sync_id) {
+  if (!hosted_registrations_.Lookup(sync_id)) {
+    // TODO(jkarlin): Abort client.
+    LOG(WARNING) << "Client attempted to release non-existing registration";
+    return;
+  }
+
+  hosted_registrations_.Remove(sync_id);
+}
+
 void BackgroundSyncServiceImpl::OnRegisterResult(
     const RegisterCallback& callback,
     BackgroundSyncStatus status,
-    const BackgroundSyncRegistration& result) {
+    scoped_ptr<BackgroundSyncRegistrationHandle> result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  SyncRegistrationPtr mojoResult = ToMojoRegistration(result);
+  BackgroundSyncRegistrationHandle* result_ptr = result.get();
+
+  if (status != BACKGROUND_SYNC_STATUS_OK) {
+    callback.Run(static_cast<content::BackgroundSyncError>(status),
+                 SyncRegistrationPtr(content::SyncRegistration::New()));
+    return;
+  }
+
+  hosted_registrations_.AddWithID(result.release(), result_ptr->handle_id());
+  SyncRegistrationPtr mojoResult = ToMojoRegistration(*result_ptr);
   callback.Run(static_cast<content::BackgroundSyncError>(status),
                mojoResult.Pass());
 }
 
 void BackgroundSyncServiceImpl::OnUnregisterResult(
     const UnregisterCallback& callback,
     BackgroundSyncStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(static_cast<content::BackgroundSyncError>(status));
 }
 
 void BackgroundSyncServiceImpl::OnGetRegistrationsResult(
     const GetRegistrationsCallback& callback,
     BackgroundSyncStatus status,
-    const std::vector<BackgroundSyncRegistration>& result_registrations) {
+    scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
+        result_registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   mojo::Array<content::SyncRegistrationPtr> mojo_registrations(0);
-  for (const auto& registration : result_registrations)
-    mojo_registrations.push_back(ToMojoRegistration(registration));
+  for (BackgroundSyncRegistrationHandle* registration : *result_registrations) {
+    hosted_registrations_.AddWithID(registration, registration->handle_id());
+    mojo_registrations.push_back(ToMojoRegistration(*registration));
+  }
+
+  result_registrations->weak_clear();
+
   callback.Run(static_cast<content::BackgroundSyncError>(status),
                mojo_registrations.Pass());
 }
 
 }  // namespace content