2602545fd9d8203d1ba55d95a83bb698f2f3a568
[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 "AdClickAttribution.h"
35 #include "CachePolicy.h"
36 #include "FrameLoaderStateMachine.h"
37 #include "FrameLoaderTypes.h"
38 #include "LayoutMilestone.h"
39 #include "MixedContentChecker.h"
40 #include "ReferrerPolicy.h"
41 #include "ResourceLoadNotifier.h"
42 #include "ResourceLoaderOptions.h"
43 #include "ResourceRequestBase.h"
44 #include "SecurityContext.h"
45 #include "StoredCredentialsPolicy.h"
46 #include "Timer.h"
47 #include <wtf/CompletionHandler.h>
48 #include <wtf/Forward.h>
49 #include <wtf/HashSet.h>
50 #include <wtf/OptionSet.h>
51 #include <wtf/Optional.h>
52 #include <wtf/WallTime.h>
53
54 namespace WebCore {
55
56 class Archive;
57 class CachedFrame;
58 class CachedFrameBase;
59 class CachedPage;
60 class CachedResource;
61 class Chrome;
62 class DOMWrapperWorld;
63 class Document;
64 class DocumentLoader;
65 class Event;
66 class FormState;
67 class FormSubmission;
68 class FrameLoadRequest;
69 class FrameLoaderClient;
70 class FrameNetworkingContext;
71 class HistoryController;
72 class HistoryItem;
73 class NavigationAction;
74 class NetworkingContext;
75 class Node;
76 class Page;
77 class PolicyChecker;
78 class ResourceError;
79 class ResourceRequest;
80 class ResourceResponse;
81 class SerializedScriptValue;
82 class SharedBuffer;
83 class SubframeLoader;
84 class SubstituteData;
85
86 enum class NewLoadInProgress : bool;
87 enum class ShouldContinue;
88 enum class NavigationPolicyDecision : uint8_t;
89 enum class ShouldTreatAsContinuingLoad : bool;
90
91 struct WindowFeatures;
92
93 WEBCORE_EXPORT bool isBackForwardLoadType(FrameLoadType);
94 WEBCORE_EXPORT bool isReload(FrameLoadType);
95
96 using ContentPolicyDecisionFunction = WTF::Function<void(PolicyAction, PolicyCheckIdentifier)>;
97
98 class FrameLoader final {
99     WTF_MAKE_FAST_ALLOCATED;
100     WTF_MAKE_NONCOPYABLE(FrameLoader);
101 public:
102     FrameLoader(Frame&, FrameLoaderClient&);
103     ~FrameLoader();
104
105     WEBCORE_EXPORT void init();
106     void initForSynthesizedDocument(const URL&);
107
108     Frame& frame() const { return m_frame; }
109
110     PolicyChecker& policyChecker() const { return *m_policyChecker; }
111     HistoryController& history() const { return *m_history; }
112     ResourceLoadNotifier& notifier() const { return m_notifier; }
113     SubframeLoader& subframeLoader() const { return *m_subframeLoader; }
114     MixedContentChecker& mixedContentChecker() const { return m_mixedContentChecker; }
115
116     void setupForReplace();
117
118     // FIXME: These are all functions which start loads. We have too many.
119     WEBCORE_EXPORT void loadURLIntoChildFrame(const URL&, const String& referer, Frame*);
120     WEBCORE_EXPORT void loadFrameRequest(FrameLoadRequest&&, Event*, RefPtr<FormState>&&, Optional<AdClickAttribution>&& = WTF::nullopt); // Called by submitForm, calls loadPostRequest and loadURL.
121
122     WEBCORE_EXPORT void load(FrameLoadRequest&&);
123
124 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
125     WEBCORE_EXPORT void loadArchive(Ref<Archive>&&);
126 #endif
127     unsigned long loadResourceSynchronously(const ResourceRequest&, ClientCredentialPolicy, const FetchOptions&, const HTTPHeaderMap&, ResourceError&, ResourceResponse&, RefPtr<SharedBuffer>& data);
128
129     void changeLocation(FrameLoadRequest&&);
130     WEBCORE_EXPORT void urlSelected(const URL&, const String& target, Event*, LockHistory, LockBackForwardList, ShouldSendReferrer, ShouldOpenExternalURLsPolicy, Optional<NewFrameOpenerPolicy> = WTF::nullopt, const AtomString& downloadAttribute = nullAtom(), const SystemPreviewInfo& = { }, Optional<AdClickAttribution>&& = WTF::nullopt);
131     void submitForm(Ref<FormSubmission>&&);
132
133     WEBCORE_EXPORT void reload(OptionSet<ReloadOption> = { });
134     WEBCORE_EXPORT void reloadWithOverrideEncoding(const String& overrideEncoding);
135
136     void open(CachedFrameBase&);
137     void loadItem(HistoryItem&, HistoryItem* fromItem, FrameLoadType, ShouldTreatAsContinuingLoad);
138     HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
139
140     void retryAfterFailedCacheOnlyMainResourceLoad();
141
142     static void reportLocalLoadFailed(Frame*, const String& url);
143     static void reportBlockedPortFailed(Frame*, const String& url);
144     static void reportAuthenticationChallengeBlocked(Frame*, const URL&, const String& reason);
145
146     // FIXME: These are all functions which stop loads. We have too many.
147     void stopAllLoadersAndCheckCompleteness();
148     WEBCORE_EXPORT void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem, StopLoadingPolicy = StopLoadingPolicy::PreventDuringUnloadEvents);
149     WEBCORE_EXPORT void stopForUserCancel(bool deferCheckLoadComplete = false);
150     void stop();
151     void stopLoading(UnloadEventPolicy);
152     bool closeURL();
153     void cancelAndClear();
154     void clearProvisionalLoadForPolicyCheck();
155     // FIXME: clear() is trying to do too many things. We should break it down into smaller functions (ideally with fewer raw Boolean parameters).
156     void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true, WTF::Function<void()>&& handleDOMWindowCreation = nullptr);
157
158     bool isLoading() const;
159     WEBCORE_EXPORT bool frameHasLoaded() const;
160
161     WEBCORE_EXPORT int numPendingOrLoadingRequests(bool recurse) const;
162
163     ReferrerPolicy effectiveReferrerPolicy() const;
164     String referrer() const;
165     WEBCORE_EXPORT String outgoingReferrer() const;
166     String outgoingOrigin() const;
167
168     WEBCORE_EXPORT DocumentLoader* activeDocumentLoader() const;
169     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
170     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
171     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
172     FrameState state() const { return m_state; }
173
174     bool shouldReportResourceTimingToParentFrame() const { return m_shouldReportResourceTimingToParentFrame; };
175     
176 #if PLATFORM(IOS_FAMILY)
177     RetainPtr<CFDictionaryRef> connectionProperties(ResourceLoader*);
178 #endif
179     const ResourceRequest& originalRequest() const;
180     const ResourceRequest& initialRequest() const;
181     void receivedMainResourceError(const ResourceError&);
182
183     bool willLoadMediaElementURL(URL&, Node&);
184
185     void handleFallbackContent();
186
187     WEBCORE_EXPORT ResourceError cancelledError(const ResourceRequest&) const;
188     WEBCORE_EXPORT ResourceError blockedByContentBlockerError(const ResourceRequest&) const;
189     ResourceError blockedError(const ResourceRequest&) const;
190 #if ENABLE(CONTENT_FILTERING)
191     ResourceError blockedByContentFilterError(const ResourceRequest&) const;
192 #endif
193
194     bool isHostedByObjectElement() const;
195
196     bool isReplacing() const;
197     void setReplacing();
198     bool subframeIsLoading() const;
199     void willChangeTitle(DocumentLoader*);
200     void didChangeTitle(DocumentLoader*);
201
202     bool shouldTreatURLAsSrcdocDocument(const URL&) const;
203
204     WEBCORE_EXPORT FrameLoadType loadType() const;
205
206     CachePolicy subresourceCachePolicy(const URL&) const;
207
208     void didReachLayoutMilestone(OptionSet<LayoutMilestone>);
209     void didFirstLayout();
210
211     void loadedResourceFromMemoryCache(CachedResource&, ResourceRequest& newRequest, ResourceError&);
212     void tellClientAboutPastMemoryCacheLoads();
213
214     void checkLoadComplete();
215     WEBCORE_EXPORT void detachFromParent();
216     void detachViewsAndDocumentLoader();
217
218     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
219     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
220     
221     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
222     static void addHTTPUpgradeInsecureRequestsIfNeeded(ResourceRequest&);
223     static void addSameSiteInfoToRequestIfNeeded(ResourceRequest&, const Document* initiator = nullptr);
224
225     FrameLoaderClient& client() const { return m_client; }
226
227     void setDefersLoading(bool);
228
229     void checkContentPolicy(const ResourceResponse&, PolicyCheckIdentifier, ContentPolicyDecisionFunction&&);
230
231     void didExplicitOpen();
232
233     // Callbacks from DocumentWriter
234     void didBeginDocument(bool dispatchWindowObjectAvailable);
235
236     void receivedFirstData();
237
238     void dispatchOnloadEvents();
239     String userAgent(const URL&) const;
240     String userAgentForJavaScript(const URL&) const;
241     String navigatorPlatform() const;
242
243     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld&);
244     void dispatchDidClearWindowObjectsInAllWorlds();
245
246     // The following sandbox flags will be forced, regardless of changes to
247     // the sandbox attribute of any parent frames.
248     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
249     SandboxFlags effectiveSandboxFlags() const;
250
251     bool checkIfFormActionAllowedByCSP(const URL&, bool didReceiveRedirectResponse) const;
252
253     WEBCORE_EXPORT Frame* opener();
254     WEBCORE_EXPORT void setOpener(Frame*);
255     bool hasOpenedFrames() const { return !m_openedFrames.isEmpty(); }
256
257     void resetMultipleFormSubmissionProtection();
258
259     void checkCallImplicitClose();
260
261     void frameDetached();
262
263     void setOutgoingReferrer(const URL&);
264
265     void loadDone(LoadCompletionType);
266     void subresourceLoadDone(LoadCompletionType);
267     void finishedParsing();
268     void checkCompleted();
269
270     WEBCORE_EXPORT bool isComplete() const;
271
272     void commitProvisionalLoad();
273
274     void setLoadsSynchronously(bool loadsSynchronously) { m_loadsSynchronously = loadsSynchronously; }
275     bool loadsSynchronously() const { return m_loadsSynchronously; }
276
277     FrameLoaderStateMachine& stateMachine() { return m_stateMachine; }
278
279     WEBCORE_EXPORT Frame* findFrameForNavigation(const AtomString& name, Document* activeDocument = nullptr);
280
281     void applyUserAgentIfNeeded(ResourceRequest&);
282
283     bool shouldInterruptLoadForXFrameOptions(const String&, const URL&, unsigned long requestIdentifier);
284
285     void completed();
286     bool allAncestorsAreComplete() const; // including this
287     void clientRedirected(const URL&, double delay, WallTime fireDate, LockBackForwardList);
288     void clientRedirectCancelledOrFinished(NewLoadInProgress);
289
290     WEBCORE_EXPORT void setOriginalURLForDownloadRequest(ResourceRequest&);
291
292     bool quickRedirectComing() const { return m_quickRedirectComing; }
293
294     WEBCORE_EXPORT bool shouldClose();
295     
296     void started();
297
298     enum class PageDismissalType { None, BeforeUnload, PageHide, Unload };
299     PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
300
301     WEBCORE_EXPORT NetworkingContext* networkingContext() const;
302
303     void loadProgressingStatusChanged();
304
305     const URL& previousURL() const { return m_previousURL; }
306
307     void forcePageTransitionIfNeeded();
308
309     void setOverrideCachePolicyForTesting(ResourceRequestCachePolicy policy) { m_overrideCachePolicyForTesting = policy; }
310     void setOverrideResourceLoadPriorityForTesting(ResourceLoadPriority priority) { m_overrideResourceLoadPriorityForTesting = priority; }
311     void setStrictRawResourceValidationPolicyDisabledForTesting(bool disabled) { m_isStrictRawResourceValidationPolicyDisabledForTesting = disabled; }
312     bool isStrictRawResourceValidationPolicyDisabledForTesting() { return m_isStrictRawResourceValidationPolicyDisabledForTesting; }
313
314     WEBCORE_EXPORT void clearTestingOverrides();
315
316     const URL& provisionalLoadErrorBeingHandledURL() const { return m_provisionalLoadErrorBeingHandledURL; }
317     void setProvisionalLoadErrorBeingHandledURL(const URL& url) { m_provisionalLoadErrorBeingHandledURL = url; }
318
319     bool isAlwaysOnLoggingAllowed() const;
320     bool shouldSuppressTextInputFromEditing() const;
321     bool isReloadingFromOrigin() const { return m_loadType == FrameLoadType::ReloadFromOrigin; }
322
323     // Used in webarchive loading tests.
324     void setAlwaysAllowLocalWebarchive(bool alwaysAllowLocalWebarchive) { m_alwaysAllowLocalWebarchive = alwaysAllowLocalWebarchive; }
325     bool alwaysAllowLocalWebarchive() const { return m_alwaysAllowLocalWebarchive; }
326
327 private:
328     enum FormSubmissionCacheLoadPolicy {
329         MayAttemptCacheOnlyLoadForFormSubmissionItem,
330         MayNotAttemptCacheOnlyLoadForFormSubmissionItem
331     };
332
333     bool allChildrenAreComplete() const; // immediate children, not all descendants
334
335     void checkTimerFired();
336     void checkCompletenessNow();
337
338     void loadSameDocumentItem(HistoryItem&);
339     void loadDifferentDocumentItem(HistoryItem&, HistoryItem* fromItem, FrameLoadType, FormSubmissionCacheLoadPolicy, ShouldTreatAsContinuingLoad);
340
341     void loadProvisionalItemFromCachedPage();
342
343     void updateFirstPartyForCookies();
344     void setFirstPartyForCookies(const URL&);
345
346     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
347     ResourceRequestCachePolicy defaultRequestCachingPolicy(const ResourceRequest&, FrameLoadType, bool isMainResource);
348
349     void clearProvisionalLoad();
350     void transitionToCommitted(CachedPage*);
351     void frameLoadCompleted();
352
353     SubstituteData defaultSubstituteDataForURL(const URL&);
354
355     bool dispatchBeforeUnloadEvent(Chrome&, FrameLoader* frameLoaderBeingNavigated);
356     void dispatchUnloadEvents(UnloadEventPolicy);
357
358     void continueLoadAfterNavigationPolicy(const ResourceRequest&, FormState*, NavigationPolicyDecision, AllowNavigationToInvalidURL);
359     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, FormState*, const String& frameName, const NavigationAction&, ShouldContinue, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
360     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
361
362     bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const URL&);
363     void scrollToFragmentWithParentBoundary(const URL&, bool isNewNavigation = true);
364
365     void dispatchDidFailProvisionalLoad(DocumentLoader& provisionalDocumentLoader, const ResourceError&);
366     void checkLoadCompleteForThisFrame();
367
368     void setDocumentLoader(DocumentLoader*);
369     void setPolicyDocumentLoader(DocumentLoader*);
370     void setProvisionalDocumentLoader(DocumentLoader*);
371
372     void setState(FrameState);
373
374     void closeOldDataSources();
375     void willRestoreFromCachedPage();
376
377     bool shouldReloadToHandleUnreachableURL(DocumentLoader&);
378
379     void dispatchDidCommitLoad(Optional<HasInsecureContent> initialHasInsecureContent);
380
381     void urlSelected(FrameLoadRequest&&, Event*, Optional<AdClickAttribution>&& = WTF::nullopt);
382
383     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, RefPtr<FormState>&&, AllowNavigationToInvalidURL, ShouldTreatAsContinuingLoad, CompletionHandler<void()>&& = [] { }); // Calls continueLoadAfterNavigationPolicy
384     void load(DocumentLoader&); // Calls loadWithDocumentLoader
385
386     void loadWithNavigationAction(const ResourceRequest&, NavigationAction&&, LockHistory, FrameLoadType, RefPtr<FormState>&&, AllowNavigationToInvalidURL, const String& downloadAttribute = { }, CompletionHandler<void()>&& = [] { }); // Calls loadWithDocumentLoader
387
388     void loadPostRequest(FrameLoadRequest&&, const String& referrer, FrameLoadType, Event*, RefPtr<FormState>&&, CompletionHandler<void()>&&);
389     void loadURL(FrameLoadRequest&&, const String& referrer, FrameLoadType, Event*, RefPtr<FormState>&&, Optional<AdClickAttribution>&&, CompletionHandler<void()>&&);
390
391     bool shouldReload(const URL& currentURL, const URL& destinationURL);
392
393     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
394
395     WEBCORE_EXPORT void detachChildren();
396     void closeAndRemoveChild(Frame&);
397
398     void loadInSameDocument(const URL&, SerializedScriptValue* stateObject, bool isNewNavigation);
399
400     void prepareForLoadStart();
401     void provisionalLoadStarted();
402
403     void willTransitionToCommitted();
404     bool didOpenURL();
405
406     void scheduleCheckCompleted();
407     void scheduleCheckLoadComplete();
408     void startCheckCompleteTimer();
409
410     bool shouldTreatURLAsSameAsCurrent(const URL&) const;
411
412     void dispatchGlobalObjectAvailableInAllWorlds();
413
414     bool isNavigationAllowed() const;
415     bool isStopLoadingAllowed() const;
416
417     enum class LoadContinuingState : uint8_t { NotContinuing, ContinuingWithRequest, ContinuingWithHistoryItem };
418     bool shouldTreatCurrentLoadAsContinuingLoad() const { return m_currentLoadContinuingState != LoadContinuingState::NotContinuing; }
419
420     Frame& m_frame;
421     FrameLoaderClient& m_client;
422
423     const std::unique_ptr<PolicyChecker> m_policyChecker;
424     const std::unique_ptr<HistoryController> m_history;
425     mutable ResourceLoadNotifier m_notifier;
426     const std::unique_ptr<SubframeLoader> m_subframeLoader;
427     mutable FrameLoaderStateMachine m_stateMachine;
428     mutable MixedContentChecker m_mixedContentChecker;
429
430     class FrameProgressTracker;
431     std::unique_ptr<FrameProgressTracker> m_progressTracker;
432
433     FrameState m_state;
434     FrameLoadType m_loadType;
435
436     // Document loaders for the three phases of frame loading. Note that while 
437     // a new request is being loaded, the old document loader may still be referenced.
438     // E.g. while a new request is in the "policy" state, the old document loader may
439     // be consulted in particular as it makes sense to imply certain settings on the new loader.
440     RefPtr<DocumentLoader> m_documentLoader;
441     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
442     RefPtr<DocumentLoader> m_policyDocumentLoader;
443
444     URL m_provisionalLoadErrorBeingHandledURL;
445
446     bool m_quickRedirectComing;
447     bool m_sentRedirectNotification;
448     bool m_inStopAllLoaders;
449     bool m_inClearProvisionalLoadForPolicyCheck { false };
450     bool m_shouldReportResourceTimingToParentFrame { true };
451
452     String m_outgoingReferrer;
453
454     bool m_isExecutingJavaScriptFormAction;
455
456     bool m_didCallImplicitClose;
457     bool m_wasUnloadEventEmitted;
458
459     PageDismissalType m_pageDismissalEventBeingDispatched { PageDismissalType::None };
460     bool m_isComplete;
461
462     RefPtr<SerializedScriptValue> m_pendingStateObject;
463
464     bool m_needsClear;
465
466     URL m_submittedFormURL;
467
468     Timer m_checkTimer;
469     bool m_shouldCallCheckCompleted;
470     bool m_shouldCallCheckLoadComplete;
471
472     Frame* m_opener;
473     HashSet<Frame*> m_openedFrames;
474
475     bool m_loadingFromCachedPage;
476
477     bool m_currentNavigationHasShownBeforeUnloadConfirmPanel;
478
479     bool m_loadsSynchronously;
480
481     SandboxFlags m_forcedSandboxFlags;
482
483     RefPtr<FrameNetworkingContext> m_networkingContext;
484
485     Optional<ResourceRequestCachePolicy> m_overrideCachePolicyForTesting;
486     Optional<ResourceLoadPriority> m_overrideResourceLoadPriorityForTesting;
487     bool m_isStrictRawResourceValidationPolicyDisabledForTesting { false };
488
489     LoadContinuingState m_currentLoadContinuingState { LoadContinuingState::NotContinuing };
490
491     bool m_checkingLoadCompleteForDetachment { false };
492
493     URL m_previousURL;
494     RefPtr<HistoryItem> m_requestedHistoryItem;
495
496     bool m_alwaysAllowLocalWebarchive { false };
497 };
498
499 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
500 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
501 // the frame name references a frame different from the openerFrame, e.g. when it is
502 // "_self" or "_parent".
503 //
504 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
505 // and moving it to a more appropriate location.
506 RefPtr<Frame> createWindow(Frame& openerFrame, Frame& lookupFrame, FrameLoadRequest&&, const WindowFeatures&, bool& created);
507
508 } // namespace WebCore