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_service_impl.h" | 5 #include "content/browser/shared_worker/shared_worker_service_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <iterator> | 8 #include <iterator> |
9 #include <set> | 9 #include <set> |
10 #include <vector> | 10 #include <vector> |
11 | 11 |
| 12 #include "content/browser/devtools/shared_worker_devtools_manager.h" |
12 #include "content/browser/renderer_host/render_process_host_impl.h" | 13 #include "content/browser/renderer_host/render_process_host_impl.h" |
13 #include "content/browser/shared_worker/shared_worker_host.h" | 14 #include "content/browser/shared_worker/shared_worker_host.h" |
14 #include "content/browser/shared_worker/shared_worker_instance.h" | 15 #include "content/browser/shared_worker/shared_worker_instance.h" |
15 #include "content/browser/shared_worker/shared_worker_message_filter.h" | 16 #include "content/browser/shared_worker/shared_worker_message_filter.h" |
16 #include "content/browser/worker_host/worker_document_set.h" | 17 #include "content/browser/worker_host/worker_document_set.h" |
17 #include "content/common/view_messages.h" | 18 #include "content/common/view_messages.h" |
18 #include "content/common/worker_messages.h" | 19 #include "content/common/worker_messages.h" |
19 #include "content/public/browser/browser_thread.h" | 20 #include "content/public/browser/browser_thread.h" |
20 #include "content/public/browser/worker_service_observer.h" | 21 #include "content/public/browser/worker_service_observer.h" |
21 | 22 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
54 } | 55 } |
55 | 56 |
56 void UpdateWorkerDependency(const std::vector<int>& added_ids, | 57 void UpdateWorkerDependency(const std::vector<int>& added_ids, |
57 const std::vector<int>& removed_ids) { | 58 const std::vector<int>& removed_ids) { |
58 BrowserThread::PostTask( | 59 BrowserThread::PostTask( |
59 BrowserThread::UI, | 60 BrowserThread::UI, |
60 FROM_HERE, | 61 FROM_HERE, |
61 base::Bind(&UpdateWorkerDependencyOnUI, added_ids, removed_ids)); | 62 base::Bind(&UpdateWorkerDependencyOnUI, added_ids, removed_ids)); |
62 } | 63 } |
63 | 64 |
| 65 void WorkerCreatedResultCallbackOnIO(int worker_process_id, |
| 66 int worker_route_id, |
| 67 bool pause_on_start) { |
| 68 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| 69 SharedWorkerServiceImpl::GetInstance()->WorkerCreatedResultCallback( |
| 70 worker_process_id, worker_route_id, pause_on_start); |
| 71 } |
| 72 |
| 73 void NotifyWorkerCreatedOnUI(int worker_process_id, |
| 74 int worker_route_id, |
| 75 const SharedWorkerInstance& instance) { |
| 76 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| 77 bool pause_on_start = |
| 78 SharedWorkerDevToolsManager::GetInstance()->WorkerCreated( |
| 79 worker_process_id, worker_route_id, instance); |
| 80 BrowserThread::PostTask(BrowserThread::IO, |
| 81 FROM_HERE, |
| 82 base::Bind(&WorkerCreatedResultCallbackOnIO, |
| 83 worker_process_id, |
| 84 worker_route_id, |
| 85 pause_on_start)); |
| 86 } |
| 87 |
64 } // namespace | 88 } // namespace |
65 | 89 |
66 SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() { | 90 SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() { |
67 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 91 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
68 return Singleton<SharedWorkerServiceImpl>::get(); | 92 return Singleton<SharedWorkerServiceImpl>::get(); |
69 } | 93 } |
70 | 94 |
71 SharedWorkerServiceImpl::SharedWorkerServiceImpl() | 95 SharedWorkerServiceImpl::SharedWorkerServiceImpl() |
72 : update_worker_dependency_(UpdateWorkerDependency) {} | 96 : update_worker_dependency_(UpdateWorkerDependency) {} |
73 | 97 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
123 const ViewHostMsg_CreateWorker_Params& params, | 147 const ViewHostMsg_CreateWorker_Params& params, |
124 int route_id, | 148 int route_id, |
125 SharedWorkerMessageFilter* filter, | 149 SharedWorkerMessageFilter* filter, |
126 ResourceContext* resource_context, | 150 ResourceContext* resource_context, |
127 const WorkerStoragePartition& partition, | 151 const WorkerStoragePartition& partition, |
128 bool* url_mismatch) { | 152 bool* url_mismatch) { |
129 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 153 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
130 ScopedWorkerDependencyChecker checker(this); | 154 ScopedWorkerDependencyChecker checker(this); |
131 *url_mismatch = false; | 155 *url_mismatch = false; |
132 SharedWorkerHost* existing_host = FindSharedWorkerHost( | 156 SharedWorkerHost* existing_host = FindSharedWorkerHost( |
133 params.url, params.name, partition, resource_context); | 157 worker_hosts_, params.url, params.name, partition, resource_context); |
134 if (existing_host) { | 158 if (existing_host) { |
135 if (params.url != existing_host->instance()->url()) { | 159 if (params.url != existing_host->instance()->url()) { |
136 *url_mismatch = true; | 160 *url_mismatch = true; |
137 return; | 161 return; |
138 } | 162 } |
139 if (existing_host->load_failed()) { | 163 if (existing_host->load_failed()) { |
140 filter->Send(new ViewMsg_WorkerScriptLoadFailed(route_id)); | 164 filter->Send(new ViewMsg_WorkerScriptLoadFailed(route_id)); |
141 return; | 165 return; |
142 } | 166 } |
143 existing_host->AddFilter(filter, route_id); | 167 existing_host->AddFilter(filter, route_id); |
144 existing_host->worker_document_set()->Add(filter, | 168 existing_host->worker_document_set()->Add(filter, |
145 params.document_id, | 169 params.document_id, |
146 filter->render_process_id(), | 170 filter->render_process_id(), |
147 params.render_frame_route_id); | 171 params.render_frame_route_id); |
148 filter->Send(new ViewMsg_WorkerCreated(route_id)); | 172 filter->Send(new ViewMsg_WorkerCreated(route_id)); |
149 return; | 173 return; |
150 } | 174 } |
| 175 SharedWorkerHost* pending_host = FindSharedWorkerHost(pending_worker_hosts_, |
| 176 params.url, |
| 177 params.name, |
| 178 partition, |
| 179 resource_context); |
| 180 if (pending_host) { |
| 181 if (params.url != pending_host->instance()->url()) { |
| 182 *url_mismatch = true; |
| 183 return; |
| 184 } |
| 185 pending_host->AddFilter(filter, route_id); |
| 186 pending_host->worker_document_set()->Add(filter, |
| 187 params.document_id, |
| 188 filter->render_process_id(), |
| 189 params.render_frame_route_id); |
| 190 return; |
| 191 } |
151 | 192 |
152 scoped_ptr<SharedWorkerInstance> instance(new SharedWorkerInstance( | 193 scoped_ptr<SharedWorkerInstance> instance(new SharedWorkerInstance( |
153 params.url, | 194 params.url, |
154 params.name, | 195 params.name, |
155 params.content_security_policy, | 196 params.content_security_policy, |
156 params.security_policy_type, | 197 params.security_policy_type, |
157 resource_context, | 198 resource_context, |
158 partition)); | 199 partition)); |
159 scoped_ptr<SharedWorkerHost> host(new SharedWorkerHost(instance.release())); | 200 scoped_ptr<SharedWorkerHost> host( |
| 201 new SharedWorkerHost(instance.release(), filter)); |
160 host->AddFilter(filter, route_id); | 202 host->AddFilter(filter, route_id); |
161 host->worker_document_set()->Add(filter, | 203 host->worker_document_set()->Add(filter, |
162 params.document_id, | 204 params.document_id, |
163 filter->render_process_id(), | 205 filter->render_process_id(), |
164 params.render_frame_route_id); | 206 params.render_frame_route_id); |
| 207 const int worker_route_id = host->worker_route_id(); |
| 208 // We need to call SharedWorkerDevToolsManager::WorkerCreated() on UI thread |
| 209 // to know whether the worker should be paused on start or not. |
| 210 // WorkerCreatedResultCallback() will be called with the result. |
| 211 BrowserThread::PostTask(BrowserThread::UI, |
| 212 FROM_HERE, |
| 213 base::Bind(&NotifyWorkerCreatedOnUI, |
| 214 filter->render_process_id(), |
| 215 worker_route_id, |
| 216 *host->instance())); |
| 217 pending_worker_hosts_.set( |
| 218 std::make_pair(filter->render_process_id(), worker_route_id), |
| 219 host.Pass()); |
| 220 } |
165 | 221 |
166 host->Init(filter); | 222 void SharedWorkerServiceImpl::WorkerCreatedResultCallback(int worker_process_id, |
167 const int worker_route_id = host->worker_route_id(); | 223 int worker_route_id, |
168 worker_hosts_.set(std::make_pair(filter->render_process_id(), | 224 bool pause_on_start) { |
169 worker_route_id), | 225 scoped_ptr<SharedWorkerHost> host = pending_worker_hosts_.take_and_erase( |
| 226 std::make_pair(worker_process_id, worker_route_id)); |
| 227 const GURL url = host->instance()->url(); |
| 228 const base::string16 name = host->instance()->name(); |
| 229 host->Start(pause_on_start); |
| 230 worker_hosts_.set(std::make_pair(worker_process_id, worker_route_id), |
170 host.Pass()); | 231 host.Pass()); |
171 | |
172 FOR_EACH_OBSERVER( | 232 FOR_EACH_OBSERVER( |
173 WorkerServiceObserver, observers_, | 233 WorkerServiceObserver, |
174 WorkerCreated(params.url, | 234 observers_, |
175 params.name, | 235 WorkerCreated(url, name, worker_process_id, worker_route_id)); |
176 filter->render_process_id(), | |
177 worker_route_id)); | |
178 } | 236 } |
179 | 237 |
180 void SharedWorkerServiceImpl::ForwardToWorker( | 238 void SharedWorkerServiceImpl::ForwardToWorker( |
181 const IPC::Message& message, | 239 const IPC::Message& message, |
182 SharedWorkerMessageFilter* filter) { | 240 SharedWorkerMessageFilter* filter) { |
183 for (WorkerHostMap::const_iterator iter = worker_hosts_.begin(); | 241 for (WorkerHostMap::const_iterator iter = worker_hosts_.begin(); |
184 iter != worker_hosts_.end(); | 242 iter != worker_hosts_.end(); |
185 ++iter) { | 243 ++iter) { |
186 if (iter->second->FilterMessage(message, filter)) | 244 if (iter->second->FilterMessage(message, filter)) |
187 return; | 245 return; |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
281 SharedWorkerMessageFilter* filter) { | 339 SharedWorkerMessageFilter* filter) { |
282 ScopedWorkerDependencyChecker checker(this); | 340 ScopedWorkerDependencyChecker checker(this); |
283 std::vector<ProcessRouteIdPair> remove_list; | 341 std::vector<ProcessRouteIdPair> remove_list; |
284 for (WorkerHostMap::iterator iter = worker_hosts_.begin(); | 342 for (WorkerHostMap::iterator iter = worker_hosts_.begin(); |
285 iter != worker_hosts_.end(); | 343 iter != worker_hosts_.end(); |
286 ++iter) { | 344 ++iter) { |
287 iter->second->FilterShutdown(filter); | 345 iter->second->FilterShutdown(filter); |
288 if (iter->first.first == filter->render_process_id()) | 346 if (iter->first.first == filter->render_process_id()) |
289 remove_list.push_back(iter->first); | 347 remove_list.push_back(iter->first); |
290 } | 348 } |
291 for (size_t i = 0; i < remove_list.size(); ++i) | 349 for (size_t i = 0; i < remove_list.size(); ++i) { |
292 worker_hosts_.erase(remove_list[i]); | 350 scoped_ptr<SharedWorkerHost> host = |
| 351 worker_hosts_.take_and_erase(remove_list[i]); |
| 352 } |
| 353 } |
| 354 |
| 355 void SharedWorkerServiceImpl::NotifyWorkerDestroyed(int worker_process_id, |
| 356 int worker_route_id) { |
| 357 FOR_EACH_OBSERVER(WorkerServiceObserver, |
| 358 observers_, |
| 359 WorkerDestroyed(worker_process_id, worker_route_id)); |
293 } | 360 } |
294 | 361 |
295 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost( | 362 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost( |
296 SharedWorkerMessageFilter* filter, | 363 SharedWorkerMessageFilter* filter, |
297 int worker_route_id) { | 364 int worker_route_id) { |
298 return worker_hosts_.get(std::make_pair(filter->render_process_id(), | 365 return worker_hosts_.get(std::make_pair(filter->render_process_id(), |
299 worker_route_id)); | 366 worker_route_id)); |
300 } | 367 } |
301 | 368 |
302 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost( | 369 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost( |
| 370 const WorkerHostMap& hosts, |
303 const GURL& url, | 371 const GURL& url, |
304 const base::string16& name, | 372 const base::string16& name, |
305 const WorkerStoragePartition& partition, | 373 const WorkerStoragePartition& partition, |
306 ResourceContext* resource_context) { | 374 ResourceContext* resource_context) { |
307 for (WorkerHostMap::const_iterator iter = worker_hosts_.begin(); | 375 for (WorkerHostMap::const_iterator iter = hosts.begin(); iter != hosts.end(); |
308 iter != worker_hosts_.end(); | |
309 ++iter) { | 376 ++iter) { |
310 SharedWorkerInstance* instance = iter->second->instance(); | 377 SharedWorkerInstance* instance = iter->second->instance(); |
311 if (instance && !iter->second->closed() && | 378 if (instance && !iter->second->closed() && |
312 instance->Matches(url, name, partition, resource_context)) | 379 instance->Matches(url, name, partition, resource_context)) |
313 return iter->second; | 380 return iter->second; |
314 } | 381 } |
315 return NULL; | 382 return NULL; |
316 } | 383 } |
317 | 384 |
318 const std::set<int> | 385 const std::set<int> |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
353 update_worker_dependency_(added_items, removed_items); | 420 update_worker_dependency_(added_items, removed_items); |
354 } | 421 } |
355 } | 422 } |
356 | 423 |
357 void SharedWorkerServiceImpl::ChangeUpdateWorkerDependencyFuncForTesting( | 424 void SharedWorkerServiceImpl::ChangeUpdateWorkerDependencyFuncForTesting( |
358 UpdateWorkerDependencyFunc new_func) { | 425 UpdateWorkerDependencyFunc new_func) { |
359 update_worker_dependency_ = new_func; | 426 update_worker_dependency_ = new_func; |
360 } | 427 } |
361 | 428 |
362 } // namespace content | 429 } // namespace content |
OLD | NEW |