1 // Copyright (c) 2012 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/browser/worker_host/worker_process_host.h"
6
7 #include <set>
8 #include <string>
9 #include <vector>
10
11 #include "base/base_switches.h"
12 #include "base/bind.h"
13 #include "base/bind_helpers.h"
14 #include "base/callback.h"
15 #include "base/command_line.h"
16 #include "base/message_loop/message_loop.h"
17 #include "base/strings/string_util.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "content/browser/appcache/appcache_dispatcher_host.h"
20 #include "content/browser/appcache/chrome_appcache_service.h"
21 #include "content/browser/browser_child_process_host_impl.h"
22 #include "content/browser/child_process_security_policy_impl.h"
23 #include "content/browser/devtools/worker_devtools_manager.h"
24 #include "content/browser/devtools/worker_devtools_message_filter.h"
25 #include "content/browser/fileapi/fileapi_message_filter.h"
26 #include "content/browser/frame_host/render_frame_host_delegate.h"
27 #include "content/browser/frame_host/render_frame_host_impl.h"
28 #include "content/browser/indexed_db/indexed_db_dispatcher_host.h"
29 #include "content/browser/loader/resource_message_filter.h"
30 #include "content/browser/message_port_message_filter.h"
31 #include "content/browser/message_port_service.h"
32 #include "content/browser/mime_registry_message_filter.h"
33 #include "content/browser/quota_dispatcher_host.h"
34 #include "content/browser/renderer_host/database_message_filter.h"
35 #include "content/browser/renderer_host/file_utilities_message_filter.h"
36 #include "content/browser/renderer_host/render_view_host_delegate.h"
37 #include "content/browser/renderer_host/render_view_host_impl.h"
38 #include "content/browser/renderer_host/socket_stream_dispatcher_host.h"
39 #include "content/browser/renderer_host/websocket_dispatcher_host.h"
40 #include "content/browser/resource_context_impl.h"
41 #include "content/browser/worker_host/worker_message_filter.h"
42 #include "content/browser/worker_host/worker_service_impl.h"
43 #include "content/common/child_process_host_impl.h"
44 #include "content/common/view_messages.h"
45 #include "content/common/worker_messages.h"
46 #include "content/public/browser/browser_thread.h"
47 #include "content/public/browser/content_browser_client.h"
48 #include "content/public/browser/user_metrics.h"
49 #include "content/public/common/content_switches.h"
50 #include "content/public/common/result_codes.h"
51 #include "content/public/common/sandboxed_process_launcher_delegate.h"
52 #include "ipc/ipc_switches.h"
53 #include "net/base/mime_util.h"
54 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
55 #include "net/url_request/url_request_context_getter.h"
56 #include "ui/base/ui_base_switches.h"
57 #include "webkit/browser/fileapi/file_system_context.h"
58 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
59 #include "webkit/common/resource_type.h"
60
61 #if defined(OS_WIN)
62 #include "content/common/sandbox_win.h"
63 #endif
64
65 namespace content {
66 namespace {
67
68 // NOTE: changes to this class need to be reviewed by the security team.
69 class WorkerSandboxedProcessLauncherDelegate
70 : public content::SandboxedProcessLauncherDelegate {
71 public:
WorkerSandboxedProcessLauncherDelegate(ChildProcessHost * host,bool debugging_child)72 WorkerSandboxedProcessLauncherDelegate(ChildProcessHost* host,
73 bool debugging_child)
74 #if defined(OS_POSIX)
75 : ipc_fd_(host->TakeClientFileDescriptor()),
76 debugging_child_(debugging_child)
77 #endif // OS_POSIX
78 {}
79
~WorkerSandboxedProcessLauncherDelegate()80 virtual ~WorkerSandboxedProcessLauncherDelegate() {}
81
82 #if defined(OS_WIN)
PreSpawnTarget(sandbox::TargetPolicy * policy,bool * success)83 virtual void PreSpawnTarget(sandbox::TargetPolicy* policy,
84 bool* success) {
85 AddBaseHandleClosePolicy(policy);
86 }
87 #elif defined(OS_POSIX)
ShouldUseZygote()88 virtual bool ShouldUseZygote() OVERRIDE {
89 return !debugging_child_;
90 }
GetIpcFd()91 virtual int GetIpcFd() OVERRIDE {
92 return ipc_fd_;
93 }
94 #endif // OS_WIN
95
96 private:
97 #if defined(OS_POSIX)
98 int ipc_fd_;
99 bool debugging_child_;
100 #endif // OS_POSIX
101 };
102
103 // Notifies RenderViewHost that one or more worker objects crashed.
WorkerCrashCallback(int render_process_unique_id,int render_frame_id)104 void WorkerCrashCallback(int render_process_unique_id, int render_frame_id) {
105 RenderFrameHostImpl* host =
106 RenderFrameHostImpl::FromID(render_process_unique_id, render_frame_id);
107 if (host)
108 host->delegate()->WorkerCrashed(host);
109 }
110
WorkerCreatedCallback(int render_process_id,int render_frame_id,int worker_process_id)111 void WorkerCreatedCallback(int render_process_id,
112 int render_frame_id,
113 int worker_process_id) {
114 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
115 RenderFrameHost* render_frame_host =
116 RenderFrameHost::FromID(render_process_id, render_frame_id);
117 if (!render_frame_host)
118 return;
119 SiteInstance* site_instance = render_frame_host->GetSiteInstance();
120 GetContentClient()->browser()->WorkerProcessCreated(site_instance,
121 worker_process_id);
122 }
123
WorkerTerminatedCallback(int render_process_id,int render_frame_id,int worker_process_id)124 void WorkerTerminatedCallback(int render_process_id,
125 int render_frame_id,
126 int worker_process_id) {
127 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
128 RenderFrameHost* render_frame_host =
129 RenderFrameHost::FromID(render_process_id, render_frame_id);
130 if (!render_frame_host)
131 return;
132 SiteInstance* site_instance = render_frame_host->GetSiteInstance();
133 GetContentClient()->browser()->WorkerProcessTerminated(site_instance,
134 worker_process_id);
135 }
136
137 } // namespace
138
WorkerProcessHost(ResourceContext * resource_context,const WorkerStoragePartition & partition)139 WorkerProcessHost::WorkerProcessHost(
140 ResourceContext* resource_context,
141 const WorkerStoragePartition& partition)
142 : resource_context_(resource_context),
143 partition_(partition),
144 process_launched_(false) {
145 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
146 DCHECK(resource_context_);
147 process_.reset(
148 new BrowserChildProcessHostImpl(PROCESS_TYPE_WORKER, this));
149 }
150
~WorkerProcessHost()151 WorkerProcessHost::~WorkerProcessHost() {
152 // If we crashed, tell the RenderViewHosts.
153 for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
154 if (!i->load_failed()) {
155 const WorkerDocumentSet::DocumentInfoSet& parents =
156 i->worker_document_set()->documents();
157 for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
158 parents.begin(); parent_iter != parents.end(); ++parent_iter) {
159 BrowserThread::PostTask(
160 BrowserThread::UI, FROM_HERE,
161 base::Bind(&WorkerCrashCallback, parent_iter->render_process_id(),
162 parent_iter->render_frame_id()));
163 }
164 }
165 WorkerServiceImpl::GetInstance()->NotifyWorkerDestroyed(
166 this, i->worker_route_id());
167 }
168
169 ChildProcessSecurityPolicyImpl::GetInstance()->Remove(
170 process_->GetData().id);
171 }
172
Send(IPC::Message * message)173 bool WorkerProcessHost::Send(IPC::Message* message) {
174 return process_->Send(message);
175 }
176
Init(int render_process_id,int render_frame_id)177 bool WorkerProcessHost::Init(int render_process_id, int render_frame_id) {
178 std::string channel_id = process_->GetHost()->CreateChannel();
179 if (channel_id.empty())
180 return false;
181
182 #if defined(OS_LINUX)
183 int flags = ChildProcessHost::CHILD_ALLOW_SELF;
184 #else
185 int flags = ChildProcessHost::CHILD_NORMAL;
186 #endif
187
188 base::FilePath exe_path = ChildProcessHost::GetChildPath(flags);
189 if (exe_path.empty())
190 return false;
191
192 CommandLine* cmd_line = new CommandLine(exe_path);
193 cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kWorkerProcess);
194 cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
195 std::string locale = GetContentClient()->browser()->GetApplicationLocale();
196 cmd_line->AppendSwitchASCII(switches::kLang, locale);
197
198 static const char* const kSwitchNames[] = {
199 switches::kDisableApplicationCache,
200 switches::kDisableDatabases,
201 #if defined(OS_WIN)
202 switches::kDisableDesktopNotifications,
203 #endif
204 switches::kDisableFileSystem,
205 switches::kDisableSeccompFilterSandbox,
206 switches::kEnableExperimentalWebPlatformFeatures,
207 switches::kEnablePreciseMemoryInfo,
208 switches::kEnableServiceWorker,
209 #if defined(OS_MACOSX)
210 switches::kEnableSandboxLogging,
211 #endif
212 switches::kJavaScriptFlags,
213 switches::kNoSandbox
214 };
215 cmd_line->CopySwitchesFrom(*CommandLine::ForCurrentProcess(), kSwitchNames,
216 arraysize(kSwitchNames));
217
218 bool debugging_child = false;
219 #if defined(OS_POSIX)
220 if (CommandLine::ForCurrentProcess()->HasSwitch(
221 switches::kWaitForDebuggerChildren)) {
222 // Look to pass-on the kWaitForDebugger flag.
223 std::string value = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
224 switches::kWaitForDebuggerChildren);
225 if (value.empty() || value == switches::kWorkerProcess) {
226 cmd_line->AppendSwitch(switches::kWaitForDebugger);
227 debugging_child = true;
228 }
229 }
230 #endif
231
232 process_->Launch(
233 new WorkerSandboxedProcessLauncherDelegate(process_->GetHost(),
234 debugging_child),
235 cmd_line);
236
237 ChildProcessSecurityPolicyImpl::GetInstance()->AddWorker(
238 process_->GetData().id, render_process_id);
239 CreateMessageFilters(render_process_id);
240
241 BrowserThread::PostTask(
242 BrowserThread::UI, FROM_HERE,
243 base::Bind(&WorkerCreatedCallback,
244 render_process_id,
245 render_frame_id,
246 process_->GetData().id));
247 return true;
248 }
249
CreateMessageFilters(int render_process_id)250 void WorkerProcessHost::CreateMessageFilters(int render_process_id) {
251 ChromeBlobStorageContext* blob_storage_context =
252 GetChromeBlobStorageContextForResourceContext(resource_context_);
253 StreamContext* stream_context =
254 GetStreamContextForResourceContext(resource_context_);
255
256 net::URLRequestContextGetter* url_request_context =
257 partition_.url_request_context();
258
259 ResourceMessageFilter::GetContextsCallback get_contexts_callback(
260 base::Bind(&WorkerProcessHost::GetContexts,
261 base::Unretained(this)));
262
263 ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
264 process_->GetData().id, PROCESS_TYPE_WORKER,
265 partition_.appcache_service(),
266 blob_storage_context,
267 partition_.filesystem_context(),
268 partition_.service_worker_context(),
269 get_contexts_callback);
270 process_->AddFilter(resource_message_filter);
271
272 MessagePortMessageFilter* message_port_message_filter =
273 new MessagePortMessageFilter(
274 base::Bind(&WorkerServiceImpl::next_worker_route_id,
275 base::Unretained(WorkerServiceImpl::GetInstance())));
276 process_->AddFilter(message_port_message_filter);
277 worker_message_filter_ = new WorkerMessageFilter(render_process_id,
278 resource_context_,
279 partition_,
280 message_port_message_filter);
281 process_->AddFilter(worker_message_filter_.get());
282 process_->AddFilter(new AppCacheDispatcherHost(
283 partition_.appcache_service(), process_->GetData().id));
284 process_->AddFilter(new FileAPIMessageFilter(
285 process_->GetData().id,
286 url_request_context,
287 partition_.filesystem_context(),
288 blob_storage_context,
289 stream_context));
290 process_->AddFilter(new FileUtilitiesMessageFilter(
291 process_->GetData().id));
292 process_->AddFilter(new MimeRegistryMessageFilter());
293 process_->AddFilter(new DatabaseMessageFilter(partition_.database_tracker()));
294 process_->AddFilter(new QuotaDispatcherHost(
295 process_->GetData().id,
296 partition_.quota_manager(),
297 GetContentClient()->browser()->CreateQuotaPermissionContext()));
298
299 SocketStreamDispatcherHost::GetRequestContextCallback
300 request_context_callback(
301 base::Bind(&WorkerProcessHost::GetRequestContext,
302 base::Unretained(this)));
303
304 SocketStreamDispatcherHost* socket_stream_dispatcher_host =
305 new SocketStreamDispatcherHost(
306 render_process_id,
307 request_context_callback,
308 resource_context_);
309 socket_stream_dispatcher_host_ = socket_stream_dispatcher_host;
310 process_->AddFilter(socket_stream_dispatcher_host);
311
312 WebSocketDispatcherHost::GetRequestContextCallback
313 websocket_request_context_callback(
314 base::Bind(&WorkerProcessHost::GetRequestContext,
315 base::Unretained(this),
316 ResourceType::SUB_RESOURCE));
317
318 process_->AddFilter(new WebSocketDispatcherHost(
319 render_process_id, websocket_request_context_callback));
320
321 process_->AddFilter(new WorkerDevToolsMessageFilter(process_->GetData().id));
322 process_->AddFilter(
323 new IndexedDBDispatcherHost(process_->GetData().id,
324 url_request_context,
325 partition_.indexed_db_context(),
326 blob_storage_context));
327 }
328
CreateWorker(const WorkerInstance & instance,bool pause_on_start)329 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance,
330 bool pause_on_start) {
331 ChildProcessSecurityPolicyImpl::GetInstance()->GrantRequestURL(
332 process_->GetData().id, instance.url());
333
334 instances_.push_back(instance);
335
336 WorkerProcessMsg_CreateWorker_Params params;
337 params.url = instance.url();
338 params.name = instance.name();
339 params.content_security_policy = instance.content_security_policy();
340 params.security_policy_type = instance.security_policy_type();
341 params.pause_on_start = pause_on_start;
342 params.route_id = instance.worker_route_id();
343 Send(new WorkerProcessMsg_CreateWorker(params));
344
345 UpdateTitle();
346
347 // Walk all pending filters and let them know the worker has been created
348 // (could be more than one in the case where we had to queue up worker
349 // creation because the worker process limit was reached).
350 for (WorkerInstance::FilterList::const_iterator i =
351 instance.filters().begin();
352 i != instance.filters().end(); ++i) {
353 i->filter()->Send(new ViewMsg_WorkerCreated(i->route_id()));
354 }
355 }
356
FilterMessage(const IPC::Message & message,WorkerMessageFilter * filter)357 bool WorkerProcessHost::FilterMessage(const IPC::Message& message,
358 WorkerMessageFilter* filter) {
359 for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
360 if (!i->closed() && i->HasFilter(filter, message.routing_id())) {
361 RelayMessage(message, filter, &(*i));
362 return true;
363 }
364 }
365
366 return false;
367 }
368
OnProcessLaunched()369 void WorkerProcessHost::OnProcessLaunched() {
370 process_launched_ = true;
371
372 WorkerServiceImpl::GetInstance()->NotifyWorkerProcessCreated();
373 }
374
OnMessageReceived(const IPC::Message & message)375 bool WorkerProcessHost::OnMessageReceived(const IPC::Message& message) {
376 bool handled = true;
377 IPC_BEGIN_MESSAGE_MAP(WorkerProcessHost, message)
378 IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextClosed,
379 OnWorkerContextClosed)
380 IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerContextDestroyed,
381 OnWorkerContextDestroyed)
382 IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerScriptLoaded,
383 OnWorkerScriptLoaded)
384 IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerScriptLoadFailed,
385 OnWorkerScriptLoadFailed)
386 IPC_MESSAGE_HANDLER(WorkerHostMsg_WorkerConnected,
387 OnWorkerConnected)
388 IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowDatabase, OnAllowDatabase)
389 IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_RequestFileSystemAccessSync,
390 OnRequestFileSystemAccessSync)
391 IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_AllowIndexedDB, OnAllowIndexedDB)
392 IPC_MESSAGE_HANDLER(WorkerProcessHostMsg_ForceKillWorker,
393 OnForceKillWorkerProcess)
394 IPC_MESSAGE_UNHANDLED(handled = false)
395 IPC_END_MESSAGE_MAP()
396
397 return handled;
398 }
399
400 // Sent to notify the browser process when a worker context invokes close(), so
401 // no new connections are sent to shared workers.
OnWorkerContextClosed(int worker_route_id)402 void WorkerProcessHost::OnWorkerContextClosed(int worker_route_id) {
403 for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
404 if (i->worker_route_id() == worker_route_id) {
405 // Set the closed flag - this will stop any further messages from
406 // being sent to the worker (messages can still be sent from the worker,
407 // for exception reporting, etc).
408 i->set_closed(true);
409 break;
410 }
411 }
412 }
413
OnWorkerContextDestroyed(int worker_route_id)414 void WorkerProcessHost::OnWorkerContextDestroyed(int worker_route_id) {
415 WorkerServiceImpl::GetInstance()->NotifyWorkerDestroyed(
416 this, worker_route_id);
417 for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
418 if (i->worker_route_id() == worker_route_id) {
419 instances_.erase(i);
420 UpdateTitle();
421 return;
422 }
423 }
424 }
425
OnWorkerScriptLoaded(int worker_route_id)426 void WorkerProcessHost::OnWorkerScriptLoaded(int worker_route_id) {
427 WorkerDevToolsManager::GetInstance()->WorkerContextStarted(this,
428 worker_route_id);
429 }
430
OnWorkerScriptLoadFailed(int worker_route_id)431 void WorkerProcessHost::OnWorkerScriptLoadFailed(int worker_route_id) {
432 bool shutdown = true;
433 for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
434 if (i->worker_route_id() != worker_route_id) {
435 shutdown = false;
436 continue;
437 }
438 i->set_load_failed(true);
439 for (WorkerInstance::FilterList::const_iterator j = i->filters().begin();
440 j != i->filters().end(); ++j) {
441 j->filter()->Send(new ViewMsg_WorkerScriptLoadFailed(j->route_id()));
442 }
443 }
444 if (shutdown) {
445 base::KillProcess(
446 process_->GetData().handle, RESULT_CODE_NORMAL_EXIT, false);
447 }
448 }
449
OnWorkerConnected(int message_port_id,int worker_route_id)450 void WorkerProcessHost::OnWorkerConnected(int message_port_id,
451 int worker_route_id) {
452 for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
453 if (i->worker_route_id() != worker_route_id)
454 continue;
455 for (WorkerInstance::FilterList::const_iterator j = i->filters().begin();
456 j != i->filters().end(); ++j) {
457 if (j->message_port_id() != message_port_id)
458 continue;
459 j->filter()->Send(new ViewMsg_WorkerConnected(j->route_id()));
460 return;
461 }
462 }
463 }
464
OnAllowDatabase(int worker_route_id,const GURL & url,const base::string16 & name,const base::string16 & display_name,unsigned long estimated_size,bool * result)465 void WorkerProcessHost::OnAllowDatabase(int worker_route_id,
466 const GURL& url,
467 const base::string16& name,
468 const base::string16& display_name,
469 unsigned long estimated_size,
470 bool* result) {
471 *result = GetContentClient()->browser()->AllowWorkerDatabase(
472 url, name, display_name, estimated_size, resource_context_,
473 GetRenderFrameIDsForWorker(worker_route_id));
474 }
475
OnRequestFileSystemAccessSync(int worker_route_id,const GURL & url,bool * result)476 void WorkerProcessHost::OnRequestFileSystemAccessSync(int worker_route_id,
477 const GURL& url,
478 bool* result) {
479 *result = GetContentClient()->browser()->AllowWorkerFileSystem(
480 url, resource_context_, GetRenderFrameIDsForWorker(worker_route_id));
481 }
482
OnAllowIndexedDB(int worker_route_id,const GURL & url,const base::string16 & name,bool * result)483 void WorkerProcessHost::OnAllowIndexedDB(int worker_route_id,
484 const GURL& url,
485 const base::string16& name,
486 bool* result) {
487 *result = GetContentClient()->browser()->AllowWorkerIndexedDB(
488 url, name, resource_context_,
489 GetRenderFrameIDsForWorker(worker_route_id));
490 }
491
OnForceKillWorkerProcess()492 void WorkerProcessHost::OnForceKillWorkerProcess() {
493 if (process_ && process_launched_)
494 base::KillProcess(
495 process_->GetData().handle, RESULT_CODE_NORMAL_EXIT, false);
496 else
497 RecordAction(base::UserMetricsAction("WorkerProcess_BadProcessToKill"));
498 }
499
RelayMessage(const IPC::Message & message,WorkerMessageFilter * incoming_filter,WorkerInstance * instance)500 void WorkerProcessHost::RelayMessage(
501 const IPC::Message& message,
502 WorkerMessageFilter* incoming_filter,
503 WorkerInstance* instance) {
504 if (message.type() == WorkerMsg_Connect::ID) {
505 // Crack the SharedWorker Connect message to setup routing for the port.
506 WorkerMsg_Connect::Param params;
507 if (!WorkerMsg_Connect::Read(&message, ¶ms))
508 return;
509
510 int sent_message_port_id = params.a;
511 int new_routing_id = params.b;
512 new_routing_id = worker_message_filter_->GetNextRoutingID();
513 MessagePortService::GetInstance()->UpdateMessagePort(
514 sent_message_port_id,
515 worker_message_filter_->message_port_message_filter(),
516 new_routing_id);
517
518 instance->SetMessagePortID(incoming_filter,
519 message.routing_id(),
520 sent_message_port_id);
521 // Resend the message with the new routing id.
522 worker_message_filter_->Send(new WorkerMsg_Connect(
523 instance->worker_route_id(), sent_message_port_id, new_routing_id));
524
525 // Send any queued messages for the sent port.
526 MessagePortService::GetInstance()->SendQueuedMessagesIfPossible(
527 sent_message_port_id);
528 } else {
529 IPC::Message* new_message = new IPC::Message(message);
530 new_message->set_routing_id(instance->worker_route_id());
531 worker_message_filter_->Send(new_message);
532 return;
533 }
534 }
535
ShutdownSocketStreamDispatcherHostIfNecessary()536 void WorkerProcessHost::ShutdownSocketStreamDispatcherHostIfNecessary() {
537 if (!instances_.size() && socket_stream_dispatcher_host_.get()) {
538 // We can assume that this object is going to delete, because
539 // currently a WorkerInstance will never be added to a WorkerProcessHost
540 // once it is initialized.
541
542 // SocketStreamDispatcherHost should be notified now that the worker
543 // process will shutdown soon.
544 socket_stream_dispatcher_host_->Shutdown();
545 socket_stream_dispatcher_host_ = NULL;
546 }
547 }
548
FilterShutdown(WorkerMessageFilter * filter)549 void WorkerProcessHost::FilterShutdown(WorkerMessageFilter* filter) {
550 for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
551 bool shutdown = false;
552 i->RemoveFilters(filter);
553
554 int render_frame_id = 0;
555 const WorkerDocumentSet::DocumentInfoSet& documents =
556 i->worker_document_set()->documents();
557 for (WorkerDocumentSet::DocumentInfoSet::const_iterator doc =
558 documents.begin(); doc != documents.end(); ++doc) {
559 if (doc->filter() == filter) {
560 render_frame_id = doc->render_frame_id();
561 break;
562 }
563 }
564 i->worker_document_set()->RemoveAll(filter);
565 if (i->worker_document_set()->IsEmpty()) {
566 shutdown = true;
567 }
568 if (shutdown) {
569 BrowserThread::PostTask(
570 BrowserThread::UI, FROM_HERE,
571 base::Bind(&WorkerTerminatedCallback,
572 filter->render_process_id(),
573 render_frame_id,
574 process_->GetData().id));
575 Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
576 i = instances_.erase(i);
577 } else {
578 ++i;
579 }
580 }
581 ShutdownSocketStreamDispatcherHostIfNecessary();
582 }
583
CanShutdown()584 bool WorkerProcessHost::CanShutdown() {
585 return instances_.empty();
586 }
587
UpdateTitle()588 void WorkerProcessHost::UpdateTitle() {
589 std::set<std::string> titles;
590 for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
591 // Allow the embedder first crack at special casing the title.
592 std::string title = GetContentClient()->browser()->
593 GetWorkerProcessTitle(i->url(), resource_context_);
594
595 if (title.empty()) {
596 title = net::registry_controlled_domains::GetDomainAndRegistry(
597 i->url(),
598 net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
599 }
600
601 // Use the host name if the domain is empty, i.e. localhost or IP address.
602 if (title.empty())
603 title = i->url().host();
604
605 // If the host name is empty, i.e. file url, use the path.
606 if (title.empty())
607 title = i->url().path();
608 titles.insert(title);
609 }
610
611 std::string display_title;
612 for (std::set<std::string>::iterator i = titles.begin();
613 i != titles.end(); ++i) {
614 if (!display_title.empty())
615 display_title += ", ";
616 display_title += *i;
617 }
618
619 process_->SetName(base::UTF8ToUTF16(display_title));
620 }
621
DocumentDetached(WorkerMessageFilter * filter,unsigned long long document_id)622 void WorkerProcessHost::DocumentDetached(WorkerMessageFilter* filter,
623 unsigned long long document_id) {
624 // Walk all instances and remove the document from their document set.
625 for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
626 int render_frame_id = 0;
627 const WorkerDocumentSet::DocumentInfoSet& documents =
628 i->worker_document_set()->documents();
629 for (WorkerDocumentSet::DocumentInfoSet::const_iterator doc =
630 documents.begin(); doc != documents.end(); ++doc) {
631 if (doc->filter() == filter && doc->document_id() == document_id) {
632 render_frame_id = doc->render_frame_id();
633 break;
634 }
635 }
636 i->worker_document_set()->Remove(filter, document_id);
637 if (i->worker_document_set()->IsEmpty()) {
638 BrowserThread::PostTask(
639 BrowserThread::UI, FROM_HERE,
640 base::Bind(&WorkerTerminatedCallback,
641 filter->render_process_id(),
642 render_frame_id,
643 process_->GetData().id));
644 // This worker has no more associated documents - shut it down.
645 Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
646 i = instances_.erase(i);
647 } else {
648 ++i;
649 }
650 }
651 ShutdownSocketStreamDispatcherHostIfNecessary();
652 }
653
TerminateWorker(int worker_route_id)654 void WorkerProcessHost::TerminateWorker(int worker_route_id) {
655 Send(new WorkerMsg_TerminateWorkerContext(worker_route_id));
656 }
657
SetBackgrounded(bool backgrounded)658 void WorkerProcessHost::SetBackgrounded(bool backgrounded) {
659 process_->SetBackgrounded(backgrounded);
660 }
661
GetData()662 const ChildProcessData& WorkerProcessHost::GetData() {
663 return process_->GetData();
664 }
665
GetRenderFrameIDsForWorker(int worker_route_id)666 std::vector<std::pair<int, int> > WorkerProcessHost::GetRenderFrameIDsForWorker(
667 int worker_route_id) {
668 std::vector<std::pair<int, int> > result;
669 WorkerProcessHost::Instances::const_iterator i;
670 for (i = instances_.begin(); i != instances_.end(); ++i) {
671 if (i->worker_route_id() != worker_route_id)
672 continue;
673 const WorkerDocumentSet::DocumentInfoSet& documents =
674 i->worker_document_set()->documents();
675 for (WorkerDocumentSet::DocumentInfoSet::const_iterator doc =
676 documents.begin(); doc != documents.end(); ++doc) {
677 result.push_back(
678 std::make_pair(doc->render_process_id(), doc->render_frame_id()));
679 }
680 break;
681 }
682 return result;
683 }
684
GetContexts(const ResourceHostMsg_Request & request,ResourceContext ** resource_context,net::URLRequestContext ** request_context)685 void WorkerProcessHost::GetContexts(const ResourceHostMsg_Request& request,
686 ResourceContext** resource_context,
687 net::URLRequestContext** request_context) {
688 *resource_context = resource_context_;
689 *request_context = partition_.url_request_context()->GetURLRequestContext();
690 }
691
GetRequestContext(ResourceType::Type resource_type)692 net::URLRequestContext* WorkerProcessHost::GetRequestContext(
693 ResourceType::Type resource_type) {
694 return partition_.url_request_context()->GetURLRequestContext();
695 }
696
WorkerInstance(const GURL & url,const base::string16 & name,const base::string16 & content_security_policy,blink::WebContentSecurityPolicyType security_policy_type,int worker_route_id,int render_frame_id,ResourceContext * resource_context,const WorkerStoragePartition & partition)697 WorkerProcessHost::WorkerInstance::WorkerInstance(
698 const GURL& url,
699 const base::string16& name,
700 const base::string16& content_security_policy,
701 blink::WebContentSecurityPolicyType security_policy_type,
702 int worker_route_id,
703 int render_frame_id,
704 ResourceContext* resource_context,
705 const WorkerStoragePartition& partition)
706 : url_(url),
707 closed_(false),
708 name_(name),
709 content_security_policy_(content_security_policy),
710 security_policy_type_(security_policy_type),
711 worker_route_id_(worker_route_id),
712 render_frame_id_(render_frame_id),
713 worker_document_set_(new WorkerDocumentSet()),
714 resource_context_(resource_context),
715 partition_(partition),
716 load_failed_(false) {
717 DCHECK(resource_context_);
718 }
719
~WorkerInstance()720 WorkerProcessHost::WorkerInstance::~WorkerInstance() {
721 }
722
SetMessagePortID(WorkerMessageFilter * filter,int route_id,int message_port_id)723 void WorkerProcessHost::WorkerInstance::SetMessagePortID(
724 WorkerMessageFilter* filter,
725 int route_id,
726 int message_port_id) {
727 for (FilterList::iterator i = filters_.begin(); i != filters_.end(); ++i) {
728 if (i->filter() == filter && i->route_id() == route_id) {
729 i->set_message_port_id(message_port_id);
730 return;
731 }
732 }
733 }
734
735 // Compares an instance based on the algorithm in the WebWorkers spec - an
736 // instance matches if the origins of the URLs match, and:
737 // a) the names are non-empty and equal
738 // -or-
739 // b) the names are both empty, and the urls are equal
Matches(const GURL & match_url,const base::string16 & match_name,const WorkerStoragePartition & partition,ResourceContext * resource_context) const740 bool WorkerProcessHost::WorkerInstance::Matches(
741 const GURL& match_url,
742 const base::string16& match_name,
743 const WorkerStoragePartition& partition,
744 ResourceContext* resource_context) const {
745 // Only match open shared workers.
746 if (closed_)
747 return false;
748
749 // ResourceContext equivalence is being used as a proxy to ensure we only
750 // matched shared workers within the same BrowserContext.
751 if (resource_context_ != resource_context)
752 return false;
753
754 // We must be in the same storage partition otherwise sharing will violate
755 // isolation.
756 if (!partition_.Equals(partition))
757 return false;
758
759 if (url_.GetOrigin() != match_url.GetOrigin())
760 return false;
761
762 if (name_.empty() && match_name.empty())
763 return url_ == match_url;
764
765 return name_ == match_name;
766 }
767
AddFilter(WorkerMessageFilter * filter,int route_id)768 void WorkerProcessHost::WorkerInstance::AddFilter(WorkerMessageFilter* filter,
769 int route_id) {
770 CHECK(filter);
771 if (!HasFilter(filter, route_id)) {
772 FilterInfo info(filter, route_id);
773 filters_.push_back(info);
774 }
775 }
776
RemoveFilter(WorkerMessageFilter * filter,int route_id)777 void WorkerProcessHost::WorkerInstance::RemoveFilter(
778 WorkerMessageFilter* filter, int route_id) {
779 for (FilterList::iterator i = filters_.begin(); i != filters_.end();) {
780 if (i->filter() == filter && i->route_id() == route_id)
781 i = filters_.erase(i);
782 else
783 ++i;
784 }
785 // Should not be duplicate copies in the filter set.
786 DCHECK(!HasFilter(filter, route_id));
787 }
788
RemoveFilters(WorkerMessageFilter * filter)789 void WorkerProcessHost::WorkerInstance::RemoveFilters(
790 WorkerMessageFilter* filter) {
791 for (FilterList::iterator i = filters_.begin(); i != filters_.end();) {
792 if (i->filter() == filter)
793 i = filters_.erase(i);
794 else
795 ++i;
796 }
797 }
798
HasFilter(WorkerMessageFilter * filter,int route_id) const799 bool WorkerProcessHost::WorkerInstance::HasFilter(
800 WorkerMessageFilter* filter, int route_id) const {
801 for (FilterList::const_iterator i = filters_.begin(); i != filters_.end();
802 ++i) {
803 if (i->filter() == filter && i->route_id() == route_id)
804 return true;
805 }
806 return false;
807 }
808
FrameIsParent(int render_process_id,int render_frame_id) const809 bool WorkerProcessHost::WorkerInstance::FrameIsParent(
810 int render_process_id, int render_frame_id) const {
811 const WorkerDocumentSet::DocumentInfoSet& parents =
812 worker_document_set()->documents();
813 for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
814 parents.begin();
815 parent_iter != parents.end(); ++parent_iter) {
816 if (parent_iter->render_process_id() == render_process_id &&
817 parent_iter->render_frame_id() == render_frame_id) {
818 return true;
819 }
820 }
821 return false;
822 }
823
824 WorkerProcessHost::WorkerInstance::FilterInfo
GetFilter() const825 WorkerProcessHost::WorkerInstance::GetFilter() const {
826 DCHECK(NumFilters() == 1);
827 return *filters_.begin();
828 }
829
830 } // namespace content
831