OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2009, 2010 Google Inc. All rights reserved. | 2 * Copyright (C) 2009, 2010 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 12 matching lines...) Expand all Loading... |
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
29 */ | 29 */ |
30 | 30 |
31 #include "core/loader/WorkerThreadableLoader.h" | 31 #include "core/loader/WorkerThreadableLoader.h" |
32 | 32 |
| 33 #include <memory> |
33 #include "core/dom/Document.h" | 34 #include "core/dom/Document.h" |
34 #include "core/dom/ExecutionContextTask.h" | 35 #include "core/dom/ExecutionContextTask.h" |
35 #include "core/loader/DocumentThreadableLoader.h" | 36 #include "core/loader/DocumentThreadableLoader.h" |
36 #include "core/timing/WorkerGlobalScopePerformance.h" | 37 #include "core/timing/WorkerGlobalScopePerformance.h" |
37 #include "core/workers/WorkerGlobalScope.h" | 38 #include "core/workers/WorkerGlobalScope.h" |
38 #include "core/workers/WorkerLoaderProxy.h" | 39 #include "core/workers/WorkerLoaderProxy.h" |
39 #include "platform/CrossThreadFunctional.h" | 40 #include "platform/CrossThreadFunctional.h" |
| 41 #include "platform/Histogram.h" |
40 #include "platform/heap/SafePoint.h" | 42 #include "platform/heap/SafePoint.h" |
41 #include "platform/network/ResourceError.h" | 43 #include "platform/network/ResourceError.h" |
42 #include "platform/network/ResourceRequest.h" | 44 #include "platform/network/ResourceRequest.h" |
43 #include "platform/network/ResourceResponse.h" | 45 #include "platform/network/ResourceResponse.h" |
44 #include "platform/network/ResourceTimingInfo.h" | 46 #include "platform/network/ResourceTimingInfo.h" |
45 #include "platform/weborigin/KURL.h" | 47 #include "platform/weborigin/KURL.h" |
46 #include "platform/weborigin/SecurityPolicy.h" | 48 #include "platform/weborigin/SecurityPolicy.h" |
| 49 #include "wtf/CurrentTime.h" |
47 #include "wtf/Functional.h" | 50 #include "wtf/Functional.h" |
48 #include "wtf/debug/Alias.h" | 51 #include "wtf/debug/Alias.h" |
49 #include <memory> | |
50 | 52 |
51 namespace blink { | 53 namespace blink { |
52 | 54 |
53 namespace { | 55 namespace { |
54 | 56 |
55 std::unique_ptr<Vector<char>> createVectorFromMemoryRegion( | 57 std::unique_ptr<Vector<char>> createVectorFromMemoryRegion( |
56 const char* data, | 58 const char* data, |
57 unsigned dataLength) { | 59 unsigned dataLength) { |
58 std::unique_ptr<Vector<char>> buffer = | 60 std::unique_ptr<Vector<char>> buffer = |
59 WTF::makeUnique<Vector<char>>(dataLength); | 61 WTF::makeUnique<Vector<char>>(dataLength); |
(...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
194 WorkerGlobalScope& workerGlobalScope, | 196 WorkerGlobalScope& workerGlobalScope, |
195 ThreadableLoaderClient* client, | 197 ThreadableLoaderClient* client, |
196 const ThreadableLoaderOptions& options, | 198 const ThreadableLoaderOptions& options, |
197 const ResourceLoaderOptions& resourceLoaderOptions, | 199 const ResourceLoaderOptions& resourceLoaderOptions, |
198 BlockingBehavior blockingBehavior) | 200 BlockingBehavior blockingBehavior) |
199 : m_workerGlobalScope(&workerGlobalScope), | 201 : m_workerGlobalScope(&workerGlobalScope), |
200 m_workerLoaderProxy(workerGlobalScope.thread()->workerLoaderProxy()), | 202 m_workerLoaderProxy(workerGlobalScope.thread()->workerLoaderProxy()), |
201 m_client(client), | 203 m_client(client), |
202 m_threadableLoaderOptions(options), | 204 m_threadableLoaderOptions(options), |
203 m_resourceLoaderOptions(resourceLoaderOptions), | 205 m_resourceLoaderOptions(resourceLoaderOptions), |
204 m_blockingBehavior(blockingBehavior) { | 206 m_blockingBehavior(blockingBehavior), |
| 207 m_isServiceWorker(workerGlobalScope.isServiceWorkerGlobalScope()) { |
205 DCHECK(client); | 208 DCHECK(client); |
206 } | 209 } |
207 | 210 |
208 void WorkerThreadableLoader::loadResourceSynchronously( | 211 void WorkerThreadableLoader::loadResourceSynchronously( |
209 WorkerGlobalScope& workerGlobalScope, | 212 WorkerGlobalScope& workerGlobalScope, |
210 const ResourceRequest& request, | 213 const ResourceRequest& request, |
211 ThreadableLoaderClient& client, | 214 ThreadableLoaderClient& client, |
212 const ThreadableLoaderOptions& options, | 215 const ThreadableLoaderOptions& options, |
213 const ResourceLoaderOptions& resourceLoaderOptions) { | 216 const ResourceLoaderOptions& resourceLoaderOptions) { |
214 (new WorkerThreadableLoader(workerGlobalScope, &client, options, | 217 (new WorkerThreadableLoader(workerGlobalScope, &client, options, |
(...skipping 20 matching lines...) Expand all Loading... |
235 eventWithTasks = WaitableEventWithTasks::create(); | 238 eventWithTasks = WaitableEventWithTasks::create(); |
236 | 239 |
237 m_workerLoaderProxy->postTaskToLoader( | 240 m_workerLoaderProxy->postTaskToLoader( |
238 BLINK_FROM_HERE, | 241 BLINK_FROM_HERE, |
239 createCrossThreadTask( | 242 createCrossThreadTask( |
240 &MainThreadLoaderHolder::createAndStart, | 243 &MainThreadLoaderHolder::createAndStart, |
241 wrapCrossThreadPersistent(this), m_workerLoaderProxy, | 244 wrapCrossThreadPersistent(this), m_workerLoaderProxy, |
242 wrapCrossThreadPersistent( | 245 wrapCrossThreadPersistent( |
243 m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()), | 246 m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()), |
244 request, m_threadableLoaderOptions, m_resourceLoaderOptions, | 247 request, m_threadableLoaderOptions, m_resourceLoaderOptions, |
245 eventWithTasks)); | 248 eventWithTasks, monotonicallyIncreasingTime(), m_isServiceWorker)); |
246 | 249 |
247 if (m_blockingBehavior == LoadAsynchronously) | 250 if (m_blockingBehavior == LoadAsynchronously) |
248 return; | 251 return; |
249 | 252 |
250 eventWithTasks->wait(); | 253 eventWithTasks->wait(); |
251 | 254 |
252 if (eventWithTasks->isAborted()) { | 255 if (eventWithTasks->isAborted()) { |
253 // This thread is going to terminate. | 256 // This thread is going to terminate. |
254 cancel(); | 257 cancel(); |
255 return; | 258 return; |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
327 void WorkerThreadableLoader::didReceiveRedirectTo(const KURL& url) { | 330 void WorkerThreadableLoader::didReceiveRedirectTo(const KURL& url) { |
328 DCHECK(!isMainThread()); | 331 DCHECK(!isMainThread()); |
329 if (!m_client) | 332 if (!m_client) |
330 return; | 333 return; |
331 m_client->didReceiveRedirectTo(url); | 334 m_client->didReceiveRedirectTo(url); |
332 } | 335 } |
333 | 336 |
334 void WorkerThreadableLoader::didReceiveResponse( | 337 void WorkerThreadableLoader::didReceiveResponse( |
335 unsigned long identifier, | 338 unsigned long identifier, |
336 std::unique_ptr<CrossThreadResourceResponseData> responseData, | 339 std::unique_ptr<CrossThreadResourceResponseData> responseData, |
337 std::unique_ptr<WebDataConsumerHandle> handle) { | 340 std::unique_ptr<WebDataConsumerHandle> handle, |
| 341 double postTaskTime) { |
| 342 int value = |
| 343 static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000); |
| 344 DEFINE_STATIC_LOCAL( |
| 345 CustomCountHistogram, hist, |
| 346 ("SWF.C2.Response.RendererMainToWorker", 0, 10000000, 50)); |
| 347 if (m_isServiceWorker) |
| 348 hist.count(value); |
338 DCHECK(!isMainThread()); | 349 DCHECK(!isMainThread()); |
339 if (!m_client) | 350 if (!m_client) |
340 return; | 351 return; |
341 ResourceResponse response(responseData.get()); | 352 ResourceResponse response(responseData.get()); |
342 m_client->didReceiveResponse(identifier, response, std::move(handle)); | 353 m_client->didReceiveResponse(identifier, response, std::move(handle)); |
343 } | 354 } |
344 | 355 |
345 void WorkerThreadableLoader::didReceiveData( | 356 void WorkerThreadableLoader::didReceiveData( |
346 std::unique_ptr<Vector<char>> data) { | 357 std::unique_ptr<Vector<char>> data) { |
347 DCHECK(!isMainThread()); | 358 DCHECK(!isMainThread()); |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
426 } | 437 } |
427 | 438 |
428 void WorkerThreadableLoader::MainThreadLoaderHolder::createAndStart( | 439 void WorkerThreadableLoader::MainThreadLoaderHolder::createAndStart( |
429 WorkerThreadableLoader* workerLoader, | 440 WorkerThreadableLoader* workerLoader, |
430 PassRefPtr<WorkerLoaderProxy> passLoaderProxy, | 441 PassRefPtr<WorkerLoaderProxy> passLoaderProxy, |
431 WorkerThreadLifecycleContext* workerThreadLifecycleContext, | 442 WorkerThreadLifecycleContext* workerThreadLifecycleContext, |
432 std::unique_ptr<CrossThreadResourceRequestData> request, | 443 std::unique_ptr<CrossThreadResourceRequestData> request, |
433 const ThreadableLoaderOptions& options, | 444 const ThreadableLoaderOptions& options, |
434 const ResourceLoaderOptions& resourceLoaderOptions, | 445 const ResourceLoaderOptions& resourceLoaderOptions, |
435 PassRefPtr<WaitableEventWithTasks> eventWithTasks, | 446 PassRefPtr<WaitableEventWithTasks> eventWithTasks, |
| 447 double postTaskTime, |
| 448 bool isServiceWorker, |
436 ExecutionContext* executionContext) { | 449 ExecutionContext* executionContext) { |
| 450 int value = |
| 451 static_cast<int>((monotonicallyIncreasingTime() - postTaskTime) * 1000); |
| 452 DEFINE_STATIC_LOCAL(CustomCountHistogram, hist, |
| 453 ("SWF.B1.Request.WorkerToRendererMain", 0, 10000000, 50)); |
| 454 if (isServiceWorker) |
| 455 hist.count(value); |
| 456 |
437 DCHECK(isMainThread()); | 457 DCHECK(isMainThread()); |
438 TaskForwarder* forwarder; | 458 TaskForwarder* forwarder; |
439 RefPtr<WorkerLoaderProxy> loaderProxy = passLoaderProxy; | 459 RefPtr<WorkerLoaderProxy> loaderProxy = passLoaderProxy; |
440 if (eventWithTasks) | 460 if (eventWithTasks) |
441 forwarder = new SyncTaskForwarder(std::move(eventWithTasks)); | 461 forwarder = new SyncTaskForwarder(std::move(eventWithTasks)); |
442 else | 462 else |
443 forwarder = new AsyncTaskForwarder(loaderProxy); | 463 forwarder = new AsyncTaskForwarder(loaderProxy); |
444 | 464 |
445 MainThreadLoaderHolder* mainThreadLoaderHolder = | 465 MainThreadLoaderHolder* mainThreadLoaderHolder = |
446 new MainThreadLoaderHolder(forwarder, workerThreadLifecycleContext); | 466 new MainThreadLoaderHolder(forwarder, workerThreadLifecycleContext); |
| 467 mainThreadLoaderHolder->m_isServiceWorker = isServiceWorker; |
447 if (mainThreadLoaderHolder->wasContextDestroyedBeforeObserverCreation()) { | 468 if (mainThreadLoaderHolder->wasContextDestroyedBeforeObserverCreation()) { |
448 // The thread is already terminating. | 469 // The thread is already terminating. |
449 forwarder->abort(); | 470 forwarder->abort(); |
450 mainThreadLoaderHolder->m_forwarder = nullptr; | 471 mainThreadLoaderHolder->m_forwarder = nullptr; |
451 return; | 472 return; |
452 } | 473 } |
453 mainThreadLoaderHolder->m_workerLoader = workerLoader; | 474 mainThreadLoaderHolder->m_workerLoader = workerLoader; |
454 forwarder->forwardTask( | 475 forwarder->forwardTask( |
455 BLINK_FROM_HERE, | 476 BLINK_FROM_HERE, |
456 crossThreadBind(&WorkerThreadableLoader::didStart, | 477 crossThreadBind(&WorkerThreadableLoader::didStart, |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
508 BLINK_FROM_HERE, | 529 BLINK_FROM_HERE, |
509 crossThreadBind(&WorkerThreadableLoader::didReceiveRedirectTo, | 530 crossThreadBind(&WorkerThreadableLoader::didReceiveRedirectTo, |
510 workerLoader, url)); | 531 workerLoader, url)); |
511 } | 532 } |
512 | 533 |
513 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResponse( | 534 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResponse( |
514 unsigned long identifier, | 535 unsigned long identifier, |
515 const ResourceResponse& response, | 536 const ResourceResponse& response, |
516 std::unique_ptr<WebDataConsumerHandle> handle) { | 537 std::unique_ptr<WebDataConsumerHandle> handle) { |
517 DCHECK(isMainThread()); | 538 DCHECK(isMainThread()); |
| 539 double now(monotonicallyIncreasingTime()); |
| 540 int value = static_cast<int>((now * 1000 - response.responseStart() / 1000)); |
| 541 DEFINE_STATIC_LOCAL( |
| 542 CustomCountHistogram, hist, |
| 543 ("SWF.C1.Response.BrowserToRendererMain", 0, 10000000, 50)); |
| 544 if (m_isServiceWorker) |
| 545 hist.count(value); |
| 546 |
518 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = | 547 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = |
519 m_workerLoader.get(); | 548 m_workerLoader.get(); |
520 if (!workerLoader || !m_forwarder) | 549 if (!workerLoader || !m_forwarder) |
521 return; | 550 return; |
522 m_forwarder->forwardTask( | 551 m_forwarder->forwardTask( |
523 BLINK_FROM_HERE, | 552 BLINK_FROM_HERE, |
524 crossThreadBind(&WorkerThreadableLoader::didReceiveResponse, workerLoader, | 553 crossThreadBind(&WorkerThreadableLoader::didReceiveResponse, workerLoader, |
525 identifier, response, WTF::passed(std::move(handle)))); | 554 identifier, response, WTF::passed(std::move(handle)), |
| 555 now)); |
526 } | 556 } |
527 | 557 |
528 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveData( | 558 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveData( |
529 const char* data, | 559 const char* data, |
530 unsigned dataLength) { | 560 unsigned dataLength) { |
531 DCHECK(isMainThread()); | 561 DCHECK(isMainThread()); |
532 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = | 562 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = |
533 m_workerLoader.get(); | 563 m_workerLoader.get(); |
534 if (!workerLoader || !m_forwarder) | 564 if (!workerLoader || !m_forwarder) |
535 return; | 565 return; |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
665 const ResourceLoaderOptions& originalResourceLoaderOptions) { | 695 const ResourceLoaderOptions& originalResourceLoaderOptions) { |
666 DCHECK(isMainThread()); | 696 DCHECK(isMainThread()); |
667 ResourceLoaderOptions resourceLoaderOptions = originalResourceLoaderOptions; | 697 ResourceLoaderOptions resourceLoaderOptions = originalResourceLoaderOptions; |
668 resourceLoaderOptions.requestInitiatorContext = WorkerContext; | 698 resourceLoaderOptions.requestInitiatorContext = WorkerContext; |
669 m_mainThreadLoader = DocumentThreadableLoader::create(document, this, options, | 699 m_mainThreadLoader = DocumentThreadableLoader::create(document, this, options, |
670 resourceLoaderOptions); | 700 resourceLoaderOptions); |
671 m_mainThreadLoader->start(ResourceRequest(request.get())); | 701 m_mainThreadLoader->start(ResourceRequest(request.get())); |
672 } | 702 } |
673 | 703 |
674 } // namespace blink | 704 } // namespace blink |
OLD | NEW |