BackgroundSyncManager tracks client registrations

content/child/background_sync/background_sync_provider_thread_proxy.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/child/background_sync/background_sync_provider_thread_proxy.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
@@ skipping 57 matching lines @@
   }
 
  private:
   scoped_ptr<blink::WebCallbacks<S, T>> callbacks_;
   int worker_thread_id_;
 };
 
 LazyInstance<ThreadLocalPointer<BackgroundSyncProviderThreadProxy>>::Leaky
     g_sync_provider_tls = LAZY_INSTANCE_INITIALIZER;
 
+void DuplicateRegistrationHandleCallbackOnSWThread(
+    const BackgroundSyncService::DuplicateRegistrationHandleCallback& callback,
+    BackgroundSyncError error,
+    SyncRegistrationPtr registration) {
+  callback.Run(error, registration.Pass());
+}
+
+void DuplicateRegistrationHandleCallbackOnMainThread(
+    int worker_thread_id,
+    const BackgroundSyncService::DuplicateRegistrationHandleCallback& callback,
+    BackgroundSyncError error,
+    SyncRegistrationPtr registration) {
+  WorkerTaskRunner::Instance()->PostTask(
+      worker_thread_id,
+      base::Bind(&DuplicateRegistrationHandleCallbackOnSWThread, callback,
+                 error, base::Passed(registration.Pass())));
+}
+
 }  // anonymous namespace
 
 // static
 BackgroundSyncProviderThreadProxy*
 BackgroundSyncProviderThreadProxy::GetThreadInstance(
     base::SingleThreadTaskRunner* main_thread_task_runner,
     BackgroundSyncProvider* sync_provider) {
   if (g_sync_provider_tls.Pointer()->Get())
     return g_sync_provider_tls.Pointer()->Get();
 
@@ skipping 94 matching lines @@
       FROM_HERE,
       base::Bind(
           &BackgroundSyncProvider::getPermissionStatus,
           base::Unretained(sync_provider_), periodicity,
           service_worker_registration,
           new CallbackThreadAdapter<blink::WebSyncGetPermissionStatusCallbacks>(
               make_scoped_ptr(callbacks),
               WorkerTaskRunner::Instance()->CurrentWorkerId())));
 }
 
+void BackgroundSyncProviderThreadProxy::releaseRegistration(int64_t handle_id) {
+  main_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&BackgroundSyncProvider::releaseRegistration,
+                            base::Unretained(sync_provider_), handle_id));
+}
+
+void BackgroundSyncProviderThreadProxy::DuplicateRegistrationHandle(
+    int64 handle_id,
+    int64 service_worker_registration_id,
+    const BackgroundSyncService::DuplicateRegistrationHandleCallback&
+        callback) {
+  main_thread_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&BackgroundSyncProvider::DuplicateRegistrationHandle,
+                 base::Unretained(sync_provider_), handle_id,
+                 service_worker_registration_id,
+                 base::Bind(&DuplicateRegistrationHandleCallbackOnMainThread,
+                            WorkerTaskRunner::Instance()->CurrentWorkerId(),
+                            callback)));
+}
+
 void BackgroundSyncProviderThreadProxy::OnWorkerRunLoopStopped() {
   delete this;
 }
 
 BackgroundSyncProviderThreadProxy::BackgroundSyncProviderThreadProxy(
     base::SingleThreadTaskRunner* main_thread_task_runner,
     BackgroundSyncProvider* sync_provider)
     : main_thread_task_runner_(main_thread_task_runner),
       sync_provider_(sync_provider) {
   g_sync_provider_tls.Pointer()->Set(this);
 }
 
 BackgroundSyncProviderThreadProxy::~BackgroundSyncProviderThreadProxy() {
   g_sync_provider_tls.Pointer()->Set(nullptr);
 }
 
 }  // namespace content