OLD | NEW |
---|---|
(Empty) | |
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 static base::LazyInstance<ThreadLocalPointer<ServiceWorkerDispatcher> >::Leaky | |
21 g_dispatcher_tls = LAZY_INSTANCE_INITIALIZER; | |
22 | |
23 ServiceWorkerDispatcher* const kHasBeenDeleted = | |
24 reinterpret_cast<ServiceWorkerDispatcher*>(0x1); | |
25 | |
26 ServiceWorkerDispatcher::ServiceWorkerDispatcher( | |
27 ThreadSafeSender* thread_safe_sender) | |
28 : thread_safe_sender_(thread_safe_sender) { | |
29 g_dispatcher_tls.Pointer()->Set(this); | |
30 } | |
31 | |
32 ServiceWorkerDispatcher::~ServiceWorkerDispatcher() { | |
33 g_dispatcher_tls.Pointer()->Set(kHasBeenDeleted); | |
34 } | |
35 | |
36 void ServiceWorkerDispatcher::OnMessageReceived(const IPC::Message& msg) { | |
37 bool handled = true; | |
38 IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg) | |
39 IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered, | |
40 OnServiceWorkerRegistered) | |
41 IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered, | |
42 OnServiceWorkerUnregistered) | |
43 IPC_MESSAGE_UNHANDLED(handled = false) | |
44 IPC_END_MESSAGE_MAP() | |
45 DCHECK(handled) << "Unhandled message:" << msg.type(); | |
46 } | |
47 | |
48 bool ServiceWorkerDispatcher::Send(IPC::Message* msg) { | |
49 return thread_safe_sender_->Send(msg); | |
50 } | |
51 | |
52 static int CurrentWorkerId() { | |
53 return WorkerTaskRunner::Instance()->CurrentWorkerId(); | |
54 } | |
55 | |
56 void ServiceWorkerDispatcher::RegisterServiceWorker( | |
57 const WebKit::WebURL& origin, | |
58 const string16& pattern, | |
59 const GURL& scriptUrl, | |
60 WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks) { | |
61 DCHECK(callbacks); | |
62 int request_id = pending_callbacks_.Add(callbacks); | |
63 thread_safe_sender_->Send(new ServiceWorkerHostMsg_RegisterServiceWorker( | |
64 CurrentWorkerId(), request_id, origin, pattern, scriptUrl)); | |
65 } | |
66 | |
67 void ServiceWorkerDispatcher::UnregisterServiceWorker( | |
68 const WebKit::WebURL& origin, | |
69 const string16& pattern, | |
70 WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks) { | |
71 DCHECK(callbacks); | |
72 int request_id = pending_callbacks_.Add(callbacks); | |
73 thread_safe_sender_->Send(new ServiceWorkerHostMsg_UnregisterServiceWorker( | |
74 CurrentWorkerId(), request_id, origin, pattern)); | |
75 } | |
76 | |
77 ServiceWorkerDispatcher* ServiceWorkerDispatcher::ThreadSpecificInstance( | |
78 ThreadSafeSender* thread_safe_sender) { | |
79 if (g_dispatcher_tls.Pointer()->Get() == kHasBeenDeleted) { | |
80 NOTREACHED() << "Re-instantiating TLS ServiceWorkerDispatcher."; | |
81 g_dispatcher_tls.Pointer()->Set(NULL); | |
82 } | |
83 if (g_dispatcher_tls.Pointer()->Get()) | |
84 return g_dispatcher_tls.Pointer()->Get(); | |
85 | |
86 ServiceWorkerDispatcher* dispatcher = | |
87 new ServiceWorkerDispatcher(thread_safe_sender); | |
88 if (WorkerTaskRunner::Instance()->CurrentWorkerId()) | |
89 webkit_glue::WorkerTaskRunner::Instance()->AddStopObserver(dispatcher); | |
90 return dispatcher; | |
91 } | |
92 | |
93 void ServiceWorkerDispatcher::OnServiceWorkerRegistered( | |
94 int32 thread_id, | |
95 int32 request_id, | |
96 int32 service_worker_id) { | |
97 WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks = | |
98 pending_callbacks_.Lookup(request_id); | |
99 DCHECK(callbacks); | |
100 if (!callbacks) | |
101 return; | |
102 | |
103 // the browser has to generate the service_worker_id so the same | |
104 // worker can be called from different renderer contexts. However, | |
105 // the proxy object doesn't have to be consistent unless we require | |
106 // the DOM objects to be identical when there's a duplicate | |
107 // registration. So for now we mint a new object each time. | |
108 WebServiceWorkerImpl* worker = | |
109 new WebServiceWorkerImpl(service_worker_id, true); | |
kinuko
2013/10/08 02:30:19
Well... I guessed you could have just named this W
alecflett
2013/10/08 22:17:59
Well, it's more of an 'impl' - it's not proxying a
| |
110 callbacks->onSuccess(worker); | |
kinuko
2013/10/08 02:30:19
Should we do pending_callbacks_.Remove(request_id)
alecflett
2013/10/08 22:17:59
oops! fixed.
| |
111 } | |
112 | |
113 void ServiceWorkerDispatcher::OnServiceWorkerUnregistered( | |
114 int32 thread_id, | |
115 int32 request_id, | |
116 int32 service_worker_id) { | |
117 WebServiceWorkerProvider::WebServiceWorkerCallbacks* callbacks = | |
118 pending_callbacks_.Lookup(request_id); | |
119 DCHECK(callbacks); | |
120 if (!callbacks) | |
121 return; | |
122 | |
123 // see notes in ServiceWorkerRegistered | |
124 WebServiceWorkerImpl* worker = | |
125 new WebServiceWorkerImpl(service_worker_id, false); | |
126 callbacks->onSuccess(worker); | |
127 } | |
128 | |
129 void ServiceWorkerDispatcher::OnWorkerRunLoopStopped() { delete this; } | |
130 | |
131 } // namespace content | |
OLD | NEW |