[Background Sync] Add renderer code to interface between JS API and back-end service

content/child/background_sync/background_sync_provider.cc

Index: content/child/background_sync/background_sync_provider.cc
diff --git a/content/child/background_sync/background_sync_provider.cc b/content/child/background_sync/background_sync_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a093856367fbe36321c647e9a546a3aa8a9805f9
--- /dev/null
+++ b/content/child/background_sync/background_sync_provider.cc
@@ -0,0 +1,244 @@
+// 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/memory/scoped_ptr.h"
+#include "content/child/background_sync/background_sync_type_converters.h"
+#include "content/child/service_worker/web_service_worker_registration_impl.h"
+#include "content/child/worker_task_runner.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"
+
+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();
+}
+
+const int kNoWorkerThread = 0;
+
+}  // namespace
+
+BackgroundSyncProvider::BackgroundSyncProvider(
+    ServiceRegistry* service_registry)
+    : service_registry_(service_registry) {
+  DCHECK(service_registry);
+}
+
+BackgroundSyncProvider::~BackgroundSyncProvider() {
+}
+
+void BackgroundSyncProvider::registerBackgroundSync(
+    const blink::WebSyncRegistration* options,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncRegistrationCallbacks* callbacks) {
+  DCHECK(options);
+  DCHECK(service_worker_registration);
+  DCHECK(callbacks);
+  scoped_ptr<blink::WebSyncRegistration> options_ptr(
+      const_cast<blink::WebSyncRegistration*>(options));

[jkarlin, 2015/05/07 11:51:53]

You could keep the constness of the pointer by having
RegisterBackgroundSyncForWorker take scoped_ptr<const
blink::WebSyncRegistration>. You could then compact this some:

RegisterBackgroundSyncForWorker(make_scoped_ptr(options),                       
      service_worker_registration, callbacks,kNoWorkerThread);

[iclelland, 2015/05/09 06:41:16]

Done. But then I removed all of the *ForWorker functions, so moot.

+  RegisterBackgroundSyncForWorker(options_ptr.Pass(),
+                                  service_worker_registration, callbacks,
+                                  kNoWorkerThread);
+}
+
+void BackgroundSyncProvider::unregisterBackgroundSync(
+    blink::WebSyncRegistration::Periodicity periodicity,
+    int64_t id, const blink::WebString& tag,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncUnregistrationCallbacks* callbacks) {
+  DCHECK(service_worker_registration);
+  DCHECK(callbacks);
+  UnregisterBackgroundSyncForWorker(periodicity, id, tag,
+                                    service_worker_registration, callbacks,
+                                    kNoWorkerThread);
+}
+
+void BackgroundSyncProvider::getRegistration(
+    blink::WebSyncRegistration::Periodicity periodicity,
+    const blink::WebString& tag,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncRegistrationCallbacks* callbacks) {
+  DCHECK(service_worker_registration);
+  DCHECK(callbacks);
+  GetRegistrationForWorker(periodicity, tag, service_worker_registration,
+                           callbacks, kNoWorkerThread);
+}
+
+void BackgroundSyncProvider::getRegistrations(
+    blink::WebSyncRegistration::Periodicity periodicity,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncGetRegistrationsCallbacks* callbacks) {
+  DCHECK(service_worker_registration);
+  DCHECK(callbacks);
+  GetRegistrationsForWorker(periodicity, service_worker_registration, callbacks,
+                            kNoWorkerThread);
+}
+
+void BackgroundSyncProvider::RegisterBackgroundSyncForWorker(

[jkarlin, 2015/05/07 11:51:53]

Given the comments for this class, it seems like BackgroundSyncProvider should
be worker-agnostic. Worker code should be in the ProxyThread class. In which
case, how about removing the *ForWorker functions and removing the worker code
from the *Callback functions. Then, you can put the callback thread jumping
logic in the callback that the proxy provides to the BackgroundSyncProvider.

In other words:

BackgroundSyncProviderThreadProxy::getRegistration(callback) {
  // 1. Create a new WebSyncRegistrationCallbacks that jumps to this worker
thread and then runs |callback| with the success or error. 
  // 2. Jump to the main thread and call BackgroundSyncProvider::getRegistration
with the new callback.
}

[iclelland, 2015/05/09 06:41:16]

Done. I really like this approach, rather than switching behaviour based on the
worker_thread_id. There's a bit more work to do here, mostly regarding pointer
ownership of the various callback objects, but I've updated the CL with the new
structure.

+    scoped_ptr<blink::WebSyncRegistration> options,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncRegistrationCallbacks* callbacks,
+    int worker_thread_id) {
+  int64 service_worker_registration_id =
+      GetServiceWorkerRegistrationId(service_worker_registration);
+
+  GetBackgroundSyncServicePtr()->Register(
+      mojo::ConvertTo<SyncRegistrationPtr>(*options),
+      service_worker_registration_id,
+      base::Bind(&BackgroundSyncProvider::RegisterCallback,
+                 base::Unretained(this),callbacks,
+                 worker_thread_id));
+}
+
+void BackgroundSyncProvider::UnregisterBackgroundSyncForWorker(
+    blink::WebSyncRegistration::Periodicity periodicity,
+    int64_t id,
+    const blink::WebString& tag,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncUnregistrationCallbacks* callbacks,
+    int worker_thread_id) {
+  int64 service_worker_registration_id =
+      GetServiceWorkerRegistrationId(service_worker_registration);
+
+  GetBackgroundSyncServicePtr()->Unregister(
+      mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity), id,
+      tag.utf8(), service_worker_registration_id,
+      base::Bind(&BackgroundSyncProvider::UnregisterCallback,
+                 base::Unretained(this),callbacks,
+                 worker_thread_id));
+}
+
+void BackgroundSyncProvider::GetRegistrationForWorker(
+    blink::WebSyncRegistration::Periodicity periodicity,
+    const blink::WebString& tag,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncRegistrationCallbacks* callbacks,
+    int worker_thread_id) {
+  int64 service_worker_registration_id =
+      GetServiceWorkerRegistrationId(service_worker_registration);
+
+  GetBackgroundSyncServicePtr()->GetRegistration(
+      mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity),
+      tag.utf8(), service_worker_registration_id,
+      base::Bind(&BackgroundSyncProvider::RegisterCallback,
+                 base::Unretained(this),callbacks,
+                 worker_thread_id));
+}
+
+void BackgroundSyncProvider::GetRegistrationsForWorker(
+    blink::WebSyncRegistration::Periodicity periodicity,
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebSyncGetRegistrationsCallbacks* callbacks,
+    int worker_thread_id) {
+  int64 service_worker_registration_id =
+      GetServiceWorkerRegistrationId(service_worker_registration);
+
+  GetBackgroundSyncServicePtr()->GetRegistrations(
+      mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity),
+      service_worker_registration_id,
+      base::Bind(&BackgroundSyncProvider::GetRegistrationsCallback,
+                 base::Unretained(this),
+                 callbacks,
+                 worker_thread_id));
+}
+
+void BackgroundSyncProvider::RegisterCallback(
+    blink::WebSyncRegistrationCallbacks* callbacks,
+    int worker_thread_id,
+    const SyncRegistrationPtr &options) {
+  // TODO(iclelland): Pass through the various errors from the manager to here
+  // and handle them appropriately.
+  scoped_ptr<blink::WebSyncRegistration> result;
+  if (!options.is_null())
+    result = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(options);
+
+  if (worker_thread_id == kNoWorkerThread) {
+    callbacks->onSuccess(result.release());
+  } else {
+      // If the worker thread has been destroyed, then this task will be
+      // silently discarded.
+      WorkerTaskRunner::Instance()->PostTask(
+          worker_thread_id,
+          base::Bind(&blink::WebSyncRegistrationCallbacks::onSuccess,
+                     base::Unretained(callbacks),
+                     result.release()));
+  }
+}
+
+void BackgroundSyncProvider::UnregisterCallback(
+    blink::WebSyncUnregistrationCallbacks *callbacks, int worker_thread_id,
+    bool success) {
+  // TODO(iclelland): Pass through the various errors from the manager to here
+  // and handle them appropriately.
+  if (worker_thread_id == kNoWorkerThread) {
+    if (success) {
+      callbacks->onSuccess(new bool(success));
+    } else {
+      callbacks->onError(new blink::WebSyncError(
+          blink::WebSyncError::ErrorTypeUnknown,
+          "Sync registration does not exist"));
+    }
+  } else {
+    if (success) {
+      // If the worker thread has been destroyed, then this task will be
+      // silently discarded.
+      WorkerTaskRunner::Instance()->PostTask(
+          worker_thread_id,
+          base::Bind(&blink::WebSyncUnregistrationCallbacks::onSuccess,
+                     base::Unretained(callbacks),
+                     new bool(success)));
+    } else {
+      // If the worker thread has been destroyed, then this task will be
+      // silently discarded.
+      WorkerTaskRunner::Instance()->PostTask(
+          worker_thread_id,
+          base::Bind(&blink::WebSyncUnregistrationCallbacks::onError,
+                     base::Unretained(callbacks),
+                     new blink::WebSyncError(
+                         blink::WebSyncError::ErrorTypeUnknown,
+                         "Sync registration does not exist")));
+    }
+  }
+}
+
+void BackgroundSyncProvider::GetRegistrationsCallback(
+    blink::WebSyncGetRegistrationsCallbacks* callbacks,
+    int worker_thread_id,
+    const mojo::Array<SyncRegistrationPtr> &registrations) {
+  // TODO(iclelland): Pass through the various errors from the manager to here
+  // and handle them appropriately.
+  blink::WebVector<blink::WebSyncRegistration*>* results =
+      new blink::WebVector<blink::WebSyncRegistration*>(registrations.size());
+  for (size_t i=0; i < registrations.size(); ++i) {
+    (*results)[i] = mojo::ConvertTo<scoped_ptr<blink::WebSyncRegistration>>(

[jkarlin, 2015/05/07 11:51:53]

make_scoped_ptr(registrations[i])

[iclelland, 2015/05/09 06:41:16]

registrations[i] is a content::SyncRegistrationPtr; here we're calling
mojo::ConvertTo<> on that object, to return a
scoped_ptr<blink::WebSyncRegistration> (from comments on
https://codereview.chromium.org/1106193002/diff/1/content/child/background_sy...)

+        registrations[i]).release();
+  }
+  if (worker_thread_id == kNoWorkerThread) {
+    callbacks->onSuccess(results);
+  } else {
+       WorkerTaskRunner::Instance()->PostTask(
+          worker_thread_id,
+          base::Bind(&blink::WebSyncGetRegistrationsCallbacks::onSuccess,
+                     base::Unretained(callbacks),
+                     results));
+  }
+}
+
+BackgroundSyncServicePtr&
+    BackgroundSyncProvider::GetBackgroundSyncServicePtr() {
+  if (!background_sync_service_.get())
+    service_registry_->ConnectToRemoteService(&background_sync_service_);
+  return background_sync_service_;
+}
+
+}  // namespace content