53faa493dec581bcd1d1747446ffccada940c5b6
[WebKit-https.git] / Source / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006-2016 Apple Inc. All rights reserved.
3  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
4  * Copyright (C) Research In Motion Limited 2009. All rights reserved.
5  * Copyright (C) 2011 Google Inc. All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1.  Redistributions of source code must retain the above copyright
12  *     notice, this list of conditions and the following disclaimer. 
13  * 2.  Redistributions in binary form must reproduce the above copyright
14  *     notice, this list of conditions and the following disclaimer in the
15  *     documentation and/or other materials provided with the distribution. 
16  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
17  *     its contributors may be used to endorse or promote products derived
18  *     from this software without specific prior written permission. 
19  *
20  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #pragma once
33
34 #include "CachePolicy.h"
35 #include "FrameLoaderStateMachine.h"
36 #include "FrameLoaderTypes.h"
37 #include "LayoutMilestones.h"
38 #include "MixedContentChecker.h"
39 #include "ReferrerPolicy.h"
40 #include "ResourceLoadNotifier.h"
41 #include "ResourceLoaderOptions.h"
42 #include "ResourceRequestBase.h"
43 #include "SecurityContext.h"
44 #include "StoredCredentialsPolicy.h"
45 #include "Timer.h"
46 #include <wtf/Forward.h>
47 #include <wtf/HashSet.h>
48 #include <wtf/OptionSet.h>
49 #include <wtf/Optional.h>
50 #include <wtf/WallTime.h>
51
52 namespace WebCore {
53
54 class Archive;
55 class CachedFrame;
56 class CachedFrameBase;
57 class CachedPage;
58 class CachedResource;
59 class Chrome;
60 class DOMWrapperWorld;
61 class Document;
62 class DocumentLoader;
63 class Event;
64 class FormState;
65 class FormSubmission;
66 class FrameLoadRequest;
67 class FrameLoaderClient;
68 class FrameNetworkingContext;
69 class HistoryController;
70 class HistoryItem;
71 class NavigationAction;
72 class NetworkingContext;
73 class Page;
74 class PolicyChecker;
75 class ResourceError;
76 class ResourceRequest;
77 class ResourceResponse;
78 class SerializedScriptValue;
79 class SharedBuffer;
80 class SubframeLoader;
81 class SubstituteData;
82
83 enum class NavigationPolicyCheck;
84 enum class ShouldContinue;
85
86 struct WindowFeatures;
87
88 WEBCORE_EXPORT bool isBackForwardLoadType(FrameLoadType);
89 WEBCORE_EXPORT bool isReload(FrameLoadType);
90
91 using ContentPolicyDecisionFunction = WTF::Function<void(PolicyAction)>;
92
93 class FrameLoader {
94     WTF_MAKE_NONCOPYABLE(FrameLoader);
95 public:
96     FrameLoader(Frame&, FrameLoaderClient&);
97     ~FrameLoader();
98
99     WEBCORE_EXPORT void init();
100     void initForSynthesizedDocument(const URL&);
101
102     Frame& frame() const { return m_frame; }
103
104     PolicyChecker& policyChecker() const { return *m_policyChecker; }
105     HistoryController& history() const { return *m_history; }
106     ResourceLoadNotifier& notifier() const { return m_notifier; }
107     SubframeLoader& subframeLoader() const { return *m_subframeLoader; }
108     MixedContentChecker& mixedContentChecker() const { return m_mixedContentChecker; }
109
110     void setupForReplace();
111
112     // FIXME: These are all functions which start loads. We have too many.
113     WEBCORE_EXPORT void loadURLIntoChildFrame(const URL&, const String& referer, Frame*);
114     WEBCORE_EXPORT void loadFrameRequest(FrameLoadRequest&&, Event*, FormState*); // Called by submitForm, calls loadPostRequest and loadURL.
115
116     WEBCORE_EXPORT void load(FrameLoadRequest&&);
117
118 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
119     WEBCORE_EXPORT void loadArchive(Ref<Archive>&&);
120 #endif
121     unsigned long loadResourceSynchronously(const ResourceRequest&, ClientCredentialPolicy, const FetchOptions&, const HTTPHeaderMap&, ResourceError&, ResourceResponse&, RefPtr<SharedBuffer>& data);
122
123     void changeLocation(FrameLoadRequest&&);
124     WEBCORE_EXPORT void urlSelected(const URL&, const String& target, Event*, LockHistory, LockBackForwardList, ShouldSendReferrer, ShouldOpenExternalURLsPolicy, std::optional<NewFrameOpenerPolicy> = std::nullopt, const AtomicString& downloadAttribute = nullAtom());
125     void submitForm(Ref<FormSubmission>&&);
126
127     WEBCORE_EXPORT void reload(OptionSet<ReloadOption> = { });
128     WEBCORE_EXPORT void reloadWithOverrideEncoding(const String& overrideEncoding);
129
130     void open(CachedFrameBase&);
131     void loadItem(HistoryItem&, FrameLoadType, NavigationPolicyCheck);
132     HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
133
134     void retryAfterFailedCacheOnlyMainResourceLoad();
135
136     static void reportLocalLoadFailed(Frame*, const String& url);
137     static void reportBlockedPortFailed(Frame*, const String& url);
138     static void reportAuthenticationChallengeBlocked(Frame*, const URL&, const String& reason);
139
140     // FIXME: These are all functions which stop loads. We have too many.
141     WEBCORE_EXPORT void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
142     WEBCORE_EXPORT void stopForUserCancel(bool deferCheckLoadComplete = false);
143     void stop();
144     void stopLoading(UnloadEventPolicy);
145     bool closeURL();
146     void cancelAndClear();
147     void clearProvisionalLoadForPolicyCheck();
148     // FIXME: clear() is trying to do too many things. We should break it down into smaller functions (ideally with fewer raw Boolean parameters).
149     void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
150
151     bool isLoading() const;
152     WEBCORE_EXPORT bool frameHasLoaded() const;
153
154     WEBCORE_EXPORT int numPendingOrLoadingRequests(bool recurse) const;
155
156     ReferrerPolicy effectiveReferrerPolicy() const;
157     String referrer() const;
158     WEBCORE_EXPORT String outgoingReferrer() const;
159     String outgoingOrigin() const;
160
161     WEBCORE_EXPORT DocumentLoader* activeDocumentLoader() const;
162     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
163     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
164     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
165     FrameState state() const { return m_state; }
166
167     void setShouldReportResourceTimingToParentFrame(bool value) { m_shouldReportResourceTimingToParentFrame = value; }
168     bool shouldReportResourceTimingToParentFrame() { return m_shouldReportResourceTimingToParentFrame; };
169     
170 #if PLATFORM(IOS)
171     RetainPtr<CFDictionaryRef> connectionProperties(ResourceLoader*);
172 #endif
173     const ResourceRequest& originalRequest() const;
174     const ResourceRequest& initialRequest() const;
175     void receivedMainResourceError(const ResourceError&);
176
177     bool willLoadMediaElementURL(URL&);
178
179     void handleFallbackContent();
180
181     WEBCORE_EXPORT ResourceError cancelledError(const ResourceRequest&) const;
182     WEBCORE_EXPORT ResourceError blockedByContentBlockerError(const ResourceRequest&) const;
183     ResourceError blockedError(const ResourceRequest&) const;
184 #if ENABLE(CONTENT_FILTERING)
185     ResourceError blockedByContentFilterError(const ResourceRequest&) const;
186 #endif
187
188     bool isHostedByObjectElement() const;
189
190     bool isReplacing() const;
191     void setReplacing();
192     bool subframeIsLoading() const;
193     void willChangeTitle(DocumentLoader*);
194     void didChangeTitle(DocumentLoader*);
195
196     bool shouldTreatURLAsSrcdocDocument(const URL&) const;
197
198     WEBCORE_EXPORT FrameLoadType loadType() const;
199
200     CachePolicy subresourceCachePolicy(const URL&) const;
201
202     void didReachLayoutMilestone(LayoutMilestones);
203     void didFirstLayout();
204
205     void loadedResourceFromMemoryCache(CachedResource&, ResourceRequest& newRequest, ResourceError&);
206     void tellClientAboutPastMemoryCacheLoads();
207
208     void checkLoadComplete();
209     WEBCORE_EXPORT void detachFromParent();
210     void detachViewsAndDocumentLoader();
211
212     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
213     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
214     
215     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
216     static void addHTTPUpgradeInsecureRequestsIfNeeded(ResourceRequest&);
217
218     FrameLoaderClient& client() const { return m_client; }
219
220     void setDefersLoading(bool);
221
222     void checkContentPolicy(const ResourceResponse&, ContentPolicyDecisionFunction&&);
223
224     void didExplicitOpen();
225
226     // Callbacks from DocumentWriter
227     void didBeginDocument(bool dispatchWindowObjectAvailable);
228
229     void receivedFirstData();
230
231     void dispatchOnloadEvents();
232     String userAgent(const URL&) const;
233
234     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&);
235     void dispatchDidClearWindowObjectsInAllWorlds();
236
237     // The following sandbox flags will be forced, regardless of changes to
238     // the sandbox attribute of any parent frames.
239     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
240     SandboxFlags effectiveSandboxFlags() const;
241
242     bool checkIfFormActionAllowedByCSP(const URL&, bool didReceiveRedirectResponse) const;
243
244     WEBCORE_EXPORT Frame* opener();
245     WEBCORE_EXPORT void setOpener(Frame*);
246
247     void resetMultipleFormSubmissionProtection();
248
249     void checkCallImplicitClose();
250
251     void frameDetached();
252
253     void setOutgoingReferrer(const URL&);
254
255     void loadDone();
256     void finishedParsing();
257     void checkCompleted();
258
259     WEBCORE_EXPORT bool isComplete() const;
260
261     void commitProvisionalLoad();
262
263     void setLoadsSynchronously(bool loadsSynchronously) { m_loadsSynchronously = loadsSynchronously; }
264     bool loadsSynchronously() const { return m_loadsSynchronously; }
265
266     FrameLoaderStateMachine& stateMachine() { return m_stateMachine; }
267
268     WEBCORE_EXPORT Frame* findFrameForNavigation(const AtomicString& name, Document* activeDocument = nullptr);
269
270     void applyUserAgentIfNeeded(ResourceRequest&);
271
272     bool shouldInterruptLoadForXFrameOptions(const String&, const URL&, unsigned long requestIdentifier);
273
274     void completed();
275     bool allAncestorsAreComplete() const; // including this
276     void clientRedirected(const URL&, double delay, WallTime fireDate, LockBackForwardList);
277     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
278
279     WEBCORE_EXPORT void setOriginalURLForDownloadRequest(ResourceRequest&);
280
281     bool quickRedirectComing() const { return m_quickRedirectComing; }
282
283     WEBCORE_EXPORT bool shouldClose();
284     
285     void started();
286
287     enum class PageDismissalType { None, BeforeUnload, PageHide, Unload };
288     PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
289
290     WEBCORE_EXPORT NetworkingContext* networkingContext() const;
291
292     void loadProgressingStatusChanged();
293
294     const URL& previousURL() const { return m_previousURL; }
295
296     void forcePageTransitionIfNeeded();
297
298     void setOverrideCachePolicyForTesting(ResourceRequestCachePolicy policy) { m_overrideCachePolicyForTesting = policy; }
299     void setOverrideResourceLoadPriorityForTesting(ResourceLoadPriority priority) { m_overrideResourceLoadPriorityForTesting = priority; }
300     void setStrictRawResourceValidationPolicyDisabledForTesting(bool disabled) { m_isStrictRawResourceValidationPolicyDisabledForTesting = disabled; }
301     bool isStrictRawResourceValidationPolicyDisabledForTesting() { return m_isStrictRawResourceValidationPolicyDisabledForTesting; }
302
303     WEBCORE_EXPORT void clearTestingOverrides();
304
305     const URL& provisionalLoadErrorBeingHandledURL() const { return m_provisionalLoadErrorBeingHandledURL; }
306     void setProvisionalLoadErrorBeingHandledURL(const URL& url) { m_provisionalLoadErrorBeingHandledURL = url; }
307
308     bool isAlwaysOnLoggingAllowed() const;
309     bool shouldSuppressTextInputFromEditing() const;
310     bool isReloadingFromOrigin() const { return m_loadType == FrameLoadType::ReloadFromOrigin; }
311
312 private:
313     enum FormSubmissionCacheLoadPolicy {
314         MayAttemptCacheOnlyLoadForFormSubmissionItem,
315         MayNotAttemptCacheOnlyLoadForFormSubmissionItem
316     };
317
318     bool allChildrenAreComplete() const; // immediate children, not all descendants
319
320     void checkTimerFired();
321
322     void loadSameDocumentItem(HistoryItem&);
323     void loadDifferentDocumentItem(HistoryItem&, FrameLoadType, FormSubmissionCacheLoadPolicy, NavigationPolicyCheck);
324
325     void loadProvisionalItemFromCachedPage();
326
327     void updateFirstPartyForCookies();
328     void setFirstPartyForCookies(const URL&);
329
330     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
331     ResourceRequestCachePolicy defaultRequestCachingPolicy(const ResourceRequest&, FrameLoadType, bool isMainResource);
332
333     void clearProvisionalLoad();
334     void transitionToCommitted(CachedPage*);
335     void frameLoadCompleted();
336
337     SubstituteData defaultSubstituteDataForURL(const URL&);
338
339     bool dispatchBeforeUnloadEvent(Chrome&, FrameLoader* frameLoaderBeingNavigated);
340     void dispatchUnloadEvents(UnloadEventPolicy);
341
342     void continueLoadAfterNavigationPolicy(const ResourceRequest&, FormState*, ShouldContinue, AllowNavigationToInvalidURL);
343     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, FormState*, const String& frameName, const NavigationAction&, ShouldContinue, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
344     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
345
346     bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const URL&);
347     void scrollToFragmentWithParentBoundary(const URL&, bool isNewNavigation = true);
348
349     void checkLoadCompleteForThisFrame();
350
351     void setDocumentLoader(DocumentLoader*);
352     void setPolicyDocumentLoader(DocumentLoader*);
353     void setProvisionalDocumentLoader(DocumentLoader*);
354
355     void setState(FrameState);
356
357     void closeOldDataSources();
358     void willRestoreFromCachedPage();
359
360     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
361
362     void dispatchDidCommitLoad(std::optional<HasInsecureContent> initialHasInsecureContent);
363
364     void urlSelected(FrameLoadRequest&&, Event*);
365
366     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, FormState*, AllowNavigationToInvalidURL, NavigationPolicyCheck, CompletionHandler<void()>&&); // Calls continueLoadAfterNavigationPolicy
367     void load(DocumentLoader*); // Calls loadWithDocumentLoader
368
369     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&, LockHistory, FrameLoadType, FormState*, AllowNavigationToInvalidURL, CompletionHandler<void()>&&); // Calls loadWithDocumentLoader
370
371     void loadPostRequest(FrameLoadRequest&&, const String& referrer, FrameLoadType, Event*, FormState*, CompletionHandler<void()>&&);
372     void loadURL(FrameLoadRequest&&, const String& referrer, FrameLoadType, Event*, FormState*, CompletionHandler<void()>&&);
373
374     bool shouldReload(const URL& currentURL, const URL& destinationURL);
375
376     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
377
378     WEBCORE_EXPORT void detachChildren();
379     void closeAndRemoveChild(Frame&);
380
381     void loadInSameDocument(const URL&, SerializedScriptValue* stateObject, bool isNewNavigation);
382
383     void prepareForLoadStart();
384     void provisionalLoadStarted();
385
386     void willTransitionToCommitted();
387     bool didOpenURL();
388
389     void scheduleCheckCompleted();
390     void scheduleCheckLoadComplete();
391     void startCheckCompleteTimer();
392
393     bool shouldTreatURLAsSameAsCurrent(const URL&) const;
394
395     void dispatchGlobalObjectAvailableInAllWorlds();
396
397     bool isNavigationAllowed() const;
398     bool isStopLoadingAllowed() const;
399
400     Frame& m_frame;
401     FrameLoaderClient& m_client;
402
403     const std::unique_ptr<PolicyChecker> m_policyChecker;
404     const std::unique_ptr<HistoryController> m_history;
405     mutable ResourceLoadNotifier m_notifier;
406     const std::unique_ptr<SubframeLoader> m_subframeLoader;
407     mutable FrameLoaderStateMachine m_stateMachine;
408     mutable MixedContentChecker m_mixedContentChecker;
409
410     class FrameProgressTracker;
411     std::unique_ptr<FrameProgressTracker> m_progressTracker;
412
413     FrameState m_state;
414     FrameLoadType m_loadType;
415
416     // Document loaders for the three phases of frame loading. Note that while 
417     // a new request is being loaded, the old document loader may still be referenced.
418     // E.g. while a new request is in the "policy" state, the old document loader may
419     // be consulted in particular as it makes sense to imply certain settings on the new loader.
420     RefPtr<DocumentLoader> m_documentLoader;
421     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
422     RefPtr<DocumentLoader> m_policyDocumentLoader;
423
424     URL m_provisionalLoadErrorBeingHandledURL;
425
426     bool m_quickRedirectComing;
427     bool m_sentRedirectNotification;
428     bool m_inStopAllLoaders;
429     bool m_shouldReportResourceTimingToParentFrame { true };
430
431     String m_outgoingReferrer;
432
433     bool m_isExecutingJavaScriptFormAction;
434
435     bool m_didCallImplicitClose;
436     bool m_wasUnloadEventEmitted;
437
438     PageDismissalType m_pageDismissalEventBeingDispatched { PageDismissalType::None };
439     bool m_isComplete;
440
441     RefPtr<SerializedScriptValue> m_pendingStateObject;
442
443     bool m_needsClear;
444
445     URL m_submittedFormURL;
446
447     Timer m_checkTimer;
448     bool m_shouldCallCheckCompleted;
449     bool m_shouldCallCheckLoadComplete;
450
451     Frame* m_opener;
452     HashSet<Frame*> m_openedFrames;
453
454     bool m_loadingFromCachedPage;
455
456     bool m_currentNavigationHasShownBeforeUnloadConfirmPanel;
457
458     bool m_loadsSynchronously;
459
460     SandboxFlags m_forcedSandboxFlags;
461
462     RefPtr<FrameNetworkingContext> m_networkingContext;
463
464     std::optional<ResourceRequestCachePolicy> m_overrideCachePolicyForTesting;
465     std::optional<ResourceLoadPriority> m_overrideResourceLoadPriorityForTesting;
466     bool m_isStrictRawResourceValidationPolicyDisabledForTesting { false };
467     bool m_currentLoadShouldCheckNavigationPolicy { true };
468
469     URL m_previousURL;
470     RefPtr<HistoryItem> m_requestedHistoryItem;
471 };
472
473 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
474 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
475 // the frame name references a frame different from the openerFrame, e.g. when it is
476 // "_self" or "_parent".
477 //
478 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
479 // and moving it to a more appropriate location.
480 RefPtr<Frame> createWindow(Frame& openerFrame, Frame& lookupFrame, FrameLoadRequest&&, const WindowFeatures&, bool& created);
481
482 } // namespace WebCore