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