OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/shared_worker/shared_worker_host.h" | 5 #include "content/browser/shared_worker/shared_worker_host.h" |
6 | 6 |
| 7 #include "content/browser/message_port_service.h" |
7 #include "content/browser/shared_worker/shared_worker_instance.h" | 8 #include "content/browser/shared_worker/shared_worker_instance.h" |
8 #include "content/browser/shared_worker/shared_worker_message_filter.h" | 9 #include "content/browser/shared_worker/shared_worker_message_filter.h" |
| 10 #include "content/common/view_messages.h" |
| 11 #include "content/common/worker_messages.h" |
9 #include "content/public/browser/browser_thread.h" | 12 #include "content/public/browser/browser_thread.h" |
10 | 13 |
11 namespace content { | 14 namespace content { |
12 | 15 |
13 SharedWorkerHost::SharedWorkerHost(SharedWorkerInstance* instance) | 16 SharedWorkerHost::SharedWorkerHost(SharedWorkerInstance* instance) |
14 : instance_(instance), | 17 : instance_(instance), |
| 18 container_render_filter_(NULL), |
15 worker_route_id_(MSG_ROUTING_NONE) { | 19 worker_route_id_(MSG_ROUTING_NONE) { |
16 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 20 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
17 } | 21 } |
18 | 22 |
19 SharedWorkerHost::~SharedWorkerHost() { | 23 SharedWorkerHost::~SharedWorkerHost() { |
20 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 24 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
21 } | 25 } |
22 | 26 |
| 27 bool SharedWorkerHost::Send(IPC::Message* message) { |
| 28 if (!container_render_filter_) { |
| 29 delete message; |
| 30 return false; |
| 31 } |
| 32 return container_render_filter_->Send(message); |
| 33 } |
| 34 |
23 void SharedWorkerHost::Init(SharedWorkerMessageFilter* filter) { | 35 void SharedWorkerHost::Init(SharedWorkerMessageFilter* filter) { |
| 36 CHECK(instance_); |
24 DCHECK(worker_route_id_ == MSG_ROUTING_NONE); | 37 DCHECK(worker_route_id_ == MSG_ROUTING_NONE); |
| 38 container_render_filter_ = filter; |
25 worker_route_id_ = filter->GetNextRoutingID(); | 39 worker_route_id_ = filter->GetNextRoutingID(); |
| 40 |
| 41 WorkerProcessMsg_CreateWorker_Params params; |
| 42 params.url = instance_->url(); |
| 43 params.name = instance_->name(); |
| 44 params.content_security_policy = instance_->content_security_policy(); |
| 45 params.security_policy_type = instance_->security_policy_type(); |
| 46 params.route_id = worker_route_id_; |
| 47 Send(new WorkerProcessMsg_CreateWorker(params)); |
| 48 |
| 49 for (SharedWorkerInstance::FilterList::const_iterator i = |
| 50 instance_->filters().begin(); |
| 51 i != instance_->filters().end(); ++i) { |
| 52 i->filter()->Send(new ViewMsg_WorkerCreated(i->route_id())); |
| 53 } |
| 54 } |
| 55 |
| 56 bool SharedWorkerHost::FilterMessage(const IPC::Message& message, |
| 57 SharedWorkerMessageFilter* filter) { |
| 58 if (!instance_) |
| 59 return false; |
| 60 |
| 61 if (!instance_->closed() && |
| 62 instance_->HasFilter(filter, message.routing_id())) { |
| 63 RelayMessage(message, filter); |
| 64 return true; |
| 65 } |
| 66 |
| 67 return false; |
| 68 } |
| 69 |
| 70 void SharedWorkerHost::FilterShutdown(SharedWorkerMessageFilter* filter) { |
| 71 if (!instance_) |
| 72 return; |
| 73 instance_->RemoveFilters(filter); |
| 74 instance_->worker_document_set()->RemoveAll(filter); |
| 75 if (instance_->worker_document_set()->IsEmpty()) { |
| 76 // This worker has no more associated documents - shut it down. |
| 77 Send(new WorkerMsg_TerminateWorkerContext(worker_route_id_)); |
| 78 } |
| 79 } |
| 80 |
| 81 void SharedWorkerHost::DocumentDetached(SharedWorkerMessageFilter* filter, |
| 82 unsigned long long document_id) { |
| 83 if (!instance_) |
| 84 return; |
| 85 // Walk all instances and remove the document from their document set. |
| 86 instance_->worker_document_set()->Remove(filter, document_id); |
| 87 if (instance_->worker_document_set()->IsEmpty()) { |
| 88 // This worker has no more associated documents - shut it down. |
| 89 Send(new WorkerMsg_TerminateWorkerContext(worker_route_id_)); |
| 90 } |
| 91 } |
| 92 |
| 93 void SharedWorkerHost::WorkerContextClosed() { |
| 94 if (!instance_) |
| 95 return; |
| 96 // Set the closed flag - this will stop any further messages from |
| 97 // being sent to the worker (messages can still be sent from the worker, |
| 98 // for exception reporting, etc). |
| 99 instance_->set_closed(true); |
| 100 } |
| 101 |
| 102 void SharedWorkerHost::WorkerContextDestroyed() { |
| 103 if (!instance_) |
| 104 return; |
| 105 instance_.reset(); |
| 106 } |
| 107 |
| 108 void SharedWorkerHost::WorkerScriptLoaded() { |
26 // TODO(horo): implement this. | 109 // TODO(horo): implement this. |
27 NOTIMPLEMENTED(); | 110 NOTIMPLEMENTED(); |
28 } | 111 } |
29 | 112 |
| 113 void SharedWorkerHost::WorkerScriptLoadFailed() { |
| 114 if (!instance_) |
| 115 return; |
| 116 instance_->set_load_failed(true); |
| 117 for (SharedWorkerInstance::FilterList::const_iterator i = |
| 118 instance_->filters().begin(); |
| 119 i != instance_->filters().end(); ++i) { |
| 120 i->filter()->Send(new ViewMsg_WorkerScriptLoadFailed(i->route_id())); |
| 121 } |
| 122 } |
| 123 |
| 124 void SharedWorkerHost::WorkerConnected(int message_port_id) { |
| 125 if (!instance_) |
| 126 return; |
| 127 for (SharedWorkerInstance::FilterList::const_iterator i = |
| 128 instance_->filters().begin(); |
| 129 i != instance_->filters().end(); ++i) { |
| 130 if (i->message_port_id() != message_port_id) |
| 131 continue; |
| 132 i->filter()->Send(new ViewMsg_WorkerConnected(i->route_id())); |
| 133 return; |
| 134 } |
| 135 } |
| 136 |
| 137 void SharedWorkerHost::AllowDatabase(const GURL& url, |
| 138 const base::string16& name, |
| 139 const base::string16& display_name, |
| 140 unsigned long estimated_size, |
| 141 bool* result) { |
| 142 // TODO(horo): implement this. |
| 143 NOTIMPLEMENTED(); |
| 144 } |
| 145 |
| 146 void SharedWorkerHost::AllowFileSystem(const GURL& url, |
| 147 bool* result) { |
| 148 // TODO(horo): implement this. |
| 149 NOTIMPLEMENTED(); |
| 150 } |
| 151 |
| 152 void SharedWorkerHost::AllowIndexedDB(const GURL& url, |
| 153 const base::string16& name, |
| 154 bool* result) { |
| 155 // TODO(horo): implement this. |
| 156 NOTIMPLEMENTED(); |
| 157 } |
| 158 |
| 159 void SharedWorkerHost::RelayMessage( |
| 160 const IPC::Message& message, |
| 161 SharedWorkerMessageFilter* incoming_filter) { |
| 162 if (!instance_) |
| 163 return; |
| 164 if (message.type() == WorkerMsg_Connect::ID) { |
| 165 // Crack the SharedWorker Connect message to setup routing for the port. |
| 166 int sent_message_port_id; |
| 167 int new_routing_id; |
| 168 if (!WorkerMsg_Connect::Read( |
| 169 &message, &sent_message_port_id, &new_routing_id)) { |
| 170 return; |
| 171 } |
| 172 DCHECK(container_render_filter_); |
| 173 new_routing_id = container_render_filter_->GetNextRoutingID(); |
| 174 MessagePortService::GetInstance()->UpdateMessagePort( |
| 175 sent_message_port_id, |
| 176 container_render_filter_->message_port_message_filter(), |
| 177 new_routing_id); |
| 178 instance_->SetMessagePortID(incoming_filter, |
| 179 message.routing_id(), |
| 180 sent_message_port_id); |
| 181 // Resend the message with the new routing id. |
| 182 Send(new WorkerMsg_Connect( |
| 183 worker_route_id_, sent_message_port_id, new_routing_id)); |
| 184 |
| 185 // Send any queued messages for the sent port. |
| 186 MessagePortService::GetInstance()->SendQueuedMessagesIfPossible( |
| 187 sent_message_port_id); |
| 188 } else { |
| 189 IPC::Message* new_message = new IPC::Message(message); |
| 190 new_message->set_routing_id(worker_route_id_); |
| 191 Send(new_message); |
| 192 return; |
| 193 } |
| 194 } |
| 195 |
30 } // namespace content | 196 } // namespace content |
OLD | NEW |