src/content/child/service_worker/service_worker_dispatcher.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/child/service_worker/service_worker_dispatcher.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/threading/thread_local.h"
   9 #include "content/child/service_worker/web_service_worker_impl.h"
  10 #include "content/child/thread_safe_sender.h"
  11 #include "content/common/service_worker_messages.h"
  12 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
  13
  14 using WebKit::WebServiceWorkerProvider;
  15 using base::ThreadLocalPointer;
  16 using webkit_glue::WorkerTaskRunner;
  17
  18 namespace content {
  19
  20 namespace {
  21
  22 base::LazyInstance<ThreadLocalPointer<ServiceWorkerDispatcher> >::Leaky
  23     g_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
  24
  25 ServiceWorkerDispatcher* const kHasBeenDeleted =
  26     reinterpret_cast<ServiceWorkerDispatcher*>(0x1);
  27
  28 int CurrentWorkerId() {
  29   return WorkerTaskRunner::Instance()->CurrentWorkerId();
  30 }
  31
  32 }  // namespace
  33
  34 ServiceWorkerDispatcher::ServiceWorkerDispatcher(
  35     ThreadSafeSender* thread_safe_sender)
  36     : thread_safe_sender_(thread_safe_sender) {
  37   g_dispatcher_tls.Pointer()->Set(this);
  38 }
  39
  40 ServiceWorkerDispatcher::~ServiceWorkerDispatcher() {
  41   g_dispatcher_tls.Pointer()->Set(kHasBeenDeleted);
  42 }
  43
  44 void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) {
  45   bool handled = true;
  46   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
  47     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered,
  48                         OnServiceWorkerRegistered)
  49     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered,
  50                         OnServiceWorkerUnregistered)
  51     IPC_MESSAGE_UNHANDLED(handled = false)
  52   IPC_END_MESSAGE_MAP()
  53   DCHECK(handled) << "Unhandled message:" << msg.type();
  54 }
  55
  56 bool ServiceWorkerDispatcher::Send(IPC::Message* msg) {
  57   return thread_safe_sender_->Send(msg);
  58 }
  59
  60 void ServiceWorkerDispatcher::RegisterServiceWorker(
  61     const GURL& pattern,
  62     const GURL& script_url,
  63     WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks) {
  64   DCHECK(callbacks);
  65   int request_id = pending_callbacks_.Add(callbacks);
  66   thread_safe_sender_->Send(new ServiceWorkerHostMsg_RegisterServiceWorker(
  67       CurrentWorkerId(), request_id, pattern, script_url));
  68 }
  69
  70 void ServiceWorkerDispatcher::UnregisterServiceWorker(
  71     const GURL& pattern,
  72     WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks) {
  73   DCHECK(callbacks);
  74   int request_id = pending_callbacks_.Add(callbacks);
  75   thread_safe_sender_->Send(new ServiceWorkerHostMsg_UnregisterServiceWorker(
  76       CurrentWorkerId(), request_id, pattern));
  77 }
  78
  79 ServiceWorkerDispatcher* ServiceWorkerDispatcher::ThreadSpecificInstance(
  80     ThreadSafeSender* thread_safe_sender) {
  81   if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) {
  82     NOTREACHED() << "Re-instantiating TLS ServiceWorkerDispatcher.";
  83     g_dispatcher_tls.Pointer()->Set(NULL);
  84   }
  85   if (g_dispatcher_tls.Pointer()->Get())
  86     return g_dispatcher_tls.Pointer()->Get();
  87
  88   ServiceWorkerDispatcher* dispatcher =
  89       new ServiceWorkerDispatcher(thread_safe_sender);
  90   if (WorkerTaskRunner::Instance()->CurrentWorkerId())
  91     webkit_glue::WorkerTaskRunner::Instance()->AddStopObserver(dispatcher);
  92   return dispatcher;
  93 }
  94
  95 void ServiceWorkerDispatcher::OnServiceWorkerRegistered(
  96     int32 thread_id,
  97     int32 request_id,
  98     int64 service_worker_id) {
  99   WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
 100       pending_callbacks_.Lookup(request_id);
 101   DCHECK(callbacks);
 102   if (!callbacks)
 103     return;
 104
 105   // the browser has to generate the service_worker_id so the same
 106   // worker can be called from different renderer contexts. However,
 107   // the impl object doesn't have to be the same instance across calls
 108   // unless we require the DOM objects to be identical when there's a
 109   // duplicate registration. So for now we mint a new object each
 110   // time.
 111   scoped_ptr<WebServiceWorkerImpl> worker(
 112       new WebServiceWorkerImpl(service_worker_id));
 113   callbacks->onSuccess(worker.release());
 114   pending_callbacks_.Remove(request_id);
 115 }
 116
 117 void ServiceWorkerDispatcher::OnServiceWorkerUnregistered(int32 thread_id,
 118                                                           int32 request_id) {
 119   WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks =
 120       pending_callbacks_.Lookup(request_id);
 121   DCHECK(callbacks);
 122   if (!callbacks)
 123     return;
 124
 125   callbacks->onSuccess(NULL);
 126   pending_callbacks_.Remove(request_id);
 127 }
 128
 129 void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() { delete this; }
 130
 131 }  // namespace content