4a34f06b4475ade7290cbe079fba37baef601872
[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 setupForReplace();
98
99     // FIXME: These are all functions which start loads. We have too many.
100     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
101     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
102         PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer);
103
104     void load(const ResourceRequest&, bool lockHistory);                                        // Called by WebFrame, calls load(ResourceRequest, SubstituteData).
105     void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                 // Called both by WebFrame and internally, calls load(DocumentLoader*).
106     void load(const ResourceRequest&, const String& frameName, bool lockHistory);               // Called by WebPluginController.
107 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
108     void loadArchive(PassRefPtr<Archive>);
109 #endif
110     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
111
112     void changeLocation(SecurityOrigin*, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
113     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer);
114     void submitForm(PassRefPtr<FormSubmission>);
115
116     void reload(bool endToEndReload = false);
117     void reloadWithOverrideEncoding(const String& overrideEncoding);
118
119     void open(CachedFrameBase&);
120     void loadItem(HistoryItem*, FrameLoadType);
121     HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
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 isLoading() const;
135     bool frameHasLoaded() const;
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&);
152
153     bool willLoadMediaElementURL(KURL&);
154
155     void handleFallbackContent();
156
157     ResourceError cancelledError(const ResourceRequest&) const;
158
159     bool isHostedByObjectElement() const;
160     bool isLoadingMainFrame() const;
161
162     bool isReplacing() const;
163     void setReplacing();
164     bool subframeIsLoading() const;
165     void willChangeTitle(DocumentLoader*);
166     void didChangeTitle(DocumentLoader*);
167     void didChangeIcons(IconType);
168
169     bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
170
171     FrameLoadType loadType() const;
172
173     CachePolicy subresourceCachePolicy() const;
174
175     void didFirstLayout();
176
177     // FIXME: didFirstVisuallyNonEmptyLayout() and didNewFirstVisuallyNonEmptyLayout() should be merged.
178     // The only reason for both to exist is to experiment with different heuristics for the time being.
179     void didFirstVisuallyNonEmptyLayout();
180     void didNewFirstVisuallyNonEmptyLayout();
181
182     void loadedResourceFromMemoryCache(CachedResource*);
183     void tellClientAboutPastMemoryCacheLoads();
184
185     void checkLoadComplete();
186     void detachFromParent();
187     void detachViewsAndDocumentLoader();
188
189     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
190     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
191     
192     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
193
194     FrameLoaderClient* client() const { return m_client; }
195
196     void setDefersLoading(bool);
197
198     void didExplicitOpen();
199
200     // Callbacks from DocumentWriter
201     void didBeginDocument(bool dispatchWindowObjectAvailable);
202     void willSetEncoding();
203
204     void handledOnloadEvents();
205     String userAgent(const KURL&) const;
206
207     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
208     void dispatchDidClearWindowObjectsInAllWorlds();
209     void dispatchDocumentElementAvailable();
210
211     // The following sandbox flags will be forced, regardless of changes to
212     // the sandbox attribute of any parent frames.
213     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
214     SandboxFlags effectiveSandboxFlags() const;
215
216     // Mixed content related functions.
217     static bool isMixedContent(SecurityOrigin* context, const KURL&);
218     bool checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
219     bool checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
220
221     Frame* opener();
222     void setOpener(Frame*);
223
224     void resetMultipleFormSubmissionProtection();
225
226     void checkCallImplicitClose();
227
228     void frameDetached();
229
230     void setOutgoingReferrer(const KURL&);
231
232     void loadDone();
233     void finishedParsing();
234     void checkCompleted();
235
236     void checkDidPerformFirstNavigation();
237
238     bool isComplete() const;
239
240     void setTitle(const StringWithDirection&);
241
242     void commitProvisionalLoad();
243
244     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
245
246     Frame* findFrameForNavigation(const AtomicString& name, Document* activeDocument = 0);
247
248     void applyUserAgent(ResourceRequest&);
249
250     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
251
252     void completed();
253     bool allAncestorsAreComplete() const; // including this
254     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
255     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
256
257     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
258     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
259     // introduce a proper callback type for this function, we should make it private again.
260     void continueLoadAfterWillSubmitForm();
261
262     void setOriginalURLForDownloadRequest(ResourceRequest&);
263
264     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
265
266     static ObjectContentType defaultObjectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages);
267
268     bool quickRedirectComing() const { return m_quickRedirectComing; }
269
270     bool shouldClose();
271     
272     void started();
273
274     enum PageDismissalType {
275         NoDismissal = 0,
276         BeforeUnloadDismissal = 1,
277         PageHideDismissal = 2,
278         UnloadDismissal = 3
279     };
280     PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
281
282     NetworkingContext* networkingContext() const;
283
284 private:
285     bool allChildrenAreComplete() const; // immediate children, not all descendants
286
287     void checkTimerFired(Timer<FrameLoader>*);
288     
289     void loadSameDocumentItem(HistoryItem*);
290     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
291     
292     void loadProvisionalItemFromCachedPage();
293
294     void receivedFirstData();
295
296     void updateFirstPartyForCookies();
297     void setFirstPartyForCookies(const KURL&);
298     
299     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
300
301     void clearProvisionalLoad();
302     void transitionToCommitted(PassRefPtr<CachedPage>);
303     void frameLoadCompleted();
304
305     SubstituteData defaultSubstituteDataForURL(const KURL&);
306
307     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
308     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
309     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
310     
311     bool fireBeforeUnloadEvent(Chrome*);
312
313     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
314     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
315     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
316
317     bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
318     void scrollToFragmentWithParentBoundary(const KURL&);
319
320     void checkLoadCompleteForThisFrame();
321
322     void setDocumentLoader(DocumentLoader*);
323     void setPolicyDocumentLoader(DocumentLoader*);
324     void setProvisionalDocumentLoader(DocumentLoader*);
325
326     void setState(FrameState);
327
328     void closeOldDataSources();
329     void prepareForCachedPageRestore();
330
331     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
332
333     void dispatchDidCommitLoad();
334
335     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL);
336
337     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
338     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
339
340     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
341         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
342
343     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
344         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
345     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
346         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
347
348     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
349
350     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
351
352     void detachChildren();
353     void closeAndRemoveChild(Frame*);
354
355     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
356
357     void prepareForLoadStart();
358     void provisionalLoadStarted();
359
360     bool didOpenURL();
361
362     void scheduleCheckCompleted();
363     void scheduleCheckLoadComplete();
364     void startCheckCompleteTimer();
365
366     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
367
368     void dispatchGlobalObjectAvailableInAllWorlds();
369
370     Frame* m_frame;
371     FrameLoaderClient* m_client;
372
373     mutable PolicyChecker m_policyChecker;
374     mutable HistoryController m_history;
375     mutable ResourceLoadNotifier m_notifer;
376     mutable SubframeLoader m_subframeLoader;
377     mutable FrameLoaderStateMachine m_stateMachine;
378     mutable IconController m_icon;
379
380     FrameState m_state;
381     FrameLoadType m_loadType;
382
383     // Document loaders for the three phases of frame loading. Note that while 
384     // a new request is being loaded, the old document loader may still be referenced.
385     // E.g. while a new request is in the "policy" state, the old document loader may
386     // be consulted in particular as it makes sense to imply certain settings on the new loader.
387     RefPtr<DocumentLoader> m_documentLoader;
388     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
389     RefPtr<DocumentLoader> m_policyDocumentLoader;
390
391     bool m_delegateIsHandlingProvisionalLoadError;
392
393     bool m_quickRedirectComing;
394     bool m_sentRedirectNotification;
395     bool m_inStopAllLoaders;
396
397     String m_outgoingReferrer;
398
399     bool m_isExecutingJavaScriptFormAction;
400
401     bool m_didCallImplicitClose;
402     bool m_wasUnloadEventEmitted;
403     PageDismissalType m_pageDismissalEventBeingDispatched;
404     bool m_isComplete;
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     KURL m_previousUrl;
430     RefPtr<HistoryItem> m_requestedHistoryItem;
431 };
432
433 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
434 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
435 // the frame name references a frame different from the openerFrame, e.g. when it is
436 // "_self" or "_parent".
437 //
438 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
439 // and moving it to a more appropriate location.
440 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
441
442 } // namespace WebCore
443
444 #endif // FrameLoader_h