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/renderer/service_worker/embedded_worker_context_client.h"
6
7 #include "base/lazy_instance.h"
8 #include "base/message_loop/message_loop_proxy.h"
9 #include "base/pickle.h"
10 #include "base/strings/string16.h"
11 #include "base/strings/utf_string_conversions.h"
12 #include "base/threading/thread_local.h"
13 #include "content/child/request_extra_data.h"
14 #include "content/child/service_worker/service_worker_network_provider.h"
15 #include "content/child/thread_safe_sender.h"
16 #include "content/child/worker_task_runner.h"
17 #include "content/child/worker_thread_task_runner.h"
18 #include "content/common/devtools_messages.h"
19 #include "content/common/service_worker/embedded_worker_messages.h"
20 #include "content/common/service_worker/service_worker_types.h"
21 #include "content/public/renderer/document_state.h"
22 #include "content/renderer/render_thread_impl.h"
23 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
24 #include "content/renderer/service_worker/service_worker_script_context.h"
25 #include "ipc/ipc_message_macros.h"
26 #include "third_party/WebKit/public/platform/WebServiceWorkerResponse.h"
27 #include "third_party/WebKit/public/platform/WebString.h"
28 #include "third_party/WebKit/public/web/WebDataSource.h"
29 #include "third_party/WebKit/public/web/WebServiceWorkerNetworkProvider.h"
30
31 namespace content {
32
33 namespace {
34
35 // For now client must be a per-thread instance.
36 // TODO(kinuko): This needs to be refactored when we start using thread pool
37 // or having multiple clients per one thread.
38 base::LazyInstance<base::ThreadLocalPointer<EmbeddedWorkerContextClient> >::
39 Leaky g_worker_client_tls = LAZY_INSTANCE_INITIALIZER;
40
CallWorkerContextDestroyedOnMainThread(int embedded_worker_id)41 void CallWorkerContextDestroyedOnMainThread(int embedded_worker_id) {
42 if (!RenderThreadImpl::current() ||
43 !RenderThreadImpl::current()->embedded_worker_dispatcher())
44 return;
45 RenderThreadImpl::current()->embedded_worker_dispatcher()->
46 WorkerContextDestroyed(embedded_worker_id);
47 }
48
49 // We store an instance of this class in the "extra data" of the WebDataSource
50 // and attach a ServiceWorkerNetworkProvider to it as base::UserData.
51 // (see createServiceWorkerNetworkProvider).
52 class DataSourceExtraData
53 : public blink::WebDataSource::ExtraData,
54 public base::SupportsUserData {
55 public:
DataSourceExtraData()56 DataSourceExtraData() {}
~DataSourceExtraData()57 virtual ~DataSourceExtraData() {}
58 };
59
60 // Called on the main thread only and blink owns it.
61 class WebServiceWorkerNetworkProviderImpl
62 : public blink::WebServiceWorkerNetworkProvider {
63 public:
64 // Blink calls this method for each request starting with the main script,
65 // we tag them with the provider id.
willSendRequest(blink::WebDataSource * data_source,blink::WebURLRequest & request)66 virtual void willSendRequest(
67 blink::WebDataSource* data_source,
68 blink::WebURLRequest& request) {
69 ServiceWorkerNetworkProvider* provider =
70 ServiceWorkerNetworkProvider::FromDocumentState(
71 static_cast<DataSourceExtraData*>(data_source->extraData()));
72 scoped_ptr<RequestExtraData> extra_data(new RequestExtraData);
73 extra_data->set_service_worker_provider_id(provider->provider_id());
74 request.setExtraData(extra_data.release());
75 }
76 };
77
78 } // namespace
79
80 EmbeddedWorkerContextClient*
ThreadSpecificInstance()81 EmbeddedWorkerContextClient::ThreadSpecificInstance() {
82 return g_worker_client_tls.Pointer()->Get();
83 }
84
EmbeddedWorkerContextClient(int embedded_worker_id,int64 service_worker_version_id,const GURL & service_worker_scope,const GURL & script_url,int worker_devtools_agent_route_id)85 EmbeddedWorkerContextClient::EmbeddedWorkerContextClient(
86 int embedded_worker_id,
87 int64 service_worker_version_id,
88 const GURL& service_worker_scope,
89 const GURL& script_url,
90 int worker_devtools_agent_route_id)
91 : embedded_worker_id_(embedded_worker_id),
92 service_worker_version_id_(service_worker_version_id),
93 service_worker_scope_(service_worker_scope),
94 script_url_(script_url),
95 worker_devtools_agent_route_id_(worker_devtools_agent_route_id),
96 sender_(ChildThread::current()->thread_safe_sender()),
97 main_thread_proxy_(base::MessageLoopProxy::current()),
98 weak_factory_(this) {
99 }
100
~EmbeddedWorkerContextClient()101 EmbeddedWorkerContextClient::~EmbeddedWorkerContextClient() {
102 }
103
OnMessageReceived(const IPC::Message & msg)104 bool EmbeddedWorkerContextClient::OnMessageReceived(
105 const IPC::Message& msg) {
106 bool handled = true;
107 IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerContextClient, msg)
108 IPC_MESSAGE_HANDLER(EmbeddedWorkerContextMsg_MessageToWorker,
109 OnMessageToWorker)
110 IPC_MESSAGE_UNHANDLED(handled = false)
111 IPC_END_MESSAGE_MAP()
112 return handled;
113 }
114
Send(IPC::Message * message)115 void EmbeddedWorkerContextClient::Send(IPC::Message* message) {
116 sender_->Send(message);
117 }
118
scope() const119 blink::WebURL EmbeddedWorkerContextClient::scope() const {
120 return service_worker_scope_;
121 }
122
getClients(blink::WebServiceWorkerClientsCallbacks * callbacks)123 void EmbeddedWorkerContextClient::getClients(
124 blink::WebServiceWorkerClientsCallbacks* callbacks) {
125 DCHECK(script_context_);
126 script_context_->GetClientDocuments(callbacks);
127 }
128
workerContextFailedToStart()129 void EmbeddedWorkerContextClient::workerContextFailedToStart() {
130 DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
131 DCHECK(!script_context_);
132
133 Send(new EmbeddedWorkerHostMsg_WorkerScriptLoadFailed(embedded_worker_id_));
134
135 RenderThreadImpl::current()->embedded_worker_dispatcher()->
136 WorkerContextDestroyed(embedded_worker_id_);
137 }
138
workerContextStarted(blink::WebServiceWorkerContextProxy * proxy)139 void EmbeddedWorkerContextClient::workerContextStarted(
140 blink::WebServiceWorkerContextProxy* proxy) {
141 DCHECK(!worker_task_runner_);
142 worker_task_runner_ = new WorkerThreadTaskRunner(
143 WorkerTaskRunner::Instance()->CurrentWorkerId());
144 DCHECK_NE(0, WorkerTaskRunner::Instance()->CurrentWorkerId());
145 // g_worker_client_tls.Pointer()->Get() could return NULL if this context
146 // gets deleted before workerContextStarted() is called.
147 DCHECK(g_worker_client_tls.Pointer()->Get() == NULL);
148 DCHECK(!script_context_);
149 g_worker_client_tls.Pointer()->Set(this);
150 script_context_.reset(new ServiceWorkerScriptContext(this, proxy));
151
152 Send(new EmbeddedWorkerHostMsg_WorkerScriptLoaded(embedded_worker_id_));
153
154 // Schedule a task to send back WorkerStarted asynchronously,
155 // so that at the time we send it we can be sure that the worker
156 // script has been evaluated and worker run loop has been started.
157 worker_task_runner_->PostTask(
158 FROM_HERE,
159 base::Bind(&EmbeddedWorkerContextClient::SendWorkerStarted,
160 weak_factory_.GetWeakPtr()));
161 }
162
willDestroyWorkerContext()163 void EmbeddedWorkerContextClient::willDestroyWorkerContext() {
164 // At this point OnWorkerRunLoopStopped is already called, so
165 // worker_task_runner_->RunsTasksOnCurrentThread() returns false
166 // (while we're still on the worker thread).
167 script_context_.reset();
168
169 // This also lets the message filter stop dispatching messages to
170 // this client.
171 g_worker_client_tls.Pointer()->Set(NULL);
172 }
173
workerContextDestroyed()174 void EmbeddedWorkerContextClient::workerContextDestroyed() {
175 DCHECK(g_worker_client_tls.Pointer()->Get() == NULL);
176
177 // Now we should be able to free the WebEmbeddedWorker container on the
178 // main thread.
179 main_thread_proxy_->PostTask(
180 FROM_HERE,
181 base::Bind(&CallWorkerContextDestroyedOnMainThread,
182 embedded_worker_id_));
183 }
184
reportException(const blink::WebString & error_message,int line_number,int column_number,const blink::WebString & source_url)185 void EmbeddedWorkerContextClient::reportException(
186 const blink::WebString& error_message,
187 int line_number,
188 int column_number,
189 const blink::WebString& source_url) {
190 Send(new EmbeddedWorkerHostMsg_ReportException(
191 embedded_worker_id_, error_message, line_number,
192 column_number, GURL(source_url)));
193 }
194
reportConsoleMessage(int source,int level,const blink::WebString & message,int line_number,const blink::WebString & source_url)195 void EmbeddedWorkerContextClient::reportConsoleMessage(
196 int source,
197 int level,
198 const blink::WebString& message,
199 int line_number,
200 const blink::WebString& source_url) {
201 EmbeddedWorkerHostMsg_ReportConsoleMessage_Params params;
202 params.source_identifier = source;
203 params.message_level = level;
204 params.message = message;
205 params.line_number = line_number;
206 params.source_url = GURL(source_url);
207
208 Send(new EmbeddedWorkerHostMsg_ReportConsoleMessage(
209 embedded_worker_id_, params));
210 }
211
dispatchDevToolsMessage(const blink::WebString & message)212 void EmbeddedWorkerContextClient::dispatchDevToolsMessage(
213 const blink::WebString& message) {
214 sender_->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
215 worker_devtools_agent_route_id_, message.utf8()));
216 }
217
saveDevToolsAgentState(const blink::WebString & state)218 void EmbeddedWorkerContextClient::saveDevToolsAgentState(
219 const blink::WebString& state) {
220 sender_->Send(new DevToolsHostMsg_SaveAgentRuntimeState(
221 worker_devtools_agent_route_id_, state.utf8()));
222 }
223
didHandleActivateEvent(int request_id,blink::WebServiceWorkerEventResult result)224 void EmbeddedWorkerContextClient::didHandleActivateEvent(
225 int request_id,
226 blink::WebServiceWorkerEventResult result) {
227 DCHECK(script_context_);
228 script_context_->DidHandleActivateEvent(request_id, result);
229 }
230
didHandleInstallEvent(int request_id,blink::WebServiceWorkerEventResult result)231 void EmbeddedWorkerContextClient::didHandleInstallEvent(
232 int request_id,
233 blink::WebServiceWorkerEventResult result) {
234 DCHECK(script_context_);
235 script_context_->DidHandleInstallEvent(request_id, result);
236 }
237
didHandleFetchEvent(int request_id)238 void EmbeddedWorkerContextClient::didHandleFetchEvent(int request_id) {
239 DCHECK(script_context_);
240 script_context_->DidHandleFetchEvent(
241 request_id,
242 SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
243 ServiceWorkerResponse());
244 }
245
didHandleFetchEvent(int request_id,const blink::WebServiceWorkerResponse & web_response)246 void EmbeddedWorkerContextClient::didHandleFetchEvent(
247 int request_id,
248 const blink::WebServiceWorkerResponse& web_response) {
249 DCHECK(script_context_);
250 std::map<std::string, std::string> headers;
251 const blink::WebVector<blink::WebString>& header_keys =
252 web_response.getHeaderKeys();
253 for (size_t i = 0; i < header_keys.size(); ++i) {
254 const base::string16& key = header_keys[i];
255 headers[base::UTF16ToUTF8(key)] =
256 base::UTF16ToUTF8(web_response.getHeader(key));
257 }
258 ServiceWorkerResponse response(web_response.status(),
259 web_response.statusText().utf8(),
260 headers,
261 web_response.blobUUID().utf8());
262 script_context_->DidHandleFetchEvent(
263 request_id, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, response);
264 }
265
didHandleSyncEvent(int request_id)266 void EmbeddedWorkerContextClient::didHandleSyncEvent(int request_id) {
267 DCHECK(script_context_);
268 script_context_->DidHandleSyncEvent(request_id);
269 }
270
271 blink::WebServiceWorkerNetworkProvider*
createServiceWorkerNetworkProvider(blink::WebDataSource * data_source)272 EmbeddedWorkerContextClient::createServiceWorkerNetworkProvider(
273 blink::WebDataSource* data_source) {
274 // Create a content::ServiceWorkerNetworkProvider for this data source so
275 // we can observe its requests.
276 scoped_ptr<ServiceWorkerNetworkProvider> provider(
277 new ServiceWorkerNetworkProvider());
278
279 // Tell the network provider about which version to load.
280 provider->SetServiceWorkerVersionId(service_worker_version_id_);
281
282 // The provider is kept around for the lifetime of the DataSource
283 // and ownership is transferred to the DataSource.
284 DataSourceExtraData* extra_data = new DataSourceExtraData();
285 data_source->setExtraData(extra_data);
286 ServiceWorkerNetworkProvider::AttachToDocumentState(
287 extra_data, provider.Pass());
288
289 // Blink is responsible for deleting the returned object.
290 return new WebServiceWorkerNetworkProviderImpl();
291 }
292
postMessageToClient(int client_id,const blink::WebString & message,blink::WebMessagePortChannelArray * channels)293 void EmbeddedWorkerContextClient::postMessageToClient(
294 int client_id,
295 const blink::WebString& message,
296 blink::WebMessagePortChannelArray* channels) {
297 DCHECK(script_context_);
298 script_context_->PostMessageToDocument(client_id, message,
299 make_scoped_ptr(channels));
300 }
301
OnMessageToWorker(int thread_id,int embedded_worker_id,const IPC::Message & message)302 void EmbeddedWorkerContextClient::OnMessageToWorker(
303 int thread_id,
304 int embedded_worker_id,
305 const IPC::Message& message) {
306 if (!script_context_)
307 return;
308 DCHECK_EQ(embedded_worker_id_, embedded_worker_id);
309 script_context_->OnMessageReceived(message);
310 }
311
SendWorkerStarted()312 void EmbeddedWorkerContextClient::SendWorkerStarted() {
313 DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
314 Send(new EmbeddedWorkerHostMsg_WorkerStarted(
315 WorkerTaskRunner::Instance()->CurrentWorkerId(),
316 embedded_worker_id_));
317 }
318
319 } // namespace content
320