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