https://bugs.webkit.org/show_bug.cgi?id=77383
[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
182     // FIXME: didFirstVisuallyNonEmptyLayout() and didNewFirstVisuallyNonEmptyLayout() should be merged.
183     // The only reason for both to exist is to experiment with different heuristics for the time being.
184     void didFirstVisuallyNonEmptyLayout();
185     void didNewFirstVisuallyNonEmptyLayout();
186
187     void loadedResourceFromMemoryCache(CachedResource*);
188     void tellClientAboutPastMemoryCacheLoads();
189
190     void checkLoadComplete();
191     void detachFromParent();
192     void detachViewsAndDocumentLoader();
193
194     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
195     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
196     
197     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
198
199     FrameLoaderClient* client() const { return m_client; }
200
201     void setDefersLoading(bool);
202
203     void didExplicitOpen();
204
205     // Callbacks from DocumentWriter
206     void didBeginDocument(bool dispatchWindowObjectAvailable);
207     void didEndDocument();
208     void willSetEncoding();
209
210     void handledOnloadEvents();
211     String userAgent(const KURL&) const;
212
213     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
214     void dispatchDidClearWindowObjectsInAllWorlds();
215     void dispatchDocumentElementAvailable();
216
217     // The following sandbox flags will be forced, regardless of changes to
218     // the sandbox attribute of any parent frames.
219     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
220     SandboxFlags effectiveSandboxFlags() const;
221
222     // Mixed content related functions.
223     static bool isMixedContent(SecurityOrigin* context, const KURL&);
224     bool checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
225     bool checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
226
227     Frame* opener();
228     void setOpener(Frame*);
229
230     void resetMultipleFormSubmissionProtection();
231
232     void checkCallImplicitClose();
233
234     void frameDetached();
235
236     void setOutgoingReferrer(const KURL&);
237
238     void loadDone();
239     void finishedParsing();
240     void checkCompleted();
241
242     void checkDidPerformFirstNavigation();
243
244     bool isComplete() const;
245
246     void setTitle(const StringWithDirection&);
247
248     void commitProvisionalLoad();
249
250     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
251
252     bool shouldAllowNavigation(Frame* targetFrame) const;
253     Frame* findFrameForNavigation(const AtomicString& name);
254
255     void applyUserAgent(ResourceRequest&);
256
257     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
258
259     void completed();
260     bool allAncestorsAreComplete() const; // including this
261     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
262     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
263
264     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
265     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
266     // introduce a proper callback type for this function, we should make it private again.
267     void continueLoadAfterWillSubmitForm();
268
269     void setOriginalURLForDownloadRequest(ResourceRequest&);
270
271     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
272
273     static ObjectContentType defaultObjectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages);
274
275     bool quickRedirectComing() const { return m_quickRedirectComing; }
276
277     bool shouldClose();
278     
279     void started();
280
281     enum PageDismissalType {
282         NoDismissal = 0,
283         BeforeUnloadDismissal = 1,
284         PageHideDismissal = 2,
285         UnloadDismissal = 3
286     };
287     PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
288
289     NetworkingContext* networkingContext() const;
290
291 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
292     Archive* archive() const { return m_archive.get(); }
293 #endif
294
295 private:
296     bool allChildrenAreComplete() const; // immediate children, not all descendants
297
298     void checkTimerFired(Timer<FrameLoader>*);
299     
300     void loadSameDocumentItem(HistoryItem*);
301     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
302     
303     void loadProvisionalItemFromCachedPage();
304
305     void receivedFirstData();
306
307     void updateFirstPartyForCookies();
308     void setFirstPartyForCookies(const KURL&);
309     
310     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
311
312     void clearProvisionalLoad();
313     void transitionToCommitted(PassRefPtr<CachedPage>);
314     void frameLoadCompleted();
315
316     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
317     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
318     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
319     
320     bool fireBeforeUnloadEvent(Chrome*);
321
322     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
323     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
324     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
325
326     bool shouldScrollToAnchor(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
327
328     void checkLoadCompleteForThisFrame();
329
330     void setDocumentLoader(DocumentLoader*);
331     void setPolicyDocumentLoader(DocumentLoader*);
332     void setProvisionalDocumentLoader(DocumentLoader*);
333
334     void setState(FrameState);
335
336     void closeOldDataSources();
337     void prepareForCachedPageRestore();
338
339     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
340
341     void dispatchDidCommitLoad();
342
343     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL);
344
345     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
346     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
347
348     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
349         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
350
351     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
352         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
353     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
354         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
355
356     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
357
358     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
359
360     void detachChildren();
361     void closeAndRemoveChild(Frame*);
362
363     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
364
365     void provisionalLoadStarted();
366
367     bool didOpenURL();
368
369     void scheduleCheckCompleted();
370     void scheduleCheckLoadComplete();
371     void startCheckCompleteTimer();
372
373     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
374
375     Frame* m_frame;
376     FrameLoaderClient* m_client;
377
378     mutable PolicyChecker m_policyChecker;
379     mutable HistoryController m_history;
380     mutable ResourceLoadNotifier m_notifer;
381     mutable SubframeLoader m_subframeLoader;
382     mutable FrameLoaderStateMachine m_stateMachine;
383     mutable IconController m_icon;
384
385     FrameState m_state;
386     FrameLoadType m_loadType;
387
388     // Document loaders for the three phases of frame loading. Note that while 
389     // a new request is being loaded, the old document loader may still be referenced.
390     // E.g. while a new request is in the "policy" state, the old document loader may
391     // be consulted in particular as it makes sense to imply certain settings on the new loader.
392     RefPtr<DocumentLoader> m_documentLoader;
393     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
394     RefPtr<DocumentLoader> m_policyDocumentLoader;
395
396     bool m_delegateIsHandlingProvisionalLoadError;
397
398     bool m_quickRedirectComing;
399     bool m_sentRedirectNotification;
400     bool m_inStopAllLoaders;
401
402     String m_outgoingReferrer;
403
404     bool m_isExecutingJavaScriptFormAction;
405
406     bool m_didCallImplicitClose;
407     bool m_wasUnloadEventEmitted;
408     PageDismissalType m_pageDismissalEventBeingDispatched;
409     bool m_isComplete;
410     bool m_isLoadingMainResource;
411
412     RefPtr<SerializedScriptValue> m_pendingStateObject;
413
414     bool m_hasReceivedFirstData;
415
416     bool m_needsClear;
417
418     KURL m_submittedFormURL;
419
420     Timer<FrameLoader> m_checkTimer;
421     bool m_shouldCallCheckCompleted;
422     bool m_shouldCallCheckLoadComplete;
423
424     Frame* m_opener;
425     HashSet<Frame*> m_openedFrames;
426
427     bool m_didPerformFirstNavigation;
428     bool m_loadingFromCachedPage;
429     bool m_suppressOpenerInNewFrame;
430
431     SandboxFlags m_forcedSandboxFlags;
432
433     RefPtr<FrameNetworkingContext> m_networkingContext;
434
435 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
436     RefPtr<Archive> m_archive;
437 #endif
438
439     KURL m_previousUrl;
440 };
441
442 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
443 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
444 // the frame name references a frame different from the openerFrame, e.g. when it is
445 // "_self" or "_parent".
446 //
447 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
448 // and moving it to a more appropriate location.
449 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
450
451 } // namespace WebCore
452
453 #endif // FrameLoader_h