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"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_local.h"
 #include "content/child/background_sync/background_sync_provider.h"
 
 using base::LazyInstance;
 using base::ThreadLocalPointer;
 
 namespace content {
 
 namespace {
 
+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())));
+}
+
 // CallbackThreadAdapter<S,T> is a wrapper for WebCallbacks<S,T> which
 // switches to a specific thread before calling the wrapped callback's
 // onSuccess or onError methods.
 //
 // Takes ownership of the WebCallbacks object which it wraps.
 template <typename S, typename T>
 class CallbackThreadAdapter : public blink::WebCallbacks<S, T> {
  public:
   CallbackThreadAdapter(scoped_ptr<blink::WebCallbacks<S, T>> callbacks,
                         int worker_thread_id)
@@ skipping 136 matching lines @@
       FROM_HERE,
       base::Bind(&BackgroundSyncProvider::getPermissionStatus,
                  base::Unretained(sync_provider_), periodicity,
                  service_worker_registration,
                  new CallbackThreadAdapter<blink::WebSyncPermissionStatus*,
                                            blink::WebSyncError*>(
                      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