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 206 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
217 DCHECK(client); | 217 DCHECK(client); |
218 } | 218 } |
219 | 219 |
220 void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& worker
GlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, con
st ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoader
Options) | 220 void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& worker
GlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, con
st ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoader
Options) |
221 { | 221 { |
222 (new WorkerThreadableLoader(workerGlobalScope, &client, options, resourceLoa
derOptions, LoadSynchronously))->start(request); | 222 (new WorkerThreadableLoader(workerGlobalScope, &client, options, resourceLoa
derOptions, LoadSynchronously))->start(request); |
223 } | 223 } |
224 | 224 |
225 WorkerThreadableLoader::~WorkerThreadableLoader() | 225 WorkerThreadableLoader::~WorkerThreadableLoader() |
226 { | 226 { |
227 DCHECK(!m_mainThreadLoaderHolder); | 227 DCHECK(!m_peer); |
228 DCHECK(!m_client); | 228 DCHECK(!m_client); |
229 } | 229 } |
230 | 230 |
231 void WorkerThreadableLoader::start(const ResourceRequest& originalRequest) | 231 void WorkerThreadableLoader::start(const ResourceRequest& originalRequest) |
232 { | 232 { |
233 ResourceRequest request(originalRequest); | 233 ResourceRequest request(originalRequest); |
234 if (!request.didSetHTTPReferrer()) | 234 if (!request.didSetHTTPReferrer()) |
235 request.setHTTPReferrer(SecurityPolicy::generateReferrer(m_workerGlobalS
cope->getReferrerPolicy(), request.url(), m_workerGlobalScope->outgoingReferrer(
))); | 235 request.setHTTPReferrer(SecurityPolicy::generateReferrer(m_workerGlobalS
cope->getReferrerPolicy(), request.url(), m_workerGlobalScope->outgoingReferrer(
))); |
236 | 236 |
237 DCHECK(!isMainThread()); | 237 DCHECK(!isMainThread()); |
238 RefPtr<WaitableEventWithTasks> eventWithTasks; | 238 RefPtr<WaitableEventWithTasks> eventWithTasks; |
239 if (m_blockingBehavior == LoadSynchronously) | 239 if (m_blockingBehavior == LoadSynchronously) |
240 eventWithTasks = WaitableEventWithTasks::create(); | 240 eventWithTasks = WaitableEventWithTasks::create(); |
241 | 241 |
242 m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask
( | 242 m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask
( |
243 &MainThreadLoaderHolder::createAndStart, | 243 &Peer::createAndStart, |
244 wrapCrossThreadPersistent(this), | 244 wrapCrossThreadPersistent(this), |
245 m_workerLoaderProxy, | 245 m_workerLoaderProxy, |
246 wrapCrossThreadPersistent(m_workerGlobalScope->thread()->getWorkerThread
LifecycleContext()), | 246 wrapCrossThreadPersistent(m_workerGlobalScope->thread()->getWorkerThread
LifecycleContext()), |
247 request, | 247 request, |
248 m_threadableLoaderOptions, | 248 m_threadableLoaderOptions, |
249 m_resourceLoaderOptions, | 249 m_resourceLoaderOptions, |
250 eventWithTasks)); | 250 eventWithTasks)); |
251 | 251 |
252 if (m_blockingBehavior == LoadAsynchronously) | 252 if (m_blockingBehavior == LoadAsynchronously) |
253 return; | 253 return; |
(...skipping 17 matching lines...) Expand all Loading... |
271 | 271 |
272 // m_clientTask contains only CallClosureTasks. So, it's ok to pass | 272 // m_clientTask contains only CallClosureTasks. So, it's ok to pass |
273 // the nullptr. | 273 // the nullptr. |
274 task.m_task->performTask(nullptr); | 274 task.m_task->performTask(nullptr); |
275 } | 275 } |
276 } | 276 } |
277 | 277 |
278 void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds) | 278 void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds) |
279 { | 279 { |
280 DCHECK(!isMainThread()); | 280 DCHECK(!isMainThread()); |
281 if (!m_mainThreadLoaderHolder) | 281 if (!m_peer) |
282 return; | 282 return; |
283 m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask
(&MainThreadLoaderHolder::overrideTimeout, m_mainThreadLoaderHolder, timeoutMill
iseconds)); | 283 m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask
(&Peer::overrideTimeout, m_peer, timeoutMilliseconds)); |
284 } | 284 } |
285 | 285 |
286 void WorkerThreadableLoader::cancel() | 286 void WorkerThreadableLoader::cancel() |
287 { | 287 { |
288 DCHECK(!isMainThread()); | 288 DCHECK(!isMainThread()); |
289 if (m_mainThreadLoaderHolder) { | 289 if (m_peer) { |
290 m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThread
Task(&MainThreadLoaderHolder::cancel, m_mainThreadLoaderHolder)); | 290 m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThread
Task(&Peer::cancel, m_peer)); |
291 m_mainThreadLoaderHolder = nullptr; | 291 m_peer = nullptr; |
292 } | 292 } |
293 | 293 |
294 if (!m_client) | 294 if (!m_client) |
295 return; | 295 return; |
296 | 296 |
297 // If the client hasn't reached a termination state, then transition it | 297 // If the client hasn't reached a termination state, then transition it |
298 // by sending a cancellation error. | 298 // by sending a cancellation error. |
299 // Note: no more client callbacks will be done after this method -- the | 299 // Note: no more client callbacks will be done after this method -- the |
300 // clearClient() call ensures that. | 300 // clearClient() call ensures that. |
301 ResourceError error(String(), 0, String(), String()); | 301 ResourceError error(String(), 0, String(), String()); |
302 error.setIsCancellation(true); | 302 error.setIsCancellation(true); |
303 didFail(error); | 303 didFail(error); |
304 DCHECK(!m_client); | 304 DCHECK(!m_client); |
305 } | 305 } |
306 | 306 |
307 void WorkerThreadableLoader::didStart(MainThreadLoaderHolder* mainThreadLoaderHo
lder) | 307 void WorkerThreadableLoader::didStart(Peer* peer) |
308 { | 308 { |
309 DCHECK(!isMainThread()); | 309 DCHECK(!isMainThread()); |
310 DCHECK(!m_mainThreadLoaderHolder); | 310 DCHECK(!m_peer); |
311 DCHECK(mainThreadLoaderHolder); | 311 DCHECK(peer); |
312 if (!m_client) { | 312 if (!m_client) { |
313 // The loading is already cancelled. | 313 // The loading is already cancelled. |
314 return; | 314 return; |
315 } | 315 } |
316 | 316 |
317 m_mainThreadLoaderHolder = mainThreadLoaderHolder; | 317 m_peer = peer; |
318 } | 318 } |
319 | 319 |
320 void WorkerThreadableLoader::didSendData(unsigned long long bytesSent, unsigned
long long totalBytesToBeSent) | 320 void WorkerThreadableLoader::didSendData(unsigned long long bytesSent, unsigned
long long totalBytesToBeSent) |
321 { | 321 { |
322 DCHECK(!isMainThread()); | 322 DCHECK(!isMainThread()); |
323 if (!m_client) | 323 if (!m_client) |
324 return; | 324 return; |
325 m_client->didSendData(bytesSent, totalBytesToBeSent); | 325 m_client->didSendData(bytesSent, totalBytesToBeSent); |
326 } | 326 } |
327 | 327 |
(...skipping 23 matching lines...) Expand all Loading... |
351 m_client->didReceiveCachedMetadata(data->data(), data->size()); | 351 m_client->didReceiveCachedMetadata(data->data(), data->size()); |
352 } | 352 } |
353 | 353 |
354 void WorkerThreadableLoader::didFinishLoading(unsigned long identifier, double f
inishTime) | 354 void WorkerThreadableLoader::didFinishLoading(unsigned long identifier, double f
inishTime) |
355 { | 355 { |
356 DCHECK(!isMainThread()); | 356 DCHECK(!isMainThread()); |
357 if (!m_client) | 357 if (!m_client) |
358 return; | 358 return; |
359 auto* client = m_client; | 359 auto* client = m_client; |
360 m_client = nullptr; | 360 m_client = nullptr; |
361 m_mainThreadLoaderHolder = nullptr; | 361 m_peer = nullptr; |
362 client->didFinishLoading(identifier, finishTime); | 362 client->didFinishLoading(identifier, finishTime); |
363 } | 363 } |
364 | 364 |
365 void WorkerThreadableLoader::didFail(const ResourceError& error) | 365 void WorkerThreadableLoader::didFail(const ResourceError& error) |
366 { | 366 { |
367 DCHECK(!isMainThread()); | 367 DCHECK(!isMainThread()); |
368 if (!m_client) | 368 if (!m_client) |
369 return; | 369 return; |
370 auto* client = m_client; | 370 auto* client = m_client; |
371 m_client = nullptr; | 371 m_client = nullptr; |
372 m_mainThreadLoaderHolder = nullptr; | 372 m_peer = nullptr; |
373 client->didFail(error); | 373 client->didFail(error); |
374 } | 374 } |
375 | 375 |
376 void WorkerThreadableLoader::didFailAccessControlCheck(const ResourceError& erro
r) | 376 void WorkerThreadableLoader::didFailAccessControlCheck(const ResourceError& erro
r) |
377 { | 377 { |
378 DCHECK(!isMainThread()); | 378 DCHECK(!isMainThread()); |
379 if (!m_client) | 379 if (!m_client) |
380 return; | 380 return; |
381 auto* client = m_client; | 381 auto* client = m_client; |
382 m_client = nullptr; | 382 m_client = nullptr; |
383 m_mainThreadLoaderHolder = nullptr; | 383 m_peer = nullptr; |
384 client->didFailAccessControlCheck(error); | 384 client->didFailAccessControlCheck(error); |
385 } | 385 } |
386 | 386 |
387 void WorkerThreadableLoader::didFailRedirectCheck() | 387 void WorkerThreadableLoader::didFailRedirectCheck() |
388 { | 388 { |
389 DCHECK(!isMainThread()); | 389 DCHECK(!isMainThread()); |
390 if (!m_client) | 390 if (!m_client) |
391 return; | 391 return; |
392 auto* client = m_client; | 392 auto* client = m_client; |
393 m_client = nullptr; | 393 m_client = nullptr; |
394 m_mainThreadLoaderHolder = nullptr; | 394 m_peer = nullptr; |
395 client->didFailRedirectCheck(); | 395 client->didFailRedirectCheck(); |
396 } | 396 } |
397 | 397 |
398 void WorkerThreadableLoader::didDownloadData(int dataLength) | 398 void WorkerThreadableLoader::didDownloadData(int dataLength) |
399 { | 399 { |
400 DCHECK(!isMainThread()); | 400 DCHECK(!isMainThread()); |
401 if (!m_client) | 401 if (!m_client) |
402 return; | 402 return; |
403 m_client->didDownloadData(dataLength); | 403 m_client->didDownloadData(dataLength); |
404 } | 404 } |
405 | 405 |
406 void WorkerThreadableLoader::didReceiveResourceTiming(std::unique_ptr<CrossThrea
dResourceTimingInfoData> timingData) | 406 void WorkerThreadableLoader::didReceiveResourceTiming(std::unique_ptr<CrossThrea
dResourceTimingInfoData> timingData) |
407 { | 407 { |
408 DCHECK(!isMainThread()); | 408 DCHECK(!isMainThread()); |
409 if (!m_client) | 409 if (!m_client) |
410 return; | 410 return; |
411 std::unique_ptr<ResourceTimingInfo> info(ResourceTimingInfo::adopt(std::move
(timingData))); | 411 std::unique_ptr<ResourceTimingInfo> info(ResourceTimingInfo::adopt(std::move
(timingData))); |
412 WorkerGlobalScopePerformance::performance(*m_workerGlobalScope)->addResource
Timing(*info); | 412 WorkerGlobalScopePerformance::performance(*m_workerGlobalScope)->addResource
Timing(*info); |
413 m_client->didReceiveResourceTiming(*info); | 413 m_client->didReceiveResourceTiming(*info); |
414 } | 414 } |
415 | 415 |
416 DEFINE_TRACE(WorkerThreadableLoader) | 416 DEFINE_TRACE(WorkerThreadableLoader) |
417 { | 417 { |
418 visitor->trace(m_workerGlobalScope); | 418 visitor->trace(m_workerGlobalScope); |
419 ThreadableLoader::trace(visitor); | 419 ThreadableLoader::trace(visitor); |
420 } | 420 } |
421 | 421 |
422 void WorkerThreadableLoader::MainThreadLoaderHolder::createAndStart( | 422 void WorkerThreadableLoader::Peer::createAndStart( |
423 WorkerThreadableLoader* workerLoader, | 423 WorkerThreadableLoader* workerLoader, |
424 PassRefPtr<WorkerLoaderProxy> passLoaderProxy, | 424 PassRefPtr<WorkerLoaderProxy> passLoaderProxy, |
425 WorkerThreadLifecycleContext* workerThreadLifecycleContext, | 425 WorkerThreadLifecycleContext* workerThreadLifecycleContext, |
426 std::unique_ptr<CrossThreadResourceRequestData> request, | 426 std::unique_ptr<CrossThreadResourceRequestData> request, |
427 const ThreadableLoaderOptions& options, | 427 const ThreadableLoaderOptions& options, |
428 const ResourceLoaderOptions& resourceLoaderOptions, | 428 const ResourceLoaderOptions& resourceLoaderOptions, |
429 PassRefPtr<WaitableEventWithTasks> eventWithTasks, | 429 PassRefPtr<WaitableEventWithTasks> eventWithTasks, |
430 ExecutionContext* executionContext) | 430 ExecutionContext* executionContext) |
431 { | 431 { |
432 DCHECK(isMainThread()); | 432 DCHECK(isMainThread()); |
433 TaskForwarder* forwarder; | 433 TaskForwarder* forwarder; |
434 RefPtr<WorkerLoaderProxy> loaderProxy = passLoaderProxy; | 434 RefPtr<WorkerLoaderProxy> loaderProxy = passLoaderProxy; |
435 if (eventWithTasks) | 435 if (eventWithTasks) |
436 forwarder = new SyncTaskForwarder(eventWithTasks); | 436 forwarder = new SyncTaskForwarder(eventWithTasks); |
437 else | 437 else |
438 forwarder = new AsyncTaskForwarder(loaderProxy); | 438 forwarder = new AsyncTaskForwarder(loaderProxy); |
439 | 439 |
440 MainThreadLoaderHolder* mainThreadLoaderHolder = new MainThreadLoaderHolder(
forwarder, workerThreadLifecycleContext); | 440 Peer* peer = new Peer(forwarder, workerThreadLifecycleContext); |
441 if (mainThreadLoaderHolder->wasContextDestroyedBeforeObserverCreation()) { | 441 if (peer->wasContextDestroyedBeforeObserverCreation()) { |
442 // The thread is already terminating. | 442 // The thread is already terminating. |
443 forwarder->abort(); | 443 forwarder->abort(); |
444 mainThreadLoaderHolder->m_forwarder = nullptr; | 444 peer->m_forwarder = nullptr; |
445 return; | 445 return; |
446 } | 446 } |
447 mainThreadLoaderHolder->m_workerLoader = workerLoader; | 447 peer->m_workerLoader = workerLoader; |
448 mainThreadLoaderHolder->start(*toDocument(executionContext), std::move(reque
st), options, resourceLoaderOptions); | 448 peer->start(*toDocument(executionContext), std::move(request), options, reso
urceLoaderOptions); |
449 forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreada
bleLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPer
sistent(mainThreadLoaderHolder))); | 449 forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreada
bleLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPer
sistent(peer))); |
450 } | 450 } |
451 | 451 |
452 WorkerThreadableLoader::MainThreadLoaderHolder::~MainThreadLoaderHolder() | 452 WorkerThreadableLoader::Peer::~Peer() |
453 { | 453 { |
454 DCHECK(isMainThread()); | 454 DCHECK(isMainThread()); |
455 DCHECK(!m_workerLoader); | 455 DCHECK(!m_workerLoader); |
456 } | 456 } |
457 | 457 |
458 void WorkerThreadableLoader::MainThreadLoaderHolder::overrideTimeout(unsigned lo
ng timeoutMilliseconds) | 458 void WorkerThreadableLoader::Peer::overrideTimeout(unsigned long timeoutMillisec
onds) |
459 { | 459 { |
460 DCHECK(isMainThread()); | 460 DCHECK(isMainThread()); |
461 if (!m_mainThreadLoader) | 461 if (!m_mainThreadLoader) |
462 return; | 462 return; |
463 m_mainThreadLoader->overrideTimeout(timeoutMilliseconds); | 463 m_mainThreadLoader->overrideTimeout(timeoutMilliseconds); |
464 } | 464 } |
465 | 465 |
466 void WorkerThreadableLoader::MainThreadLoaderHolder::cancel() | 466 void WorkerThreadableLoader::Peer::cancel() |
467 { | 467 { |
468 DCHECK(isMainThread()); | 468 DCHECK(isMainThread()); |
469 if (!m_mainThreadLoader) | 469 if (!m_mainThreadLoader) |
470 return; | 470 return; |
471 m_mainThreadLoader->cancel(); | 471 m_mainThreadLoader->cancel(); |
472 m_mainThreadLoader = nullptr; | 472 m_mainThreadLoader = nullptr; |
473 } | 473 } |
474 | 474 |
475 void WorkerThreadableLoader::MainThreadLoaderHolder::didSendData(unsigned long l
ong bytesSent, unsigned long long totalBytesToBeSent) | 475 void WorkerThreadableLoader::Peer::didSendData(unsigned long long bytesSent, uns
igned long long totalBytesToBeSent) |
476 { | 476 { |
477 DCHECK(isMainThread()); | 477 DCHECK(isMainThread()); |
478 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 478 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
479 if (!workerLoader || !m_forwarder) | 479 if (!workerLoader || !m_forwarder) |
480 return; | 480 return; |
481 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didSendData, workerLoader, bytesSent, totalBytesToBeSent)); | 481 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didSendData, workerLoader, bytesSent, totalBytesToBeSent)); |
482 } | 482 } |
483 | 483 |
484 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResponse(unsigned
long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsu
merHandle> handle) | 484 void WorkerThreadableLoader::Peer::didReceiveResponse(unsigned long identifier,
const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle) |
485 { | 485 { |
486 DCHECK(isMainThread()); | 486 DCHECK(isMainThread()); |
487 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 487 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
488 if (!workerLoader || !m_forwarder) | 488 if (!workerLoader || !m_forwarder) |
489 return; | 489 return; |
490 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveResponse, workerLoader, identifier, response, passed(std:
:move(handle)))); | 490 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveResponse, workerLoader, identifier, response, passed(std:
:move(handle)))); |
491 } | 491 } |
492 | 492 |
493 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveData(const char*
data, unsigned dataLength) | 493 void WorkerThreadableLoader::Peer::didReceiveData(const char* data, unsigned dat
aLength) |
494 { | 494 { |
495 DCHECK(isMainThread()); | 495 DCHECK(isMainThread()); |
496 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 496 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
497 if (!workerLoader || !m_forwarder) | 497 if (!workerLoader || !m_forwarder) |
498 return; | 498 return; |
499 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveData, workerLoader, passed(createVectorFromMemoryRegion(d
ata, dataLength)))); | 499 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveData, workerLoader, passed(createVectorFromMemoryRegion(d
ata, dataLength)))); |
500 } | 500 } |
501 | 501 |
502 void WorkerThreadableLoader::MainThreadLoaderHolder::didDownloadData(int dataLen
gth) | 502 void WorkerThreadableLoader::Peer::didDownloadData(int dataLength) |
503 { | 503 { |
504 DCHECK(isMainThread()); | 504 DCHECK(isMainThread()); |
505 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 505 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
506 if (!workerLoader || !m_forwarder) | 506 if (!workerLoader || !m_forwarder) |
507 return; | 507 return; |
508 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didDownloadData, workerLoader, dataLength)); | 508 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didDownloadData, workerLoader, dataLength)); |
509 } | 509 } |
510 | 510 |
511 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveCachedMetadata(co
nst char* data, int dataLength) | 511 void WorkerThreadableLoader::Peer::didReceiveCachedMetadata(const char* data, in
t dataLength) |
512 { | 512 { |
513 DCHECK(isMainThread()); | 513 DCHECK(isMainThread()); |
514 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 514 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
515 if (!workerLoader || !m_forwarder) | 515 if (!workerLoader || !m_forwarder) |
516 return; | 516 return; |
517 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveCachedMetadata, workerLoader, passed(createVectorFromMemo
ryRegion(data, dataLength)))); | 517 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveCachedMetadata, workerLoader, passed(createVectorFromMemo
ryRegion(data, dataLength)))); |
518 } | 518 } |
519 | 519 |
520 void WorkerThreadableLoader::MainThreadLoaderHolder::didFinishLoading(unsigned l
ong identifier, double finishTime) | 520 void WorkerThreadableLoader::Peer::didFinishLoading(unsigned long identifier, do
uble finishTime) |
521 { | 521 { |
522 DCHECK(isMainThread()); | 522 DCHECK(isMainThread()); |
523 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 523 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
524 if (!workerLoader || !m_forwarder) | 524 if (!workerLoader || !m_forwarder) |
525 return; | 525 return; |
526 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFinishLoading, workerLoader, identifier, finishTim
e)); | 526 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFinishLoading, workerLoader, identifier, finishTim
e)); |
527 m_forwarder = nullptr; | 527 m_forwarder = nullptr; |
528 } | 528 } |
529 | 529 |
530 void WorkerThreadableLoader::MainThreadLoaderHolder::didFail(const ResourceError
& error) | 530 void WorkerThreadableLoader::Peer::didFail(const ResourceError& error) |
531 { | 531 { |
532 DCHECK(isMainThread()); | 532 DCHECK(isMainThread()); |
533 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 533 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
534 if (!workerLoader || !m_forwarder) | 534 if (!workerLoader || !m_forwarder) |
535 return; | 535 return; |
536 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFail, workerLoader, error)); | 536 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFail, workerLoader, error)); |
537 m_forwarder = nullptr; | 537 m_forwarder = nullptr; |
538 } | 538 } |
539 | 539 |
540 void WorkerThreadableLoader::MainThreadLoaderHolder::didFailAccessControlCheck(c
onst ResourceError& error) | 540 void WorkerThreadableLoader::Peer::didFailAccessControlCheck(const ResourceError
& error) |
541 { | 541 { |
542 DCHECK(isMainThread()); | 542 DCHECK(isMainThread()); |
543 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 543 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
544 if (!workerLoader || !m_forwarder) | 544 if (!workerLoader || !m_forwarder) |
545 return; | 545 return; |
546 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFailAccessControlCheck, workerLoader, error)); | 546 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFailAccessControlCheck, workerLoader, error)); |
547 m_forwarder = nullptr; | 547 m_forwarder = nullptr; |
548 } | 548 } |
549 | 549 |
550 void WorkerThreadableLoader::MainThreadLoaderHolder::didFailRedirectCheck() | 550 void WorkerThreadableLoader::Peer::didFailRedirectCheck() |
551 { | 551 { |
552 DCHECK(isMainThread()); | 552 DCHECK(isMainThread()); |
553 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 553 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
554 if (!workerLoader || !m_forwarder) | 554 if (!workerLoader || !m_forwarder) |
555 return; | 555 return; |
556 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFailRedirectCheck, workerLoader)); | 556 m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTas
k(&WorkerThreadableLoader::didFailRedirectCheck, workerLoader)); |
557 m_forwarder = nullptr; | 557 m_forwarder = nullptr; |
558 } | 558 } |
559 | 559 |
560 void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResourceTiming(co
nst ResourceTimingInfo& info) | 560 void WorkerThreadableLoader::Peer::didReceiveResourceTiming(const ResourceTiming
Info& info) |
561 { | 561 { |
562 DCHECK(isMainThread()); | 562 DCHECK(isMainThread()); |
563 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); | 563 CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.
get(); |
564 if (!workerLoader || !m_forwarder) | 564 if (!workerLoader || !m_forwarder) |
565 return; | 565 return; |
566 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveResourceTiming, workerLoader, info)); | 566 m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThrea
dableLoader::didReceiveResourceTiming, workerLoader, info)); |
567 } | 567 } |
568 | 568 |
569 void WorkerThreadableLoader::MainThreadLoaderHolder::contextDestroyed() | 569 void WorkerThreadableLoader::Peer::contextDestroyed() |
570 { | 570 { |
571 DCHECK(isMainThread()); | 571 DCHECK(isMainThread()); |
572 if (m_forwarder) { | 572 if (m_forwarder) { |
573 m_forwarder->abort(); | 573 m_forwarder->abort(); |
574 m_forwarder = nullptr; | 574 m_forwarder = nullptr; |
575 } | 575 } |
576 m_workerLoader = nullptr; | 576 m_workerLoader = nullptr; |
577 cancel(); | 577 cancel(); |
578 } | 578 } |
579 | 579 |
580 DEFINE_TRACE(WorkerThreadableLoader::MainThreadLoaderHolder) | 580 DEFINE_TRACE(WorkerThreadableLoader::Peer) |
581 { | 581 { |
582 visitor->trace(m_forwarder); | 582 visitor->trace(m_forwarder); |
583 visitor->trace(m_mainThreadLoader); | 583 visitor->trace(m_mainThreadLoader); |
584 WorkerThreadLifecycleObserver::trace(visitor); | 584 WorkerThreadLifecycleObserver::trace(visitor); |
585 } | 585 } |
586 | 586 |
587 WorkerThreadableLoader::MainThreadLoaderHolder::MainThreadLoaderHolder(TaskForwa
rder* forwarder, WorkerThreadLifecycleContext* context) | 587 WorkerThreadableLoader::Peer::Peer(TaskForwarder* forwarder, WorkerThreadLifecyc
leContext* context) |
588 : WorkerThreadLifecycleObserver(context) | 588 : WorkerThreadLifecycleObserver(context) |
589 , m_forwarder(forwarder) | 589 , m_forwarder(forwarder) |
590 { | 590 { |
591 DCHECK(isMainThread()); | 591 DCHECK(isMainThread()); |
592 } | 592 } |
593 | 593 |
594 void WorkerThreadableLoader::MainThreadLoaderHolder::start( | 594 void WorkerThreadableLoader::Peer::start( |
595 Document& document, | 595 Document& document, |
596 std::unique_ptr<CrossThreadResourceRequestData> request, | 596 std::unique_ptr<CrossThreadResourceRequestData> request, |
597 const ThreadableLoaderOptions& options, | 597 const ThreadableLoaderOptions& options, |
598 const ResourceLoaderOptions& originalResourceLoaderOptions) | 598 const ResourceLoaderOptions& originalResourceLoaderOptions) |
599 { | 599 { |
600 DCHECK(isMainThread()); | 600 DCHECK(isMainThread()); |
601 ResourceLoaderOptions resourceLoaderOptions = originalResourceLoaderOptions; | 601 ResourceLoaderOptions resourceLoaderOptions = originalResourceLoaderOptions; |
602 resourceLoaderOptions.requestInitiatorContext = WorkerContext; | 602 resourceLoaderOptions.requestInitiatorContext = WorkerContext; |
603 m_mainThreadLoader = DocumentThreadableLoader::create(document, this, option
s, resourceLoaderOptions); | 603 m_mainThreadLoader = DocumentThreadableLoader::create(document, this, option
s, resourceLoaderOptions); |
604 m_mainThreadLoader->start(ResourceRequest(request.get())); | 604 m_mainThreadLoader->start(ResourceRequest(request.get())); |
605 } | 605 } |
606 | 606 |
607 } // namespace blink | 607 } // namespace blink |
OLD | NEW |