00f6dca355e3d19c4ae8a6a8b666fc7c3b59cf4d
[WebKit.git] / Source / WebCore / loader / DocumentLoader.h
1 /*
2  * Copyright (C) 2006-2017 Apple Inc. All rights reserved.
3  * Copyright (C) 2011 Google Inc. All rights reserved.
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 #pragma once
31
32 #include "CachedRawResourceClient.h"
33 #include "CachedResourceHandle.h"
34 #include "ContentSecurityPolicyClient.h"
35 #include "DocumentWriter.h"
36 #include "FrameDestructionObserver.h"
37 #include "LinkIcon.h"
38 #include "LoadTiming.h"
39 #include "NavigationAction.h"
40 #include "ResourceError.h"
41 #include "ResourceLoaderOptions.h"
42 #include "ResourceRequest.h"
43 #include "ResourceResponse.h"
44 #include "ServiceWorkerRegistrationData.h"
45 #include "StringWithDirection.h"
46 #include "StyleSheetContents.h"
47 #include "SubstituteData.h"
48 #include "Timer.h"
49 #include <wtf/HashSet.h>
50 #include <wtf/OptionSet.h>
51 #include <wtf/RefPtr.h>
52 #include <wtf/Vector.h>
53
54 #if ENABLE(APPLICATION_MANIFEST)
55 #include "ApplicationManifest.h"
56 #endif
57
58 #if HAVE(RUNLOOP_TIMER)
59 #include <wtf/RunLoopTimer.h>
60 #endif
61
62 #if PLATFORM(COCOA)
63 #include <wtf/SchedulePair.h>
64 #endif
65
66 namespace WebCore {
67
68 class ApplicationCacheHost;
69 class ApplicationManifestLoader;
70 class Archive;
71 class ArchiveResource;
72 class ArchiveResourceCollection;
73 class CachedRawResource;
74 class CachedResourceLoader;
75 class ContentFilter;
76 class FormState;
77 class Frame;
78 class FrameLoader;
79 class HTTPHeaderField;
80 class IconLoader;
81 class Page;
82 class PreviewConverter;
83 class ResourceLoader;
84 class SharedBuffer;
85 class SubresourceLoader;
86 class SubstituteResource;
87
88 enum class ShouldContinue;
89
90 using ResourceLoaderMap = HashMap<unsigned long, RefPtr<ResourceLoader>>;
91
92 enum class AutoplayPolicy {
93     Default, // Uses policies specified in document settings.
94     Allow,
95     AllowWithoutSound,
96     Deny,
97 };
98
99 enum class AutoplayQuirk {
100     SynthesizedPauseEvents = 1 << 0,
101     InheritedUserGestures = 1 << 1,
102     ArbitraryUserGestures = 1 << 2,
103 };
104
105 enum class PopUpPolicy {
106     Default, // Uses policies specified in frame settings.
107     Allow,
108     Block,
109 };
110
111 class DocumentLoader
112     : public RefCounted<DocumentLoader>
113     , public FrameDestructionObserver
114     , public ContentSecurityPolicyClient
115     , private CachedRawResourceClient {
116     WTF_MAKE_FAST_ALLOCATED;
117     friend class ContentFilter;
118 public:
119     static Ref<DocumentLoader> create(const ResourceRequest& request, const SubstituteData& data)
120     {
121         return adoptRef(*new DocumentLoader(request, data));
122     }
123     WEBCORE_EXPORT virtual ~DocumentLoader();
124
125     void attachToFrame(Frame&);
126
127     WEBCORE_EXPORT virtual void detachFromFrame();
128
129     WEBCORE_EXPORT FrameLoader* frameLoader() const;
130     WEBCORE_EXPORT SubresourceLoader* mainResourceLoader() const;
131     WEBCORE_EXPORT RefPtr<SharedBuffer> mainResourceData() const;
132     
133     DocumentWriter& writer() const { return m_writer; }
134
135     const ResourceRequest& originalRequest() const;
136     const ResourceRequest& originalRequestCopy() const;
137
138     const ResourceRequest& request() const;
139     ResourceRequest& request();
140
141     CachedResourceLoader& cachedResourceLoader() { return m_cachedResourceLoader; }
142
143     const SubstituteData& substituteData() const { return m_substituteData; }
144
145     const URL& url() const;
146     const URL& unreachableURL() const;
147
148     const URL& originalURL() const;
149     const URL& responseURL() const;
150     const String& responseMIMEType() const;
151 #if PLATFORM(IOS)
152     // FIXME: This method seems to violate the encapsulation of this class.
153     WEBCORE_EXPORT void setResponseMIMEType(const String&);
154 #endif
155     const String& currentContentType() const;
156     void replaceRequestURLForSameDocumentNavigation(const URL&);
157     bool isStopping() const { return m_isStopping; }
158     void stopLoading();
159     void setCommitted(bool committed) { m_committed = committed; }
160     bool isCommitted() const { return m_committed; }
161     WEBCORE_EXPORT bool isLoading() const;
162
163     const ResourceError& mainDocumentError() const { return m_mainDocumentError; }
164
165     const ResourceResponse& response() const { return m_response; }
166
167     // FIXME: This method seems to violate the encapsulation of this class.
168     void setResponse(const ResourceResponse& response) { m_response = response; }
169
170     bool isClientRedirect() const { return m_isClientRedirect; }
171     void setIsClientRedirect(bool isClientRedirect) { m_isClientRedirect = isClientRedirect; }
172     void dispatchOnloadEvents();
173     bool wasOnloadDispatched() { return m_wasOnloadDispatched; }
174     WEBCORE_EXPORT bool isLoadingInAPISense() const;
175     WEBCORE_EXPORT void setTitle(const StringWithDirection&);
176     const String& overrideEncoding() const { return m_overrideEncoding; }
177
178 #if PLATFORM(COCOA)
179     void schedule(SchedulePair&);
180     void unschedule(SchedulePair&);
181 #endif
182
183 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
184     void setArchive(Ref<Archive>&&);
185     WEBCORE_EXPORT void addAllArchiveResources(Archive&);
186     WEBCORE_EXPORT void addArchiveResource(Ref<ArchiveResource>&&);
187     RefPtr<Archive> popArchiveForSubframe(const String& frameName, const URL&);
188     WEBCORE_EXPORT SharedBuffer* parsedArchiveData() const;
189
190     WEBCORE_EXPORT bool scheduleArchiveLoad(ResourceLoader&, const ResourceRequest&);
191 #endif
192
193     void scheduleSubstituteResourceLoad(ResourceLoader&, SubstituteResource&);
194     void scheduleCannotShowURLError(ResourceLoader&);
195
196     // Return the ArchiveResource for the URL only when loading an Archive
197     WEBCORE_EXPORT ArchiveResource* archiveResourceForURL(const URL&) const;
198
199     WEBCORE_EXPORT RefPtr<ArchiveResource> mainResource() const;
200
201     // Return an ArchiveResource for the URL, either creating from live data or
202     // pulling from the ArchiveResourceCollection.
203     WEBCORE_EXPORT RefPtr<ArchiveResource> subresource(const URL&) const;
204
205     WEBCORE_EXPORT Vector<Ref<ArchiveResource>> subresources() const;
206
207 #ifndef NDEBUG
208     bool isSubstituteLoadPending(ResourceLoader*) const;
209 #endif
210     void cancelPendingSubstituteLoad(ResourceLoader*);   
211     
212     void addResponse(const ResourceResponse&);
213     const Vector<ResourceResponse>& responses() const { return m_responses; }
214
215     const NavigationAction& triggeringAction() const { return m_triggeringAction; }
216     void setTriggeringAction(const NavigationAction&);
217     void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
218     void setLastCheckedRequest(ResourceRequest&& request) { m_lastCheckedRequest = WTFMove(request); }
219     const ResourceRequest& lastCheckedRequest()  { return m_lastCheckedRequest; }
220
221     void stopRecordingResponses();
222     const StringWithDirection& title() const { return m_pageTitle; }
223
224     WEBCORE_EXPORT URL urlForHistory() const;
225     WEBCORE_EXPORT bool urlForHistoryReflectsFailure() const;
226
227     // These accessors accommodate WebCore's somewhat fickle custom of creating history
228     // items for redirects, but only sometimes. For "source" and "destination",
229     // these accessors return the URL that would have been used if a history
230     // item were created. This allows WebKit to link history items reflecting
231     // redirects into a chain from start to finish.
232     String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; } // null if no client redirect occurred.
233     String clientRedirectDestinationForHistory() const { return urlForHistory(); }
234     void setClientRedirectSourceForHistory(const String& clientRedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientRedirectSourceForHistory; }
235     
236     String serverRedirectSourceForHistory() const { return (urlForHistory() == url() || url() == blankURL()) ? String() : urlForHistory().string(); } // null if no server redirect occurred.
237     String serverRedirectDestinationForHistory() const { return url(); }
238
239     bool didCreateGlobalHistoryEntry() const { return m_didCreateGlobalHistoryEntry; }
240     void setDidCreateGlobalHistoryEntry(bool didCreateGlobalHistoryEntry) { m_didCreateGlobalHistoryEntry = didCreateGlobalHistoryEntry; }
241
242     bool subresourceLoadersArePageCacheAcceptable() const { return m_subresourceLoadersArePageCacheAcceptable; }
243
244     void setDefersLoading(bool);
245     void setMainResourceDataBufferingPolicy(DataBufferingPolicy);
246
247     void startLoadingMainResource(ShouldContinue);
248     WEBCORE_EXPORT void cancelMainResourceLoad(const ResourceError&);
249     void willContinueMainResourceLoadAfterRedirect(const ResourceRequest&);
250
251     bool isLoadingMainResource() const { return m_loadingMainResource; }
252     bool isLoadingMultipartContent() const { return m_isLoadingMultipartContent; }
253
254     void stopLoadingPlugIns();
255     void stopLoadingSubresources();
256
257     bool userContentExtensionsEnabled() const { return m_userContentExtensionsEnabled; }
258     void setUserContentExtensionsEnabled(bool enabled) { m_userContentExtensionsEnabled = enabled; }
259
260     AutoplayPolicy autoplayPolicy() const { return m_autoplayPolicy; }
261     void setAutoplayPolicy(AutoplayPolicy policy) { m_autoplayPolicy = policy; }
262
263     OptionSet<AutoplayQuirk> allowedAutoplayQuirks() const { return m_allowedAutoplayQuirks; }
264     void setAllowedAutoplayQuirks(OptionSet<AutoplayQuirk> allowedQuirks) { m_allowedAutoplayQuirks = allowedQuirks; }
265
266     PopUpPolicy popUpPolicy() const { return m_popUpPolicy; }
267     void setPopUpPolicy(PopUpPolicy popUpPolicy) { m_popUpPolicy = popUpPolicy; }
268
269     void addSubresourceLoader(ResourceLoader*);
270     void removeSubresourceLoader(ResourceLoader*);
271     void addPlugInStreamLoader(ResourceLoader&);
272     void removePlugInStreamLoader(ResourceLoader&);
273
274     void subresourceLoaderFinishedLoadingOnePart(ResourceLoader*);
275
276     void setDeferMainResourceDataLoad(bool defer) { m_deferMainResourceDataLoad = defer; }
277     
278     void didTellClientAboutLoad(const String& url);
279     bool haveToldClientAboutLoad(const String& url) { return m_resourcesClientKnowsAbout.contains(url); }
280     void recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest&);
281     void takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loads);
282
283     LoadTiming& timing() { return m_loadTiming; }
284     void resetTiming() { m_loadTiming = LoadTiming(); }
285
286     // The WebKit layer calls this function when it's ready for the data to actually be added to the document.
287     WEBCORE_EXPORT void commitData(const char* bytes, size_t length);
288
289     ApplicationCacheHost& applicationCacheHost() const;
290     ApplicationCacheHost* applicationCacheHostUnlessBeingDestroyed() const;
291
292     void checkLoadComplete();
293
294     // The URL of the document resulting from this DocumentLoader.
295     URL documentURL() const;
296
297 #if USE(QUICK_LOOK)
298     void setPreviewConverter(std::unique_ptr<PreviewConverter>&&);
299     PreviewConverter* previewConverter() const;
300 #endif
301
302 #if ENABLE(CONTENT_EXTENSIONS)
303     void addPendingContentExtensionSheet(const String& identifier, StyleSheetContents&);
304     void addPendingContentExtensionDisplayNoneSelector(const String& identifier, const String& selector, uint32_t selectorID);
305 #endif
306
307     void setShouldOpenExternalURLsPolicy(ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicy) { m_shouldOpenExternalURLsPolicy = shouldOpenExternalURLsPolicy; }
308     ShouldOpenExternalURLsPolicy shouldOpenExternalURLsPolicyToPropagate() const;
309
310 #if ENABLE(CONTENT_FILTERING)
311     ContentFilter* contentFilter() const;
312 #endif
313
314     bool isAlwaysOnLoggingAllowed() const;
315
316     void startIconLoading();
317     WEBCORE_EXPORT void didGetLoadDecisionForIcon(bool decision, uint64_t loadIdentifier, uint64_t newCallbackID);
318     void finishedLoadingIcon(IconLoader&, SharedBuffer*);
319
320     const Vector<LinkIcon>& linkIcons() const { return m_linkIcons; }
321
322 #if ENABLE(APPLICATION_MANIFEST)
323     WEBCORE_EXPORT uint64_t loadApplicationManifest();
324     void finishedLoadingApplicationManifest(ApplicationManifestLoader&);
325 #endif
326
327     WEBCORE_EXPORT void setCustomHeaderFields(Vector<HTTPHeaderField>&& fields);
328     const Vector<HTTPHeaderField>& customHeaderFields() { return m_customHeaderFields; }
329     
330 protected:
331     WEBCORE_EXPORT DocumentLoader(const ResourceRequest&, const SubstituteData&);
332
333     WEBCORE_EXPORT virtual void attachToFrame();
334
335     bool m_deferMainResourceDataLoad { true };
336
337 private:
338     Document* document() const;
339
340 #if ENABLE(SERVICE_WORKER)
341     void matchRegistration(const URL&, CompletionHandler<void(std::optional<ServiceWorkerRegistrationData>&&)>&&);
342 #endif
343
344     void loadMainResource(ResourceRequest&&);
345
346     void setRequest(const ResourceRequest&);
347
348     void commitIfReady();
349     void setMainDocumentError(const ResourceError&);
350     void commitLoad(const char*, int);
351     void clearMainResourceLoader();
352
353     void setupForReplace();
354     void maybeFinishLoadingMultipartContent();
355     
356     bool maybeCreateArchive();
357 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
358     void clearArchiveResources();
359 #endif
360
361     void willSendRequest(ResourceRequest&&, const ResourceResponse&, ShouldContinue, CompletionHandler<void(ResourceRequest&&)>&&);
362     void finishedLoading();
363     void mainReceivedError(const ResourceError&);
364     WEBCORE_EXPORT void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
365     WEBCORE_EXPORT void responseReceived(CachedResource&, const ResourceResponse&, CompletionHandler<void()>&&) override;
366     WEBCORE_EXPORT void dataReceived(CachedResource&, const char* data, int length) override;
367     WEBCORE_EXPORT void notifyFinished(CachedResource&) override;
368
369     void responseReceived(const ResourceResponse&, CompletionHandler<void()>&&);
370     void dataReceived(const char* data, int length);
371
372     bool maybeLoadEmpty();
373
374     bool isMultipartReplacingLoad() const;
375     bool isPostOrRedirectAfterPost(const ResourceRequest&, const ResourceResponse&);
376
377     bool tryLoadingRequestFromApplicationCache();
378     bool tryLoadingRedirectRequestFromApplicationCache(const ResourceRequest&);
379 #if ENABLE(SERVICE_WORKER)
380     void restartLoadingDueToServiceWorkerRegistrationChange(ResourceRequest&&, std::optional<ServiceWorkerRegistrationData>&&);
381 #endif
382     void continueAfterContentPolicy(PolicyAction);
383
384     void stopLoadingForPolicyChange();
385     ResourceError interruptedForPolicyChangeError() const;
386
387     void stopLoadingAfterXFrameOptionsOrContentSecurityPolicyDenied(unsigned long identifier, const ResourceResponse&);
388
389 #if HAVE(RUNLOOP_TIMER)
390     typedef RunLoopTimer<DocumentLoader> DocumentLoaderTimer;
391 #else
392     typedef Timer DocumentLoaderTimer;
393 #endif
394     void handleSubstituteDataLoadSoon();
395     void handleSubstituteDataLoadNow();
396     void startDataLoadTimer();
397
398     void deliverSubstituteResourcesAfterDelay();
399     void substituteResourceDeliveryTimerFired();
400
401     void clearMainResource();
402
403     void cancelPolicyCheckIfNeeded();
404     void becomeMainResourceClient();
405
406     void notifyFinishedLoadingIcon(uint64_t callbackIdentifier, SharedBuffer*);
407
408 #if ENABLE(APPLICATION_MANIFEST)
409     void notifyFinishedLoadingApplicationManifest(uint64_t callbackIdentifier, std::optional<ApplicationManifest>);
410 #endif
411
412     // ContentSecurityPolicyClient
413     WEBCORE_EXPORT void addConsoleMessage(MessageSource, MessageLevel, const String&, unsigned long requestIdentifier) final;
414     WEBCORE_EXPORT void sendCSPViolationReport(URL&&, Ref<FormData>&&) final;
415     WEBCORE_EXPORT void dispatchSecurityPolicyViolationEvent(Ref<SecurityPolicyViolationEvent>&&) final;
416
417     Ref<CachedResourceLoader> m_cachedResourceLoader;
418
419     CachedResourceHandle<CachedRawResource> m_mainResource;
420     ResourceLoaderMap m_subresourceLoaders;
421     ResourceLoaderMap m_multipartSubresourceLoaders;
422     ResourceLoaderMap m_plugInStreamLoaders;
423     
424     mutable DocumentWriter m_writer;
425
426     // A reference to actual request used to create the data source.
427     // This should only be used by the resourceLoadDelegate's
428     // identifierForInitialRequest:fromDatasource: method. It is
429     // not guaranteed to remain unchanged, as requests are mutable.
430     ResourceRequest m_originalRequest;   
431
432     SubstituteData m_substituteData;
433
434     // A copy of the original request used to create the data source.
435     // We have to copy the request because requests are mutable.
436     ResourceRequest m_originalRequestCopy;
437     
438     // The 'working' request. It may be mutated
439     // several times from the original request to include additional
440     // headers, cookie information, canonicalization and redirects.
441     ResourceRequest m_request;
442
443     ResourceResponse m_response;
444
445     ResourceError m_mainDocumentError;    
446
447     bool m_originalSubstituteDataWasValid;
448     bool m_committed { false };
449     bool m_isStopping { false };
450     bool m_gotFirstByte { false };
451     bool m_isClientRedirect { false };
452     bool m_isLoadingMultipartContent { false };
453
454     // FIXME: Document::m_processingLoadEvent and DocumentLoader::m_wasOnloadDispatched are roughly the same
455     // and should be merged.
456     bool m_wasOnloadDispatched { false };
457
458     StringWithDirection m_pageTitle;
459
460     String m_overrideEncoding;
461
462     // The action that triggered loading - we keep this around for the
463     // benefit of the various policy handlers.
464     NavigationAction m_triggeringAction;
465
466     // The last request that we checked click policy for - kept around
467     // so we can avoid asking again needlessly.
468     ResourceRequest m_lastCheckedRequest;
469
470     // We retain all the received responses so we can play back the
471     // WebResourceLoadDelegate messages if the item is loaded from the
472     // page cache.
473     Vector<ResourceResponse> m_responses;
474     bool m_stopRecordingResponses { false };
475     
476     typedef HashMap<RefPtr<ResourceLoader>, RefPtr<SubstituteResource>> SubstituteResourceMap;
477     SubstituteResourceMap m_pendingSubstituteResources;
478     Timer m_substituteResourceDeliveryTimer;
479
480     std::unique_ptr<ArchiveResourceCollection> m_archiveResourceCollection;
481 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
482     RefPtr<Archive> m_archive;
483     RefPtr<SharedBuffer> m_parsedArchiveData;
484 #endif
485
486     HashSet<String> m_resourcesClientKnowsAbout;
487     Vector<ResourceRequest> m_resourcesLoadedFromMemoryCacheForClientNotification;
488     
489     String m_clientRedirectSourceForHistory;
490     bool m_didCreateGlobalHistoryEntry { false };
491
492     bool m_loadingMainResource { false };
493     LoadTiming m_loadTiming;
494
495     MonotonicTime m_timeOfLastDataReceived;
496     unsigned long m_identifierForLoadWithoutResourceLoader { 0 };
497
498     DocumentLoaderTimer m_dataLoadTimer;
499     bool m_waitingForContentPolicy { false };
500     bool m_waitingForNavigationPolicy { false };
501
502     HashMap<uint64_t, LinkIcon> m_iconsPendingLoadDecision;
503     HashMap<std::unique_ptr<IconLoader>, uint64_t> m_iconLoaders;
504     Vector<LinkIcon> m_linkIcons;
505
506 #if ENABLE(APPLICATION_MANIFEST)
507     HashMap<std::unique_ptr<ApplicationManifestLoader>, uint64_t> m_applicationManifestLoaders;
508 #endif
509
510     Vector<HTTPHeaderField> m_customHeaderFields;
511     
512     bool m_subresourceLoadersArePageCacheAcceptable { false };
513     ShouldOpenExternalURLsPolicy m_shouldOpenExternalURLsPolicy { ShouldOpenExternalURLsPolicy::ShouldNotAllow };
514
515     std::unique_ptr<ApplicationCacheHost> m_applicationCacheHost;
516
517 #if ENABLE(CONTENT_FILTERING)
518     std::unique_ptr<ContentFilter> m_contentFilter;
519 #endif
520
521 #if USE(QUICK_LOOK)
522     std::unique_ptr<PreviewConverter> m_previewConverter;
523 #endif
524
525 #if ENABLE(CONTENT_EXTENSIONS)
526     HashMap<String, RefPtr<StyleSheetContents>> m_pendingNamedContentExtensionStyleSheets;
527     HashMap<String, Vector<std::pair<String, uint32_t>>> m_pendingContentExtensionDisplayNoneSelectors;
528 #endif
529     bool m_userContentExtensionsEnabled { true };
530     AutoplayPolicy m_autoplayPolicy { AutoplayPolicy::Default };
531     OptionSet<AutoplayQuirk> m_allowedAutoplayQuirks;
532     PopUpPolicy m_popUpPolicy { PopUpPolicy::Default };
533
534 #if ENABLE(SERVICE_WORKER)
535     std::optional<ServiceWorkerRegistrationData> m_serviceWorkerRegistrationData;
536 #endif
537
538 #ifndef NDEBUG
539     bool m_hasEverBeenAttached { false };
540 #endif
541 };
542
543 inline void DocumentLoader::recordMemoryCacheLoadForFutureClientNotification(const ResourceRequest& request)
544 {
545     m_resourcesLoadedFromMemoryCacheForClientNotification.append(request);
546 }
547
548 inline void DocumentLoader::takeMemoryCacheLoadsForClientNotification(Vector<ResourceRequest>& loadsSet)
549 {
550     loadsSet.swap(m_resourcesLoadedFromMemoryCacheForClientNotification);
551     m_resourcesLoadedFromMemoryCacheForClientNotification.clear();
552 }
553
554 inline const ResourceRequest& DocumentLoader::originalRequest() const
555 {
556     return m_originalRequest;
557 }
558
559 inline const ResourceRequest& DocumentLoader::originalRequestCopy() const
560 {
561     return m_originalRequestCopy;
562 }
563
564 inline const ResourceRequest& DocumentLoader::request() const
565 {
566     return m_request;
567 }
568
569 inline ResourceRequest& DocumentLoader::request()
570 {
571     return m_request;
572 }
573
574 inline const URL& DocumentLoader::url() const
575 {
576     return m_request.url();
577 }
578
579 inline const URL& DocumentLoader::originalURL() const
580 {
581     return m_originalRequestCopy.url();
582 }
583
584 inline const URL& DocumentLoader::responseURL() const
585 {
586     return m_response.url();
587 }
588
589 inline const String& DocumentLoader::responseMIMEType() const
590 {
591     return m_response.mimeType();
592 }
593
594 inline const String& DocumentLoader::currentContentType() const
595 {
596     return m_writer.mimeType();
597 }
598
599 inline const URL& DocumentLoader::unreachableURL() const
600 {
601     return m_substituteData.failingURL();
602 }
603
604 inline ApplicationCacheHost& DocumentLoader::applicationCacheHost() const
605 {
606     // For a short time while the document loader is being destroyed, m_applicationCacheHost is null.
607     // It's not acceptable to call this function during that time.
608     ASSERT(m_applicationCacheHost);
609     return *m_applicationCacheHost;
610 }
611
612 inline ApplicationCacheHost* DocumentLoader::applicationCacheHostUnlessBeingDestroyed() const
613 {
614     return m_applicationCacheHost.get();
615 }
616
617 #if ENABLE(CONTENT_FILTERING)
618
619 inline ContentFilter* DocumentLoader::contentFilter() const
620 {
621     return m_contentFilter.get();
622 }
623
624 #endif
625
626 inline void DocumentLoader::didTellClientAboutLoad(const String& url)
627 {
628 #if !PLATFORM(COCOA)
629     // Don't include data URLs here, as if a lot of data is loaded that way, we hold on to the (large) URL string for too long.
630     if (protocolIs(url, "data"))
631         return;
632 #endif
633     if (!url.isEmpty())
634         m_resourcesClientKnowsAbout.add(url);
635 }
636
637 }