Use mojo to connect to BackgroundSyncManager object

content/child/background_sync/background_sync_provider.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.h"
 
 #include "base/bind.h"
+#include "base/lazy_instance.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_type_converters.h"
+#include "content/child/child_thread_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
-#include "content/child/worker_task_runner.h"
 #include "content/public/common/background_sync.mojom.h"
 #include "content/public/common/permission_status.mojom.h"
-#include "content/public/common/service_registry.h"
 #include "third_party/WebKit/public/platform/modules/background_sync/WebSyncError.h"
 #include "third_party/WebKit/public/platform/modules/background_sync/WebSyncRegistration.h"
 
+using base::LazyInstance;
+using base::ThreadLocalPointer;
+
 namespace content {
 namespace {
 
 // Returns the id of the given |service_worker_registration|, which
 // is only available on the implementation of the interface.
 int64 GetServiceWorkerRegistrationId(
     blink::WebServiceWorkerRegistration* service_worker_registration) {
   return static_cast<WebServiceWorkerRegistrationImpl*>(
              service_worker_registration)->registration_id();
 }
 
+void ConnectToServiceOnMainThread(
+    mojo::InterfaceRequest<BackgroundSyncService> request) {
+  DCHECK(ChildThreadImpl::current());
+  ChildThreadImpl::current()->service_registry()->ConnectToRemoteService(
+      request.Pass());
+}
+
+LazyInstance<ThreadLocalPointer<BackgroundSyncProvider>>::Leaky
+    g_sync_provider_tls = LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
-BackgroundSyncProvider::BackgroundSyncProvider(
-    ServiceRegistry* service_registry)
-    : service_registry_(service_registry), background_sync_service_(14) {
-  DCHECK(service_registry);
+BackgroundSyncProvider::~BackgroundSyncProvider() {
+  g_sync_provider_tls.Pointer()->Set(nullptr);
 }
 
-BackgroundSyncProvider::~BackgroundSyncProvider() {
+// static
+BackgroundSyncProvider*
+BackgroundSyncProvider::GetOrCreateThreadSpecificInstance(
+    base::SingleThreadTaskRunner* main_thread_task_runner) {
+  DCHECK(main_thread_task_runner);
+  if (g_sync_provider_tls.Pointer()->Get())
+    return g_sync_provider_tls.Pointer()->Get();
+
+  bool have_worker_id = (WorkerThread::GetCurrentId() > 0);
+  if (!main_thread_task_runner->BelongsToCurrentThread() && !have_worker_id) {
+    // On a worker thread, this could happen if this method is called
+    // very late (say by a garbage collected SyncRegistration).
+    return nullptr;
+  }
+
+  BackgroundSyncProvider* instance =
+      new BackgroundSyncProvider(main_thread_task_runner);
+
+  if (have_worker_id) {
+    // For worker threads, use the observer interface to clean up when workers
+    // are stopped.
+    WorkerThread::AddObserver(instance);
+  }
+
+  return instance;
 }
 
 void BackgroundSyncProvider::registerBackgroundSync(
     const blink::WebSyncRegistration* options,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     bool requested_from_service_worker,
     blink::WebSyncRegistrationCallbacks* callbacks) {
   DCHECK(options);
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
@@ skipping 108 matching lines @@
 }
 
 void BackgroundSyncProvider::DuplicateRegistrationHandle(
     int64_t handle_id,
     const BackgroundSyncService::DuplicateRegistrationHandleCallback&
         callback) {
   GetBackgroundSyncServicePtr()->DuplicateRegistrationHandle(handle_id,
                                                              callback);
 }
 
+void BackgroundSyncProvider::WillStopCurrentWorkerThread() {
+  delete this;
+}
+
+BackgroundSyncProvider::BackgroundSyncProvider(
+    const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
+    : main_thread_task_runner_(main_task_runner) {
+  DCHECK(main_task_runner);
+  g_sync_provider_tls.Pointer()->Set(this);
+}
+
 void BackgroundSyncProvider::RegisterCallback(
     scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacks,
     BackgroundSyncError error,
     const SyncRegistrationPtr& options) {
   // TODO(iclelland): Determine the correct error message to return in each case
   scoped_ptr<blink::WebSyncRegistration> result;
   switch (error) {
     case BACKGROUND_SYNC_ERROR_NONE:
       if (!options.is_null())
         result =
@@ skipping 193 matching lines @@
       callbacks->onError(
           blink::WebSyncError(blink::WebSyncError::ErrorTypeUnknown,
                               "No service worker is active."));
       break;
   }
 }
 
 BackgroundSyncServicePtr&
 BackgroundSyncProvider::GetBackgroundSyncServicePtr() {
   if (!background_sync_service_.get()) {
-    service_registry_->ConnectToRemoteService(
-        mojo::GetProxy(&background_sync_service_));
+    mojo::InterfaceRequest<BackgroundSyncService> request =
+        mojo::GetProxy(&background_sync_service_);
+    main_thread_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ConnectToServiceOnMainThread, base::Passed(&request)));
   }
   return background_sync_service_;
 }
 
 }  // namespace content