Rename ReferrerPolicy to clarify its meaning
[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  * 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 Computer, 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 #ifndef FrameLoader_h
33 #define FrameLoader_h
34
35 #include "CachePolicy.h"
36 #include "FrameLoaderStateMachine.h"
37 #include "FrameLoaderTypes.h"
38 #include "HistoryController.h"
39 #include "IconController.h"
40 #include "IconURL.h"
41 #include "PolicyChecker.h"
42 #include "ResourceHandle.h"
43 #include "ResourceLoadNotifier.h"
44 #include "SecurityContext.h"
45 #include "SubframeLoader.h"
46 #include "Timer.h"
47 #include <wtf/Forward.h>
48 #include <wtf/HashSet.h>
49
50 namespace WebCore {
51
52 class Archive;
53 class CachedFrameBase;
54 class CachedPage;
55 class CachedResource;
56 class Chrome;
57 class DOMWrapperWorld;
58 class DocumentLoader;
59 class Event;
60 class FormState;
61 class FormSubmission;
62 class FrameLoaderClient;
63 class FrameNetworkingContext;
64 class NavigationAction;
65 class NetworkingContext;
66 class Page;
67 class ResourceError;
68 class ResourceRequest;
69 class ResourceResponse;
70 class SecurityOrigin;
71 class SerializedScriptValue;
72 class StringWithDirection;
73 class SubstituteData;
74
75 struct FrameLoadRequest;
76 struct WindowFeatures;
77
78 bool isBackForwardLoadType(FrameLoadType);
79
80 class FrameLoader {
81     WTF_MAKE_NONCOPYABLE(FrameLoader);
82 public:
83     FrameLoader(Frame*, FrameLoaderClient*);
84     ~FrameLoader();
85
86     void init();
87
88     Frame* frame() const { return m_frame; }
89
90     PolicyChecker* policyChecker() const { return &m_policyChecker; }
91     HistoryController* history() const { return &m_history; }
92     ResourceLoadNotifier* notifier() const { return &m_notifer; }
93     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
94     IconController* icon() const { return &m_icon; }
95
96     void prepareForHistoryNavigation();
97     void prepareForLoadStart();
98     void setupForReplace();
99
100     // FIXME: These are all functions which start loads. We have too many.
101     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
102     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
103         PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer);
104
105     void load(const ResourceRequest&, bool lockHistory);                                        // Called by WebFrame, calls load(ResourceRequest, SubstituteData).
106     void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                 // Called both by WebFrame and internally, calls load(DocumentLoader*).
107     void load(const ResourceRequest&, const String& frameName, bool lockHistory);               // Called by WebPluginController.
108 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
109     void loadArchive(PassRefPtr<Archive>);
110 #endif
111     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
112
113     void changeLocation(SecurityOrigin*, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
114     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer);
115     void submitForm(PassRefPtr<FormSubmission>);
116
117     void reload(bool endToEndReload = false);
118     void reloadWithOverrideEncoding(const String& overrideEncoding);
119
120     void open(CachedFrameBase&);
121     void loadItem(HistoryItem*, FrameLoadType);
122
123     static void reportLocalLoadFailed(Frame*, const String& url);
124
125     // FIXME: These are all functions which stop loads. We have too many.
126     void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
127     void stopForUserCancel(bool deferCheckLoadComplete = false);
128     void stop();
129     void stopLoading(UnloadEventPolicy);
130     bool closeURL();
131     void cancelAndClear();
132     void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
133
134     bool isLoadingMainResource() const { return m_isLoadingMainResource; }
135     bool isLoading() const;
136     bool frameHasLoaded() const;
137     void transferLoadingResourcesFromPage(Page*);
138     void dispatchTransferLoadingResourceFromPage(ResourceLoader*, const ResourceRequest&, Page*);
139
140     int numPendingOrLoadingRequests(bool recurse) const;
141     String referrer() const;
142     String outgoingReferrer() const;
143     String outgoingOrigin() const;
144
145     DocumentLoader* activeDocumentLoader() const;
146     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
147     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
148     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
149     FrameState state() const { return m_state; }
150     static double timeOfLastCompletedLoad();
151
152     const ResourceRequest& originalRequest() const;
153     const ResourceRequest& initialRequest() const;
154     void receivedMainResourceError(const ResourceError&, bool isComplete);
155
156     bool willLoadMediaElementURL(KURL&);
157
158     void handleFallbackContent();
159
160     void finishedLoading();
161
162     ResourceError cancelledError(const ResourceRequest&) const;
163
164     bool isHostedByObjectElement() const;
165     bool isLoadingMainFrame() const;
166
167     void finishedLoadingDocument(DocumentLoader*);
168     bool isReplacing() const;
169     void setReplacing();
170     void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
171     bool subframeIsLoading() const;
172     void willChangeTitle(DocumentLoader*);
173     void didChangeTitle(DocumentLoader*);
174     void didChangeIcons(IconType);
175
176     FrameLoadType loadType() const;
177
178     CachePolicy subresourceCachePolicy() const;
179
180     void didFirstLayout();
181     void didFirstVisuallyNonEmptyLayout();
182
183     void loadedResourceFromMemoryCache(CachedResource*);
184     void tellClientAboutPastMemoryCacheLoads();
185
186     void checkLoadComplete();
187     void detachFromParent();
188     void detachViewsAndDocumentLoader();
189
190     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
191     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
192     
193     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
194
195     FrameLoaderClient* client() const { return m_client; }
196
197     void setDefersLoading(bool);
198
199     void didExplicitOpen();
200
201     // Callbacks from DocumentWriter
202     void didBeginDocument(bool dispatchWindowObjectAvailable);
203     void didEndDocument();
204     void willSetEncoding();
205
206     void handledOnloadEvents();
207     String userAgent(const KURL&) const;
208
209     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
210     void dispatchDidClearWindowObjectsInAllWorlds();
211     void dispatchDocumentElementAvailable();
212
213     // The following sandbox flags will be forced, regardless of changes to
214     // the sandbox attribute of any parent frames.
215     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
216     SandboxFlags effectiveSandboxFlags() const;
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, ShouldSendReferrer, 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     Frame* m_frame;
370     FrameLoaderClient* m_client;
371
372     mutable PolicyChecker m_policyChecker;
373     mutable HistoryController m_history;
374     mutable ResourceLoadNotifier m_notifer;
375     mutable SubframeLoader m_subframeLoader;
376     mutable FrameLoaderStateMachine m_stateMachine;
377     mutable IconController m_icon;
378
379     FrameState m_state;
380     FrameLoadType m_loadType;
381
382     // Document loaders for the three phases of frame loading. Note that while 
383     // a new request is being loaded, the old document loader may still be referenced.
384     // E.g. while a new request is in the "policy" state, the old document loader may
385     // be consulted in particular as it makes sense to imply certain settings on the new loader.
386     RefPtr<DocumentLoader> m_documentLoader;
387     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
388     RefPtr<DocumentLoader> m_policyDocumentLoader;
389
390     bool m_delegateIsHandlingProvisionalLoadError;
391
392     bool m_quickRedirectComing;
393     bool m_sentRedirectNotification;
394     bool m_inStopAllLoaders;
395
396     String m_outgoingReferrer;
397
398     bool m_isExecutingJavaScriptFormAction;
399
400     bool m_didCallImplicitClose;
401     bool m_wasUnloadEventEmitted;
402     PageDismissalType m_pageDismissalEventBeingDispatched;
403     bool m_isComplete;
404     bool m_isLoadingMainResource;
405
406     RefPtr<SerializedScriptValue> m_pendingStateObject;
407
408     bool m_hasReceivedFirstData;
409
410     bool m_needsClear;
411
412     KURL m_submittedFormURL;
413
414     Timer<FrameLoader> m_checkTimer;
415     bool m_shouldCallCheckCompleted;
416     bool m_shouldCallCheckLoadComplete;
417
418     Frame* m_opener;
419     HashSet<Frame*> m_openedFrames;
420
421     bool m_didPerformFirstNavigation;
422     bool m_loadingFromCachedPage;
423     bool m_suppressOpenerInNewFrame;
424
425     SandboxFlags m_forcedSandboxFlags;
426
427     RefPtr<FrameNetworkingContext> m_networkingContext;
428
429 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
430     RefPtr<Archive> m_archive;
431 #endif
432
433     KURL m_previousUrl;
434 };
435
436 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
437 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
438 // the frame name references a frame different from the openerFrame, e.g. when it is
439 // "_self" or "_parent".
440 //
441 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
442 // and moving it to a more appropriate location.
443 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
444
445 } // namespace WebCore
446
447 #endif // FrameLoader_h