Flush out initial [un]registerServiceWorker roundtrip

content/child/service_worker/service_worker_dispatcher.cc

+// 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/service_worker_dispatcher.h"
+
+#include "base/lazy_instance.h"
+#include "base/threading/thread_local.h"
+#include "content/child/service_worker/web_service_worker_impl.h"
+#include "content/child/thread_safe_sender.h"
+#include "content/common/service_worker_messages.h"
+#include "third_party/WebKit/public/web/WebSecurityOrigin.h"
+
+using WebKit::WebServiceWorkerProvider;
+using base::ThreadLocalPointer;
+using webkit_glue::WorkerTaskRunner;
+
+namespace content {
+
+static base::LazyInstance<ThreadLocalPointer<ServiceWorkerDispatcher> >::Leaky
+    g_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
+
+ServiceWorkerDispatcher* const kHasBeenDeleted =
+    reinterpret_cast<ServiceWorkerDispatcher*>(0x1);
+
+ServiceWorkerDispatcher::ServiceWorkerDispatcher(
+    ThreadSafeSender* thread_safe_sender)
+    : thread_safe_sender_(thread_safe_sender) {
+  g_dispatcher_tls.Pointer()->Set(this);
+}
+
+ServiceWorkerDispatcher::~ServiceWorkerDispatcher() {
+  g_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
+}
+
+void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered,
+                        OnServiceWorkerRegistered)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered,
+                        OnServiceWorkerUnregistered)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  DCHECK(handled) << "Unhandled message:" << msg.type();
+}
+
+bool ServiceWorkerDispatcher::Send(IPC::Message* msg) {
+  return thread_safe_sender_->Send(msg);
+}
+
+static int CurrentWorkerId() {
+  return WorkerTaskRunner::Instance()->CurrentWorkerId();
+}
+
+void ServiceWorkerDispatcher::RegisterServiceWorker(
+    const WebKit::WebURL& origin,
+    const string16& pattern,
+    const GURL& scriptUrl,
+    WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks) {
+  DCHECK(callbacks);
+  int request_id = pending_callbacks_.Add(callbacks);
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_RegisterServiceWorker(
+      CurrentWorkerId(), request_id, origin, pattern, scriptUrl));
+}
+
+void ServiceWorkerDispatcher::UnregisterServiceWorker(
+    const WebKit::WebURL& origin,
+    const string16& pattern,
+    WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks) {
+  DCHECK(callbacks);
+  int request_id = pending_callbacks_.Add(callbacks);
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_UnregisterServiceWorker(
+      CurrentWorkerId(), request_id, origin, pattern));
+}
+
+ServiceWorkerDispatcher* ServiceWorkerDispatcher::ThreadSpecificInstance(
+    ThreadSafeSender* thread_safe_sender) {
+  if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
+    NOTREACHED() << "Re-instantiating TLS ServiceWorkerDispatcher.";
+    g_dispatcher_tls.Pointer()->Set(NULL);
+  }
+  if (g_dispatcher_tls.Pointer()->Get())
+    return g_dispatcher_tls.Pointer()->Get();
+
+  ServiceWorkerDispatcher* dispatcher =
+      new ServiceWorkerDispatcher(thread_safe_sender);
+  if (WorkerTaskRunner::Instance()->CurrentWorkerId())
+    webkit_glue::WorkerTaskRunner::Instance()->AddStopObserver(dispatcher);
+  return dispatcher;
+}
+
+void ServiceWorkerDispatcher::OnServiceWorkerRegistered(
+    int32 thread_id,
+    int32 request_id,
+    int32 service_worker_id) {
+  WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
+      pending_callbacks_.Lookup(request_id);
+  DCHECK(callbacks);
+  if (!callbacks)
+    return;
+
+  // the browser has to generate the service_worker_id so the same
+  // worker can be called from different renderer contexts. However,
+  // the proxy object doesn't have to be consistent unless we require
+  // the DOM objects to be identical when there's a duplicate
+  // registration. So for now we mint a new object each time.
+  WebServiceWorkerImpl* worker =
+      new WebServiceWorkerImpl(service_worker_id, true);

[kinuko, 2013/10/08 02:30:19]

Well... I guessed you could have just named this WebServiceWorkerProxy (and
revert the impl/proxy file name changes)?   It looks this interface is going to
be used for communication between the actual Service Worker and if so the term
proxy sounds good to me.  (And WebFooProxy implementing WebFoo pattern sounds ok
to me too)  Wdyt- michaeln@ / alec@?

[alecflett, 2013/10/08 22:17:59]

Well, it's more of an 'impl' - it's not proxying anything, just implementing a
WebKit API interface. It does send its messages across IPC but not with the
intention of hitting another WebServiceWorker on the other side.

+  callbacks->onSuccess(worker);

[kinuko, 2013/10/08 02:30:19]

Should we do pending_callbacks_.Remove(request_id) to free up the callbacks
here?

[alecflett, 2013/10/08 22:17:59]

oops! fixed.

+}
+
+void ServiceWorkerDispatcher::OnServiceWorkerUnregistered(
+    int32 thread_id,
+    int32 request_id,
+    int32 service_worker_id) {
+  WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
+      pending_callbacks_.Lookup(request_id);
+  DCHECK(callbacks);
+  if (!callbacks)
+    return;
+
+  // see notes in ServiceWorkerRegistered
+  WebServiceWorkerImpl* worker =
+      new WebServiceWorkerImpl(service_worker_id, false);
+  callbacks->onSuccess(worker);
+}
+
+void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() { delete this; }
+
+}  // namespace content