Flush out initial [un]registerServiceWorker roundtrip

content/child/service_worker/web_service_worker_registry_proxy.cc

Index: content/child/service_worker/web_service_worker_registry_proxy.cc
diff --git a/content/child/service_worker/web_service_worker_registry_proxy.cc b/content/child/service_worker/web_service_worker_registry_proxy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2f1e89851bff523e23e5a5daba3cb13364a2d434
--- /dev/null
+++ b/content/child/service_worker/web_service_worker_registry_proxy.cc
@@ -0,0 +1,37 @@
+// Copyright 2013 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/service_worker/web_service_worker_registry_proxy.h"
+
+#include "base/logging.h"
+#include "content/child/child_thread.h"
+#include "content/child/service_worker/service_worker_dispatcher.h"
+#include "content/common/service_worker_messages.h"
+#include "ipc/ipc_sender.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/WebURL.h"
+
+using WebKit::WebString;
+using WebKit::WebURL;
+
+namespace content {
+
+WebServiceWorkerRegistryImpl::~WebServiceWorkerRegistryImpl() {}
+
+void WebServiceWorkerRegistryImpl::registerServiceWorker(
+    const WebString& pattern,
+    const WebURL& scriptUrl,
+    WebServiceWorkerCallbacks* callbacks) {
+  ChildThread::current()->service_worker_dispatcher()->RegisterServiceWorker(
+      pattern, scriptUrl, callbacks);

[kinuko, 2013/09/30 12:41:17]

So we start with an assumption that we call this only on the main thread (while
we also have some code which works on any threads)? (just asking)

If that's the case we might be able to start with slightly simpler/less code?
(But in the way that no much effort will be necessary when we're converting it
to real multi-threaded)

[alecflett, 2013/10/01 00:17:04]

Well my intention was to support any main or worker thread by default when
working in a child process - meaning you could call registerServiceWorker() from
a worker. I didn't think I was assuming I was only on the main thread, maybe I'm
misunderstanding ChildThread::current() here? Is there an assertion to make sure
we're being called on the main thread or the worker thread, but not any other
random threads in the renderer?

Please let me know if there are additional things I should be protecting
against. I'm also starting to investigate tests so that might be a good place to
sanity check my assumptions as well.

[kinuko, 2013/10/01 07:48:11]

ChildThread::current() returns null on non-main thread, as noted in the header
file comment (content/child/child_thread.h).
If this could be called on an arbitrary threads I think we should rather call
ServiceWorkerDispatcher::ThreadSpecificInstance() to get an instance. (If we're
on the main thread we'll automatically get the same one as
ChildThread::current()->service_worker_dispatcher())

+}
+
+void WebServiceWorkerRegistryImpl::unregisterServiceWorker(
+    const WebString& pattern,
+    WebServiceWorkerCallbacks* callbacks) {
+  ChildThread::current()->service_worker_dispatcher()->UnregisterServiceWorker(
+      pattern, callbacks);
+}
+
+}  // namespace content