Async XMLHttpRequest should get access to AppCache resources stored as flat files
[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 = 0;
94     m_documentLoader = 0;
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->setClient(0);
108         m_handle = 0;
109     }
110
111     m_resourceData = 0;
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 0;
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 = 0;
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
297 #if ENABLE(CONTENT_EXTENSIONS)
298     ASSERT(m_resourceType != ResourceType::Invalid);
299
300     if (frameLoader() && frameLoader()->frame().page() && frameLoader()->frame().page()->userContentController() && m_documentLoader)
301         frameLoader()->frame().page()->userContentController()->processContentExtensionRulesForLoad(request, m_resourceType, *m_documentLoader);
302
303     if (request.isNull()) {
304         didFail(cannotShowURLError());
305         return;
306     }
307 #endif
308
309     // We need a resource identifier for all requests, even if FrameLoader is never going to see it (such as with CORS preflight requests).
310     bool createdResourceIdentifier = false;
311     if (!m_identifier) {
312         m_identifier = m_frame->page()->progress().createUniqueIdentifier();
313         createdResourceIdentifier = true;
314     }
315
316     if (m_options.sendLoadCallbacks() == SendCallbacks) {
317         if (createdResourceIdentifier)
318             frameLoader()->notifier().assignIdentifierToInitialRequest(m_identifier, documentLoader(), request);
319
320 #if PLATFORM(IOS)
321         // If this ResourceLoader was stopped as a result of assignIdentifierToInitialRequest, bail out
322         if (m_reachedTerminalState)
323             return;
324 #endif
325
326         frameLoader()->notifier().willSendRequest(this, request, redirectResponse);
327     }
328     else
329         InspectorInstrumentation::willSendRequest(m_frame.get(), m_identifier, m_frame->loader().documentLoader(), request, redirectResponse);
330
331     if (!redirectResponse.isNull())
332         platformStrategies()->loaderStrategy()->resourceLoadScheduler()->crossOriginRedirectReceived(this, request.url());
333
334     m_request = request;
335
336     if (!redirectResponse.isNull() && !m_documentLoader->isCommitted())
337         frameLoader()->client().dispatchDidReceiveServerRedirectForProvisionalLoad();
338 }
339
340 void ResourceLoader::willSendRequest(ResourceRequest&& request, const ResourceResponse& redirectResponse, std::function<void(ResourceRequest&)> callback)
341 {
342     willSendRequest(request, redirectResponse);
343     callback(request);
344 }
345
346 void ResourceLoader::didSendData(unsigned long long, unsigned long long)
347 {
348 }
349
350 static void logResourceResponseSource(Frame* frame, ResourceResponse::Source source)
351 {
352     if (!frame)
353         return;
354
355     String sourceKey;
356     switch (source) {
357     case ResourceResponse::Source::Network:
358         sourceKey = DiagnosticLoggingKeys::networkKey();
359         break;
360     case ResourceResponse::Source::DiskCache:
361         sourceKey = DiagnosticLoggingKeys::diskCacheKey();
362         break;
363     case ResourceResponse::Source::DiskCacheAfterValidation:
364         sourceKey = DiagnosticLoggingKeys::diskCacheAfterValidationKey();
365         break;
366     case ResourceResponse::Source::Unknown:
367         return;
368     }
369
370     frame->mainFrame().diagnosticLoggingClient().logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceResponseKey(), DiagnosticLoggingKeys::sourceKey(), sourceKey, ShouldSample::Yes);
371 }
372
373 void ResourceLoader::didReceiveResponse(const ResourceResponse& r)
374 {
375     ASSERT(!m_reachedTerminalState);
376
377     // Protect this in this delegate method since the additional processing can do
378     // anything including possibly derefing this; one example of this is Radar 3266216.
379     Ref<ResourceLoader> protect(*this);
380
381     logResourceResponseSource(m_frame.get(), r.source());
382
383     m_response = r;
384
385     if (FormData* data = m_request.httpBody())
386         data->removeGeneratedFilesIfNeeded();
387         
388     if (m_options.sendLoadCallbacks() == SendCallbacks)
389         frameLoader()->notifier().didReceiveResponse(this, m_response);
390 }
391
392 void ResourceLoader::didReceiveData(const char* data, unsigned length, long long encodedDataLength, DataPayloadType dataPayloadType)
393 {
394     // The following assertions are not quite valid here, since a subclass
395     // might override didReceiveData in a way that invalidates them. This
396     // happens with the steps listed in 3266216
397     // ASSERT(con == connection);
398     // ASSERT(!m_reachedTerminalState);
399
400     didReceiveDataOrBuffer(data, length, 0, encodedDataLength, dataPayloadType);
401 }
402
403 void ResourceLoader::didReceiveBuffer(PassRefPtr<SharedBuffer> buffer, long long encodedDataLength, DataPayloadType dataPayloadType)
404 {
405     didReceiveDataOrBuffer(0, 0, buffer, encodedDataLength, dataPayloadType);
406 }
407
408 void ResourceLoader::didReceiveDataOrBuffer(const char* data, unsigned length, PassRefPtr<SharedBuffer> prpBuffer, long long encodedDataLength, DataPayloadType dataPayloadType)
409 {
410     // This method should only get data+length *OR* a SharedBuffer.
411     ASSERT(!prpBuffer || (!data && !length));
412
413     // Protect this in this delegate method since the additional processing can do
414     // anything including possibly derefing this; one example of this is Radar 3266216.
415     Ref<ResourceLoader> protect(*this);
416     RefPtr<SharedBuffer> buffer = prpBuffer;
417
418     addDataOrBuffer(data, length, buffer.get(), dataPayloadType);
419     
420     // FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
421     // However, with today's computers and networking speeds, this won't happen in practice.
422     // Could be an issue with a giant local file.
423     if (m_options.sendLoadCallbacks() == SendCallbacks && m_frame)
424         frameLoader()->notifier().didReceiveData(this, buffer ? buffer->data() : data, buffer ? buffer->size() : length, static_cast<int>(encodedDataLength));
425 }
426
427 void ResourceLoader::didFinishLoading(double finishTime)
428 {
429     didFinishLoadingOnePart(finishTime);
430
431     // If the load has been cancelled by a delegate in response to didFinishLoad(), do not release
432     // the resources a second time, they have been released by cancel.
433     if (wasCancelled())
434         return;
435     releaseResources();
436 }
437
438 void ResourceLoader::didFinishLoadingOnePart(double finishTime)
439 {
440     // If load has been cancelled after finishing (which could happen with a
441     // JavaScript that changes the window location), do nothing.
442     if (wasCancelled())
443         return;
444     ASSERT(!m_reachedTerminalState);
445
446     if (m_notifiedLoadComplete)
447         return;
448     m_notifiedLoadComplete = true;
449     if (m_options.sendLoadCallbacks() == SendCallbacks)
450         frameLoader()->notifier().didFinishLoad(this, finishTime);
451 }
452
453 void ResourceLoader::didFail(const ResourceError& error)
454 {
455     if (wasCancelled())
456         return;
457     ASSERT(!m_reachedTerminalState);
458
459     // Protect this in this delegate method since the additional processing can do
460     // anything including possibly derefing this; one example of this is Radar 3266216.
461     Ref<ResourceLoader> protect(*this);
462
463     cleanupForError(error);
464     releaseResources();
465 }
466
467 void ResourceLoader::cleanupForError(const ResourceError& error)
468 {
469     if (FormData* data = m_request.httpBody())
470         data->removeGeneratedFilesIfNeeded();
471
472     if (m_notifiedLoadComplete)
473         return;
474     m_notifiedLoadComplete = true;
475     if (m_options.sendLoadCallbacks() == SendCallbacks && m_identifier)
476         frameLoader()->notifier().didFailToLoad(this, error);
477 }
478
479 void ResourceLoader::cancel()
480 {
481     cancel(ResourceError());
482 }
483
484 void ResourceLoader::cancel(const ResourceError& error)
485 {
486     // If the load has already completed - succeeded, failed, or previously cancelled - do nothing.
487     if (m_reachedTerminalState)
488         return;
489        
490     ResourceError nonNullError = error.isNull() ? cancelledError() : error;
491     
492     // willCancel() and didFailToLoad() both call out to clients that might do 
493     // something causing the last reference to this object to go away.
494     Ref<ResourceLoader> protect(*this);
495     
496     // If we re-enter cancel() from inside willCancel(), we want to pick up from where we left 
497     // off without re-running willCancel()
498     if (m_cancellationStatus == NotCancelled) {
499         m_cancellationStatus = CalledWillCancel;
500         
501         willCancel(nonNullError);
502     }
503
504     // If we re-enter cancel() from inside didFailToLoad(), we want to pick up from where we 
505     // left off without redoing any of this work.
506     if (m_cancellationStatus == CalledWillCancel) {
507         m_cancellationStatus = Cancelled;
508
509         if (m_handle)
510             m_handle->clearAuthentication();
511
512         m_documentLoader->cancelPendingSubstituteLoad(this);
513         if (m_handle) {
514             m_handle->cancel();
515             m_handle = 0;
516         }
517         cleanupForError(nonNullError);
518     }
519
520     // If cancel() completed from within the call to willCancel() or didFailToLoad(),
521     // we don't want to redo didCancel() or releasesResources().
522     if (m_reachedTerminalState)
523         return;
524
525     didCancel(nonNullError);
526
527     if (m_cancellationStatus == FinishedCancel)
528         return;
529     m_cancellationStatus = FinishedCancel;
530
531     releaseResources();
532 }
533
534 ResourceError ResourceLoader::cancelledError()
535 {
536     return frameLoader()->cancelledError(m_request);
537 }
538
539 ResourceError ResourceLoader::blockedError()
540 {
541     return frameLoader()->client().blockedError(m_request);
542 }
543
544 ResourceError ResourceLoader::cannotShowURLError()
545 {
546     return frameLoader()->client().cannotShowURLError(m_request);
547 }
548
549 void ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
550 {
551     if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForRedirect(this, request, redirectResponse))
552         return;
553     willSendRequest(request, redirectResponse);
554 }
555
556 void ResourceLoader::didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
557 {
558     didSendData(bytesSent, totalBytesToBeSent);
559 }
560
561 void ResourceLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
562 {
563     if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForResponse(this, response))
564         return;
565     didReceiveResponse(response);
566 }
567
568 void ResourceLoader::didReceiveData(ResourceHandle*, const char* data, unsigned length, int encodedDataLength)
569 {
570     didReceiveData(data, length, encodedDataLength, DataPayloadBytes);
571 }
572
573 void ResourceLoader::didReceiveBuffer(ResourceHandle*, PassRefPtr<SharedBuffer> buffer, int encodedDataLength)
574 {
575     didReceiveBuffer(buffer, encodedDataLength, DataPayloadBytes);
576 }
577
578 void ResourceLoader::didFinishLoading(ResourceHandle*, double finishTime)
579 {
580     didFinishLoading(finishTime);
581 }
582
583 void ResourceLoader::didFail(ResourceHandle*, const ResourceError& error)
584 {
585     if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForError(this, error))
586         return;
587     didFail(error);
588 }
589
590 void ResourceLoader::wasBlocked(ResourceHandle*)
591 {
592     didFail(blockedError());
593 }
594
595 void ResourceLoader::cannotShowURL(ResourceHandle*)
596 {
597     didFail(cannotShowURLError());
598 }
599
600 bool ResourceLoader::shouldUseCredentialStorage()
601 {
602     if (m_options.allowCredentials() == DoNotAllowStoredCredentials)
603         return false;
604     
605     Ref<ResourceLoader> protect(*this);
606     return frameLoader()->client().shouldUseCredentialStorage(documentLoader(), identifier());
607 }
608
609 bool ResourceLoader::isAllowedToAskUserForCredentials() const
610 {
611     return m_options.clientCredentialPolicy() == AskClientForAllCredentials || (m_options.clientCredentialPolicy() == DoNotAskClientForCrossOriginCredentials && m_frame->document()->securityOrigin()->canRequest(originalRequest().url()));
612 }
613
614 void ResourceLoader::didReceiveAuthenticationChallenge(const AuthenticationChallenge& challenge)
615 {
616     ASSERT(m_handle->hasAuthenticationChallenge());
617
618     // Protect this in this delegate method since the additional processing can do
619     // anything including possibly derefing this; one example of this is Radar 3266216.
620     Ref<ResourceLoader> protect(*this);
621
622     if (m_options.allowCredentials() == AllowStoredCredentials) {
623         if (isAllowedToAskUserForCredentials()) {
624             frameLoader()->notifier().didReceiveAuthenticationChallenge(this, challenge);
625             return;
626         }
627     }
628     // Only these platforms provide a way to continue without credentials.
629     // If we can't continue with credentials, we need to cancel the load altogether.
630 #if PLATFORM(COCOA) || USE(CFNETWORK) || USE(CURL) || PLATFORM(GTK) || PLATFORM(EFL)
631     challenge.authenticationClient()->receivedRequestToContinueWithoutCredential(challenge);
632     ASSERT(!m_handle || !m_handle->hasAuthenticationChallenge());
633 #else
634     didFail(blockedError());
635 #endif
636 }
637
638 void ResourceLoader::didCancelAuthenticationChallenge(const AuthenticationChallenge& challenge)
639 {
640     // Protect this in this delegate method since the additional processing can do
641     // anything including possibly derefing this; one example of this is Radar 3266216.
642     Ref<ResourceLoader> protect(*this);
643     frameLoader()->notifier().didCancelAuthenticationChallenge(this, challenge);
644 }
645
646 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
647
648 bool ResourceLoader::canAuthenticateAgainstProtectionSpace(const ProtectionSpace& protectionSpace)
649 {
650     Ref<ResourceLoader> protect(*this);
651     return frameLoader()->client().canAuthenticateAgainstProtectionSpace(documentLoader(), identifier(), protectionSpace);
652 }
653
654 #endif
655     
656 #if PLATFORM(IOS)
657
658 RetainPtr<CFDictionaryRef> ResourceLoader::connectionProperties(ResourceHandle*)
659 {
660     return frameLoader()->connectionProperties(this);
661 }
662
663 #endif
664
665 void ResourceLoader::receivedCancellation(const AuthenticationChallenge&)
666 {
667     cancel();
668 }
669
670 #if PLATFORM(MAC)
671
672 void ResourceLoader::schedule(SchedulePair& pair)
673 {
674     if (m_handle)
675         m_handle->schedule(pair);
676 }
677
678 void ResourceLoader::unschedule(SchedulePair& pair)
679 {
680     if (m_handle)
681         m_handle->unschedule(pair);
682 }
683
684 #endif
685
686 #if USE(QUICK_LOOK)
687 void ResourceLoader::didCreateQuickLookHandle(QuickLookHandle& handle)
688 {
689     m_isQuickLookResource = true;
690     frameLoader()->client().didCreateQuickLookHandle(handle);
691 }
692 #endif
693
694 }