Clean up usesAsyncCallbacks handling in ResourceHandle
[WebKit-https.git] / Source / WebCore / loader / ResourceLoader.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
3  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "ResourceLoader.h"
32
33 #include "ApplicationCacheHost.h"
34 #include "AuthenticationChallenge.h"
35 #include "DiagnosticLoggingClient.h"
36 #include "DiagnosticLoggingKeys.h"
37 #include "DocumentLoader.h"
38 #include "Frame.h"
39 #include "FrameLoader.h"
40 #include "FrameLoaderClient.h"
41 #include "InspectorInstrumentation.h"
42 #include "LoaderStrategy.h"
43 #include "MainFrame.h"
44 #include "Page.h"
45 #include "PlatformStrategies.h"
46 #include "ProgressTracker.h"
47 #include "ResourceError.h"
48 #include "ResourceHandle.h"
49 #include "ResourceLoadScheduler.h"
50 #include "SecurityOrigin.h"
51 #include "Settings.h"
52 #include "SharedBuffer.h"
53 #include <wtf/Ref.h>
54
55 #if ENABLE(CONTENT_EXTENSIONS)
56 #include "ResourceLoadInfo.h"
57 #include "UserContentController.h"
58 #endif
59
60 namespace WebCore {
61
62 ResourceLoader::ResourceLoader(Frame* frame, ResourceLoaderOptions options)
63     : m_frame(frame)
64     , m_documentLoader(frame->loader().activeDocumentLoader())
65     , m_identifier(0)
66     , m_reachedTerminalState(false)
67     , m_notifiedLoadComplete(false)
68     , m_cancellationStatus(NotCancelled)
69     , m_defersLoading(frame->page()->defersLoading())
70     , m_options(options)
71     , m_isQuickLookResource(false)
72 #if ENABLE(CONTENT_EXTENSIONS)
73     , m_resourceType(ResourceType::Invalid)
74 #endif
75 {
76 }
77
78 ResourceLoader::~ResourceLoader()
79 {
80     ASSERT(m_reachedTerminalState);
81 }
82
83 void ResourceLoader::releaseResources()
84 {
85     ASSERT(!m_reachedTerminalState);
86     
87     // It's possible that when we release the handle, it will be
88     // deallocated and release the last reference to this object.
89     // We need to retain to avoid accessing the object after it
90     // has been deallocated and also to avoid reentering this method.
91     Ref<ResourceLoader> protect(*this);
92
93     m_frame = nullptr;
94     m_documentLoader = nullptr;
95     
96     // We need to set reachedTerminalState to true before we release
97     // the resources to prevent a double dealloc of WebView <rdar://problem/4372628>
98     m_reachedTerminalState = true;
99
100     platformStrategies()->loaderStrategy()->resourceLoadScheduler()->remove(this);
101     m_identifier = 0;
102
103     if (m_handle) {
104         // Clear out the ResourceHandle's client so that it doesn't try to call
105         // us back after we release it, unless it has been replaced by someone else.
106         if (m_handle->client() == this)
107             m_handle->clearClient();
108         m_handle = nullptr;
109     }
110
111     m_resourceData = nullptr;
112     m_deferredRequest = ResourceRequest();
113 }
114
115 bool ResourceLoader::init(const ResourceRequest& r)
116 {
117     ASSERT(!m_handle);
118     ASSERT(m_request.isNull());
119     ASSERT(m_deferredRequest.isNull());
120     ASSERT(!m_documentLoader->isSubstituteLoadPending(this));
121     
122     ResourceRequest clientRequest(r);
123
124 #if PLATFORM(IOS)
125     // If the documentLoader was detached while this ResourceLoader was waiting its turn
126     // in ResourceLoadScheduler queue, don't continue.
127     if (!m_documentLoader->frame()) {
128         cancel();
129         return false;
130     }
131 #endif
132     
133     m_defersLoading = m_frame->page()->defersLoading();
134     if (m_options.securityCheck() == DoSecurityCheck && !m_frame->document()->securityOrigin()->canDisplay(clientRequest.url())) {
135         FrameLoader::reportLocalLoadFailed(m_frame.get(), clientRequest.url().string());
136         releaseResources();
137         return false;
138     }
139     
140     // https://bugs.webkit.org/show_bug.cgi?id=26391
141     // The various plug-in implementations call directly to ResourceLoader::load() instead of piping requests
142     // through FrameLoader. As a result, they miss the FrameLoader::addExtraFieldsToRequest() step which sets
143     // up the 1st party for cookies URL. Until plug-in implementations can be reigned in to pipe through that
144     // method, we need to make sure there is always a 1st party for cookies set.
145     if (clientRequest.firstPartyForCookies().isNull()) {
146         if (Document* document = m_frame->document())
147             clientRequest.setFirstPartyForCookies(document->firstPartyForCookies());
148     }
149
150     willSendRequest(clientRequest, ResourceResponse());
151
152 #if PLATFORM(IOS)
153     // If this ResourceLoader was stopped as a result of willSendRequest, bail out.
154     if (m_reachedTerminalState)
155         return false;
156 #endif
157
158     if (clientRequest.isNull()) {
159         cancel();
160         return false;
161     }
162
163     m_originalRequest = m_request = clientRequest;
164     return true;
165 }
166
167 void ResourceLoader::deliverResponseAndData(const ResourceResponse& response, RefPtr<SharedBuffer>&& buffer)
168 {
169     Ref<ResourceLoader> protect(*this);
170
171     didReceiveResponse(response);
172     if (reachedTerminalState())
173         return;
174
175     if (buffer) {
176         unsigned size = buffer->size();
177         didReceiveBuffer(buffer.release(), size, DataPayloadWholeResource);
178         if (reachedTerminalState())
179             return;
180     }
181
182     didFinishLoading(0);
183 }
184
185 void ResourceLoader::start()
186 {
187     ASSERT(!m_handle);
188     ASSERT(!m_request.isNull());
189     ASSERT(m_deferredRequest.isNull());
190     ASSERT(frameLoader());
191
192 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
193     if (m_documentLoader->scheduleArchiveLoad(this, m_request))
194         return;
195 #endif
196
197     if (m_documentLoader->applicationCacheHost()->maybeLoadResource(this, m_request, m_request.url()))
198         return;
199
200     if (m_defersLoading) {
201         m_deferredRequest = m_request;
202         return;
203     }
204
205     if (!m_reachedTerminalState) {
206         FrameLoader& loader = m_request.url().protocolIsData() ? dataProtocolFrameLoader() : *frameLoader();
207         m_handle = ResourceHandle::create(loader.networkingContext(), m_request, this, m_defersLoading, m_options.sniffContent() == SniffContent);
208     }
209 }
210
211 void ResourceLoader::setDefersLoading(bool defers)
212 {
213     m_defersLoading = defers;
214     if (m_handle)
215         m_handle->setDefersLoading(defers);
216     if (!defers && !m_deferredRequest.isNull()) {
217         m_request = m_deferredRequest;
218         m_deferredRequest = ResourceRequest();
219         start();
220     }
221
222     platformStrategies()->loaderStrategy()->resourceLoadScheduler()->setDefersLoading(this, defers);
223 }
224
225 FrameLoader* ResourceLoader::frameLoader() const
226 {
227     if (!m_frame)
228         return nullptr;
229     return &m_frame->loader();
230 }
231
232 // This function should only be called when frameLoader() is non-null.
233 FrameLoader& ResourceLoader::dataProtocolFrameLoader() const
234 {
235     FrameLoader* loader = frameLoader();
236     ASSERT(loader);
237     FrameLoader* dataProtocolLoader = loader->client().dataProtocolLoader();
238     return *(dataProtocolLoader ? dataProtocolLoader : loader);
239 }
240
241 void ResourceLoader::setDataBufferingPolicy(DataBufferingPolicy dataBufferingPolicy)
242
243     m_options.setDataBufferingPolicy(dataBufferingPolicy); 
244
245     // Reset any already buffered data
246     if (dataBufferingPolicy == DoNotBufferData)
247         m_resourceData = nullptr;
248 }
249     
250 void ResourceLoader::willSwitchToSubstituteResource()
251 {
252     ASSERT(!m_documentLoader->isSubstituteLoadPending(this));
253     platformStrategies()->loaderStrategy()->resourceLoadScheduler()->remove(this);
254     if (m_handle)
255         m_handle->cancel();
256 }
257
258 void ResourceLoader::addDataOrBuffer(const char* data, unsigned length, SharedBuffer* buffer, DataPayloadType dataPayloadType)
259 {
260     if (m_options.dataBufferingPolicy() == DoNotBufferData)
261         return;
262
263     if (dataPayloadType == DataPayloadWholeResource) {
264         m_resourceData = buffer ? buffer : SharedBuffer::create(data, length);
265         return;
266     }
267         
268     if (!m_resourceData)
269         m_resourceData = buffer ? buffer : SharedBuffer::create(data, length);
270     else {
271         if (buffer)
272             m_resourceData->append(buffer);
273         else
274             m_resourceData->append(data, length);
275     }
276 }
277
278 void ResourceLoader::clearResourceData()
279 {
280     if (m_resourceData)
281         m_resourceData->clear();
282 }
283
284 bool ResourceLoader::isSubresourceLoader()
285 {
286     return false;
287 }
288
289 void ResourceLoader::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
290 {
291     // Protect this in this delegate method since the additional processing can do
292     // anything including possibly derefing this; one example of this is Radar 3266216.
293     Ref<ResourceLoader> protect(*this);
294
295     ASSERT(!m_reachedTerminalState);
296 #if ENABLE(CONTENT_EXTENSIONS)
297     ASSERT(m_resourceType != ResourceType::Invalid);
298 #endif
299
300     // We need a resource identifier for all requests, even if FrameLoader is never going to see it (such as with CORS preflight requests).
301     bool createdResourceIdentifier = false;
302     if (!m_identifier) {
303         m_identifier = m_frame->page()->progress().createUniqueIdentifier();
304         createdResourceIdentifier = true;
305     }
306
307 #if ENABLE(CONTENT_EXTENSIONS)
308     if (frameLoader()) {
309         Page* page = frameLoader()->frame().page();
310         if (page && m_documentLoader) {
311             auto* userContentController = page->userContentController();
312             if (userContentController)
313                 userContentController->processContentExtensionRulesForLoad(*page, request, m_resourceType, *m_documentLoader);
314         }
315     }
316 #endif
317     
318     if (isPlugInStreamLoader())
319         documentLoader()->addPlugInStreamLoader(this);
320
321     if (request.isNull()) {
322         didFail(cannotShowURLError());
323         return;
324     }
325
326     if (m_options.sendLoadCallbacks() == SendCallbacks) {
327         if (createdResourceIdentifier)
328             frameLoader()->notifier().assignIdentifierToInitialRequest(m_identifier, documentLoader(), request);
329
330 #if PLATFORM(IOS)
331         // If this ResourceLoader was stopped as a result of assignIdentifierToInitialRequest, bail out
332         if (m_reachedTerminalState)
333             return;
334 #endif
335
336         frameLoader()->notifier().willSendRequest(this, request, redirectResponse);
337     }
338     else
339         InspectorInstrumentation::willSendRequest(m_frame.get(), m_identifier, m_frame->loader().documentLoader(), request, redirectResponse);
340
341     if (!redirectResponse.isNull())
342         platformStrategies()->loaderStrategy()->resourceLoadScheduler()->crossOriginRedirectReceived(this, request.url());
343
344     m_request = request;
345
346     if (!redirectResponse.isNull() && !m_documentLoader->isCommitted())
347         frameLoader()->client().dispatchDidReceiveServerRedirectForProvisionalLoad();
348 }
349
350 void ResourceLoader::willSendRequest(ResourceRequest&& request, const ResourceResponse& redirectResponse, std::function<void(ResourceRequest&)> callback)
351 {
352     willSendRequest(request, redirectResponse);
353     callback(request);
354 }
355
356 void ResourceLoader::didSendData(unsigned long long, unsigned long long)
357 {
358 }
359
360 static void logResourceResponseSource(Frame* frame, ResourceResponse::Source source)
361 {
362     if (!frame)
363         return;
364
365     String sourceKey;
366     switch (source) {
367     case ResourceResponse::Source::Network:
368         sourceKey = DiagnosticLoggingKeys::networkKey();
369         break;
370     case ResourceResponse::Source::DiskCache:
371         sourceKey = DiagnosticLoggingKeys::diskCacheKey();
372         break;
373     case ResourceResponse::Source::DiskCacheAfterValidation:
374         sourceKey = DiagnosticLoggingKeys::diskCacheAfterValidationKey();
375         break;
376     case ResourceResponse::Source::Unknown:
377         return;
378     }
379
380     frame->mainFrame().diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceResponseKey(), DiagnosticLoggingKeys::sourceKey(), sourceKey, ShouldSample::Yes);
381 }
382
383 void ResourceLoader::didReceiveResponse(const ResourceResponse& r)
384 {
385     ASSERT(!m_reachedTerminalState);
386
387     // Protect this in this delegate method since the additional processing can do
388     // anything including possibly derefing this; one example of this is Radar 3266216.
389     Ref<ResourceLoader> protect(*this);
390
391     logResourceResponseSource(m_frame.get(), r.source());
392
393     m_response = r;
394
395     if (FormData* data = m_request.httpBody())
396         data->removeGeneratedFilesIfNeeded();
397         
398     if (m_options.sendLoadCallbacks() == SendCallbacks)
399         frameLoader()->notifier().didReceiveResponse(this, m_response);
400 }
401
402 void ResourceLoader::didReceiveData(const char* data, unsigned length, long long encodedDataLength, DataPayloadType dataPayloadType)
403 {
404     // The following assertions are not quite valid here, since a subclass
405     // might override didReceiveData in a way that invalidates them. This
406     // happens with the steps listed in 3266216
407     // ASSERT(con == connection);
408     // ASSERT(!m_reachedTerminalState);
409
410     didReceiveDataOrBuffer(data, length, 0, encodedDataLength, dataPayloadType);
411 }
412
413 void ResourceLoader::didReceiveBuffer(PassRefPtr<SharedBuffer> buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
414 {
415     didReceiveDataOrBuffer(0, 0, buffer, encodedDataLength, dataPayloadType);
416 }
417
418 void ResourceLoader::didReceiveDataOrBuffer(const char* data, unsigned length, PassRefPtr<SharedBuffer> prpBuffer, long long encodedDataLength, DataPayloadType dataPayloadType)
419 {
420     // This method should only get data+length *OR* a SharedBuffer.
421     ASSERT(!prpBuffer || (!data && !length));
422
423     // Protect this in this delegate method since the additional processing can do
424     // anything including possibly derefing this; one example of this is Radar 3266216.
425     Ref<ResourceLoader> protect(*this);
426     RefPtr<SharedBuffer> buffer = prpBuffer;
427
428     addDataOrBuffer(data, length, buffer.get(), dataPayloadType);
429     
430     // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
431     // However, with today's computers and networking speeds, this won't happen in practice.
432     // Could be an issue with a giant local file.
433     if (m_options.sendLoadCallbacks() == SendCallbacks && m_frame)
434         frameLoader()->notifier().didReceiveData(this, buffer ? buffer->data() : data, buffer ? buffer->size() : length, static_cast<int>(encodedDataLength));
435 }
436
437 void ResourceLoader::didFinishLoading(double finishTime)
438 {
439     didFinishLoadingOnePart(finishTime);
440
441     // If the load has been cancelled by a delegate in response to didFinishLoad(), do not release
442     // the resources a second time, they have been released by cancel.
443     if (wasCancelled())
444         return;
445     releaseResources();
446 }
447
448 void ResourceLoader::didFinishLoadingOnePart(double finishTime)
449 {
450     // If load has been cancelled after finishing (which could happen with a
451     // JavaScript that changes the window location), do nothing.
452     if (wasCancelled())
453         return;
454     ASSERT(!m_reachedTerminalState);
455
456     if (m_notifiedLoadComplete)
457         return;
458     m_notifiedLoadComplete = true;
459     if (m_options.sendLoadCallbacks() == SendCallbacks)
460         frameLoader()->notifier().didFinishLoad(this, finishTime);
461 }
462
463 void ResourceLoader::didFail(const ResourceError& error)
464 {
465     if (wasCancelled())
466         return;
467     ASSERT(!m_reachedTerminalState);
468
469     // Protect this in this delegate method since the additional processing can do
470     // anything including possibly derefing this; one example of this is Radar 3266216.
471     Ref<ResourceLoader> protect(*this);
472
473     cleanupForError(error);
474     releaseResources();
475 }
476
477 void ResourceLoader::cleanupForError(const ResourceError& error)
478 {
479     if (FormData* data = m_request.httpBody())
480         data->removeGeneratedFilesIfNeeded();
481
482     if (m_notifiedLoadComplete)
483         return;
484     m_notifiedLoadComplete = true;
485     if (m_options.sendLoadCallbacks() == SendCallbacks && m_identifier)
486         frameLoader()->notifier().didFailToLoad(this, error);
487 }
488
489 void ResourceLoader::cancel()
490 {
491     cancel(ResourceError());
492 }
493
494 void ResourceLoader::cancel(const ResourceError& error)
495 {
496     // If the load has already completed - succeeded, failed, or previously cancelled - do nothing.
497     if (m_reachedTerminalState)
498         return;
499        
500     ResourceError nonNullError = error.isNull() ? cancelledError() : error;
501     
502     // willCancel() and didFailToLoad() both call out to clients that might do 
503     // something causing the last reference to this object to go away.
504     Ref<ResourceLoader> protect(*this);
505     
506     // If we re-enter cancel() from inside willCancel(), we want to pick up from where we left 
507     // off without re-running willCancel()
508     if (m_cancellationStatus == NotCancelled) {
509         m_cancellationStatus = CalledWillCancel;
510         
511         willCancel(nonNullError);
512     }
513
514     // If we re-enter cancel() from inside didFailToLoad(), we want to pick up from where we 
515     // left off without redoing any of this work.
516     if (m_cancellationStatus == CalledWillCancel) {
517         m_cancellationStatus = Cancelled;
518
519         if (m_handle)
520             m_handle->clearAuthentication();
521
522         m_documentLoader->cancelPendingSubstituteLoad(this);
523         if (m_handle) {
524             m_handle->cancel();
525             m_handle = nullptr;
526         }
527         cleanupForError(nonNullError);
528     }
529
530     // If cancel() completed from within the call to willCancel() or didFailToLoad(),
531     // we don't want to redo didCancel() or releasesResources().
532     if (m_reachedTerminalState)
533         return;
534
535     didCancel(nonNullError);
536
537     if (m_cancellationStatus == FinishedCancel)
538         return;
539     m_cancellationStatus = FinishedCancel;
540
541     releaseResources();
542 }
543
544 ResourceError ResourceLoader::cancelledError()
545 {
546     return frameLoader()->cancelledError(m_request);
547 }
548
549 ResourceError ResourceLoader::blockedError()
550 {
551     return frameLoader()->client().blockedError(m_request);
552 }
553
554 ResourceError ResourceLoader::cannotShowURLError()
555 {
556     return frameLoader()->client().cannotShowURLError(m_request);
557 }
558
559 void ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
560 {
561     if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForRedirect(this, request, redirectResponse))
562         return;
563     willSendRequest(request, redirectResponse);
564 }
565
566 void ResourceLoader::didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
567 {
568     didSendData(bytesSent, totalBytesToBeSent);
569 }
570
571 void ResourceLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
572 {
573     if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForResponse(this, response))
574         return;
575     didReceiveResponse(response);
576 }
577
578 void ResourceLoader::didReceiveData(ResourceHandle*, const char* data, unsigned length, int encodedDataLength)
579 {
580     didReceiveData(data, length, encodedDataLength, DataPayloadBytes);
581 }
582
583 void ResourceLoader::didReceiveBuffer(ResourceHandle*, PassRefPtr<SharedBuffer> buffer, int encodedDataLength)
584 {
585     didReceiveBuffer(buffer, encodedDataLength, DataPayloadBytes);
586 }
587
588 void ResourceLoader::didFinishLoading(ResourceHandle*, double finishTime)
589 {
590     didFinishLoading(finishTime);
591 }
592
593 void ResourceLoader::didFail(ResourceHandle*, const ResourceError& error)
594 {
595     if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForError(this, error))
596         return;
597     didFail(error);
598 }
599
600 void ResourceLoader::wasBlocked(ResourceHandle*)
601 {
602     didFail(blockedError());
603 }
604
605 void ResourceLoader::cannotShowURL(ResourceHandle*)
606 {
607     didFail(cannotShowURLError());
608 }
609
610 bool ResourceLoader::shouldUseCredentialStorage()
611 {
612     if (m_options.allowCredentials() == DoNotAllowStoredCredentials)
613         return false;
614     
615     Ref<ResourceLoader> protect(*this);
616     return frameLoader()->client().shouldUseCredentialStorage(documentLoader(), identifier());
617 }
618
619 bool ResourceLoader::isAllowedToAskUserForCredentials() const
620 {
621     return m_options.clientCredentialPolicy() == AskClientForAllCredentials || (m_options.clientCredentialPolicy() == DoNotAskClientForCrossOriginCredentials && m_frame->document()->securityOrigin()->canRequest(originalRequest().url()));
622 }
623
624 void ResourceLoader::didReceiveAuthenticationChallenge(const AuthenticationChallenge& challenge)
625 {
626     ASSERT(m_handle->hasAuthenticationChallenge());
627
628     // Protect this in this delegate method since the additional processing can do
629     // anything including possibly derefing this; one example of this is Radar 3266216.
630     Ref<ResourceLoader> protect(*this);
631
632     if (m_options.allowCredentials() == AllowStoredCredentials) {
633         if (isAllowedToAskUserForCredentials()) {
634             frameLoader()->notifier().didReceiveAuthenticationChallenge(this, challenge);
635             return;
636         }
637     }
638     // Only these platforms provide a way to continue without credentials.
639     // If we can't continue with credentials, we need to cancel the load altogether.
640 #if PLATFORM(COCOA) || USE(CFNETWORK) || USE(CURL) || PLATFORM(GTK) || PLATFORM(EFL)
641     challenge.authenticationClient()->receivedRequestToContinueWithoutCredential(challenge);
642     ASSERT(!m_handle || !m_handle->hasAuthenticationChallenge());
643 #else
644     didFail(blockedError());
645 #endif
646 }
647
648 void ResourceLoader::didCancelAuthenticationChallenge(const AuthenticationChallenge& challenge)
649 {
650     // Protect this in this delegate method since the additional processing can do
651     // anything including possibly derefing this; one example of this is Radar 3266216.
652     Ref<ResourceLoader> protect(*this);
653     frameLoader()->notifier().didCancelAuthenticationChallenge(this, challenge);
654 }
655
656 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
657
658 bool ResourceLoader::canAuthenticateAgainstProtectionSpace(const ProtectionSpace& protectionSpace)
659 {
660     Ref<ResourceLoader> protect(*this);
661     return frameLoader()->client().canAuthenticateAgainstProtectionSpace(documentLoader(), identifier(), protectionSpace);
662 }
663
664 #endif
665     
666 #if PLATFORM(IOS)
667
668 RetainPtr<CFDictionaryRef> ResourceLoader::connectionProperties(ResourceHandle*)
669 {
670     return frameLoader()->connectionProperties(this);
671 }
672
673 #endif
674
675 void ResourceLoader::receivedCancellation(const AuthenticationChallenge&)
676 {
677     cancel();
678 }
679
680 #if PLATFORM(MAC)
681
682 void ResourceLoader::schedule(SchedulePair& pair)
683 {
684     if (m_handle)
685         m_handle->schedule(pair);
686 }
687
688 void ResourceLoader::unschedule(SchedulePair& pair)
689 {
690     if (m_handle)
691         m_handle->unschedule(pair);
692 }
693
694 #endif
695
696 #if USE(QUICK_LOOK)
697 void ResourceLoader::didCreateQuickLookHandle(QuickLookHandle& handle)
698 {
699     m_isQuickLookResource = true;
700     frameLoader()->client().didCreateQuickLookHandle(handle);
701 }
702 #endif
703
704 }