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