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

[kinuko, 2013/10/09 12:13:25]

nit: maybe 'proxy object' -> 'service worker object' if it's not a proxy?

[alecflett, 2013/10/09 18:54:29]

Done. (and clarified the language too)

+  // 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);
+  callbacks->onSuccess(worker);
+  pending_callbacks_.Remove(request_id);
+}
+
+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);
+  pending_callbacks_.Remove(request_id);
+}
+
+void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() { delete this; }
+
+}  // namespace content