Source/WebCore: Never override the policy URL on form submissions.
[WebKit-https.git] / Source / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2011 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  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1.  Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer. 
12  * 2.  Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in the
14  *     documentation and/or other materials provided with the distribution. 
15  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
16  *     its contributors may be used to endorse or promote products derived
17  *     from this software without specific prior written permission. 
18  *
19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef FrameLoader_h
32 #define FrameLoader_h
33
34 #include "CachePolicy.h"
35 #include "FrameLoaderStateMachine.h"
36 #include "FrameLoaderTypes.h"
37 #include "HistoryController.h"
38 #include "IconController.h"
39 #include "IconURL.h"
40 #include "PolicyChecker.h"
41 #include "ResourceLoadNotifier.h"
42 #include "SubframeLoader.h"
43 #include "ThreadableLoader.h"
44 #include "Timer.h"
45 #include <wtf/Forward.h>
46 #include <wtf/HashSet.h>
47
48 namespace WebCore {
49
50 class Archive;
51 class CachedFrameBase;
52 class CachedPage;
53 class CachedResource;
54 class Chrome;
55 class DOMWrapperWorld;
56 class DocumentLoader;
57 class Event;
58 class FormState;
59 class FormSubmission;
60 class FrameLoaderClient;
61 class FrameNetworkingContext;
62 class NavigationAction;
63 class NetworkingContext;
64 class Page;
65 class ResourceError;
66 class ResourceRequest;
67 class ResourceResponse;
68 class SecurityOrigin;
69 class SerializedScriptValue;
70 class StringWithDirection;
71 class SubstituteData;
72
73 struct FrameLoadRequest;
74 struct WindowFeatures;
75
76 bool isBackForwardLoadType(FrameLoadType);
77
78 class FrameLoader {
79     WTF_MAKE_NONCOPYABLE(FrameLoader);
80 public:
81     FrameLoader(Frame*, FrameLoaderClient*);
82     ~FrameLoader();
83
84     void init();
85
86     Frame* frame() const { return m_frame; }
87
88     PolicyChecker* policyChecker() const { return &m_policyChecker; }
89     HistoryController* history() const { return &m_history; }
90     ResourceLoadNotifier* notifier() const { return &m_notifer; }
91     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
92     IconController* icon() const { return &m_icon; }
93
94     void prepareForLoadStart();
95     void setupForReplace();
96
97     // FIXME: These are all functions which start loads. We have too many.
98     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
99     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
100         PassRefPtr<Event>, PassRefPtr<FormState>, ReferrerPolicy);
101
102     void load(const ResourceRequest&, bool lockHistory);                                        // Called by WebFrame, calls load(ResourceRequest, SubstituteData).
103     void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                 // Called both by WebFrame and internally, calls load(DocumentLoader*).
104     void load(const ResourceRequest&, const String& frameName, bool lockHistory);               // Called by WebPluginController.
105 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
106     void loadArchive(PassRefPtr<Archive>);
107 #endif
108     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
109
110     void changeLocation(PassRefPtr<SecurityOrigin>, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
111     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy);
112     void submitForm(PassRefPtr<FormSubmission>);
113
114     void reload(bool endToEndReload = false);
115     void reloadWithOverrideEncoding(const String& overrideEncoding);
116
117     void open(CachedFrameBase&);
118     void loadItem(HistoryItem*, FrameLoadType);
119
120     static void reportLocalLoadFailed(Frame*, const String& url);
121
122     // FIXME: These are all functions which stop loads. We have too many.
123     void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
124     void stopForUserCancel(bool deferCheckLoadComplete = false);
125     void stop();
126     void stopLoading(UnloadEventPolicy);
127     bool closeURL();
128     void cancelAndClear();
129     void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
130
131     bool isLoadingMainResource() const { return m_isLoadingMainResource; }
132     bool isLoading() const;
133     bool frameHasLoaded() const;
134     void transferLoadingResourcesFromPage(Page*);
135     void dispatchTransferLoadingResourceFromPage(unsigned long, DocumentLoader*, const ResourceRequest&, Page*);
136
137     int numPendingOrLoadingRequests(bool recurse) const;
138     String referrer() const;
139     String outgoingReferrer() const;
140     String outgoingOrigin() const;
141
142     DocumentLoader* activeDocumentLoader() const;
143     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
144     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
145     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
146     FrameState state() const { return m_state; }
147     static double timeOfLastCompletedLoad();
148
149     const ResourceRequest& originalRequest() const;
150     const ResourceRequest& initialRequest() const;
151     void receivedMainResourceError(const ResourceError&, bool isComplete);
152
153     bool willLoadMediaElementURL(KURL&);
154
155     void handleFallbackContent();
156
157     void finishedLoading();
158
159     ResourceError cancelledError(const ResourceRequest&) const;
160
161     bool isHostedByObjectElement() const;
162     bool isLoadingMainFrame() const;
163
164     void finishedLoadingDocument(DocumentLoader*);
165     bool isReplacing() const;
166     void setReplacing();
167     void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
168     bool subframeIsLoading() const;
169     void willChangeTitle(DocumentLoader*);
170     void didChangeTitle(DocumentLoader*);
171     void didChangeIcons(DocumentLoader*, IconType);
172
173     FrameLoadType loadType() const;
174
175     CachePolicy subresourceCachePolicy() const;
176
177     void didFirstLayout();
178     void didFirstVisuallyNonEmptyLayout();
179
180     void loadedResourceFromMemoryCache(CachedResource*);
181     void tellClientAboutPastMemoryCacheLoads();
182
183     void checkLoadComplete();
184     void detachFromParent();
185     void detachViewsAndDocumentLoader();
186
187     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
188     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
189     
190     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
191
192     FrameLoaderClient* client() const { return m_client; }
193
194     void setDefersLoading(bool);
195
196     void didExplicitOpen();
197
198     // Callbacks from DocumentWriter
199     void didBeginDocument(bool dispatchWindowObjectAvailable);
200     void didEndDocument();
201     void willSetEncoding();
202
203     void handledOnloadEvents();
204     String userAgent(const KURL&) const;
205
206     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
207     void dispatchDidClearWindowObjectsInAllWorlds();
208     void dispatchDocumentElementAvailable();
209
210     void ownerElementSandboxFlagsChanged() { updateSandboxFlags(); }
211
212     bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
213     SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
214     // The following sandbox flags will be forced, regardless of changes to
215     // the sandbox attribute of any parent frames.
216     void setForcedSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags = flags; m_sandboxFlags |= flags; }
217
218     // Mixed content related functions.
219     static bool isMixedContent(SecurityOrigin* context, const KURL&);
220     bool checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
221     bool checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
222
223     Frame* opener();
224     void setOpener(Frame*);
225
226     void resetMultipleFormSubmissionProtection();
227
228     void checkCallImplicitClose();
229
230     void frameDetached();
231
232     void setOutgoingReferrer(const KURL&);
233
234     void loadDone();
235     void finishedParsing();
236     void checkCompleted();
237
238     void checkDidPerformFirstNavigation();
239
240     bool isComplete() const;
241
242     void setTitle(const StringWithDirection&);
243
244     void commitProvisionalLoad();
245
246     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
247
248     bool shouldAllowNavigation(Frame* targetFrame) const;
249     Frame* findFrameForNavigation(const AtomicString& name);
250
251     void applyUserAgent(ResourceRequest&);
252
253     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
254
255     void completed();
256     bool allAncestorsAreComplete() const; // including this
257     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
258     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
259
260     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
261     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
262     // introduce a proper callback type for this function, we should make it private again.
263     void continueLoadAfterWillSubmitForm();
264     
265     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
266
267     static ObjectContentType defaultObjectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages);
268
269     bool quickRedirectComing() const { return m_quickRedirectComing; }
270
271     bool shouldClose();
272     
273     void started();
274
275     enum PageDismissalType {
276         NoDismissal = 0,
277         BeforeUnloadDismissal = 1,
278         PageHideDismissal = 2,
279         UnloadDismissal = 3
280     };
281     PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
282
283     NetworkingContext* networkingContext() const;
284
285 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
286     Archive* archive() const { return m_archive.get(); }
287 #endif
288
289 private:
290     bool allChildrenAreComplete() const; // immediate children, not all descendants
291
292     void checkTimerFired(Timer<FrameLoader>*);
293     
294     void loadSameDocumentItem(HistoryItem*);
295     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
296     
297     void loadProvisionalItemFromCachedPage();
298
299     void receivedFirstData();
300
301     void updateFirstPartyForCookies();
302     void setFirstPartyForCookies(const KURL&);
303     
304     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
305
306     void clearProvisionalLoad();
307     void transitionToCommitted(PassRefPtr<CachedPage>);
308     void frameLoadCompleted();
309
310     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
311     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
312     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
313     
314     bool fireBeforeUnloadEvent(Chrome*);
315
316     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
317     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
318     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
319
320     bool shouldScrollToAnchor(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
321
322     void checkLoadCompleteForThisFrame();
323
324     void setDocumentLoader(DocumentLoader*);
325     void setPolicyDocumentLoader(DocumentLoader*);
326     void setProvisionalDocumentLoader(DocumentLoader*);
327
328     void setState(FrameState);
329
330     void closeOldDataSources();
331     void prepareForCachedPageRestore();
332
333     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
334
335     void dispatchDidCommitLoad();
336
337     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy, ShouldReplaceDocumentIfJavaScriptURL);
338
339     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
340     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
341
342     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
343         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
344
345     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
346         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
347     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
348         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
349
350     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
351
352     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
353
354     void detachChildren();
355     void closeAndRemoveChild(Frame*);
356
357     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
358
359     void provisionalLoadStarted();
360
361     bool didOpenURL();
362
363     void scheduleCheckCompleted();
364     void scheduleCheckLoadComplete();
365     void startCheckCompleteTimer();
366
367     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
368
369     void updateSandboxFlags();
370
371     Frame* m_frame;
372     FrameLoaderClient* m_client;
373
374     mutable PolicyChecker m_policyChecker;
375     mutable HistoryController m_history;
376     mutable ResourceLoadNotifier m_notifer;
377     mutable SubframeLoader m_subframeLoader;
378     mutable FrameLoaderStateMachine m_stateMachine;
379     mutable IconController m_icon;
380
381     FrameState m_state;
382     FrameLoadType m_loadType;
383
384     // Document loaders for the three phases of frame loading. Note that while 
385     // a new request is being loaded, the old document loader may still be referenced.
386     // E.g. while a new request is in the "policy" state, the old document loader may
387     // be consulted in particular as it makes sense to imply certain settings on the new loader.
388     RefPtr<DocumentLoader> m_documentLoader;
389     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
390     RefPtr<DocumentLoader> m_policyDocumentLoader;
391
392     bool m_delegateIsHandlingProvisionalLoadError;
393
394     bool m_quickRedirectComing;
395     bool m_sentRedirectNotification;
396     bool m_inStopAllLoaders;
397
398     String m_outgoingReferrer;
399
400     bool m_isExecutingJavaScriptFormAction;
401
402     bool m_didCallImplicitClose;
403     bool m_wasUnloadEventEmitted;
404     PageDismissalType m_pageDismissalEventBeingDispatched;
405     bool m_isComplete;
406     bool m_isLoadingMainResource;
407
408     RefPtr<SerializedScriptValue> m_pendingStateObject;
409
410     bool m_hasReceivedFirstData;
411
412     bool m_needsClear;
413
414     KURL m_submittedFormURL;
415
416     Timer<FrameLoader> m_checkTimer;
417     bool m_shouldCallCheckCompleted;
418     bool m_shouldCallCheckLoadComplete;
419
420     Frame* m_opener;
421     HashSet<Frame*> m_openedFrames;
422
423     bool m_didPerformFirstNavigation;
424     bool m_loadingFromCachedPage;
425     bool m_suppressOpenerInNewFrame;
426
427     SandboxFlags m_sandboxFlags;
428     SandboxFlags m_forcedSandboxFlags;
429
430     RefPtr<FrameNetworkingContext> m_networkingContext;
431
432 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
433     RefPtr<Archive> m_archive;
434 #endif
435
436     KURL m_previousUrl;
437 };
438
439 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
440 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
441 // the frame name references a frame different from the openerFrame, e.g. when it is
442 // "_self" or "_parent".
443 //
444 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
445 // and moving it to a more appropriate location.
446 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
447
448 } // namespace WebCore
449
450 #endif // FrameLoader_h