1ca069688659dc658df3760eb73444d33aacc253
[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 "IconURL.h"
39 #include "LayoutMilestones.h"
40 #include "MixedContentChecker.h"
41 #include "ResourceHandleTypes.h"
42 #include "ResourceLoadNotifier.h"
43 #include "SecurityContext.h"
44 #include "SubframeLoader.h"
45 #include "Timer.h"
46 #include <wtf/Forward.h>
47 #include <wtf/HashSet.h>
48
49 namespace WebCore {
50
51 class Archive;
52 class CachedFrameBase;
53 class CachedPage;
54 class CachedResource;
55 class Chrome;
56 class DOMWrapperWorld;
57 class DocumentLoader;
58 class Event;
59 class FormState;
60 class FormSubmission;
61 class FrameLoaderClient;
62 class FrameNetworkingContext;
63 class HistoryController;
64 class HistoryItem;
65 class IconController;
66 class NavigationAction;
67 class NetworkingContext;
68 class Page;
69 class PolicyChecker;
70 class ResourceError;
71 class ResourceRequest;
72 class ResourceResponse;
73 class SecurityOrigin;
74 class SerializedScriptValue;
75 class StringWithDirection;
76 class SubstituteData;
77
78 struct FrameLoadRequest;
79 struct WindowFeatures;
80
81 bool isBackForwardLoadType(FrameLoadType);
82
83 class FrameLoader {
84     WTF_MAKE_NONCOPYABLE(FrameLoader);
85 public:
86     FrameLoader(Frame*, FrameLoaderClient*);
87     ~FrameLoader();
88
89     void init();
90
91     Frame* frame() const { return m_frame; }
92
93     PolicyChecker* policyChecker() const { return m_policyChecker.get(); }
94     HistoryController* history() const { return m_history.get(); }
95     ResourceLoadNotifier* notifier() const { return &m_notifer; }
96     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
97     IconController* icon() const { return m_icon.get(); }
98     MixedContentChecker* mixedContentChecker() const { return &m_mixedContentChecker; }
99
100     void prepareForHistoryNavigation();
101     void setupForReplace();
102
103     // FIXME: These are all functions which start loads. We have too many.
104     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
105     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
106         PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer);
107
108     void load(const FrameLoadRequest&);
109
110 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
111     void loadArchive(PassRefPtr<Archive>);
112 #endif
113     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data);
114
115     void changeLocation(SecurityOrigin*, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
116     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer);
117     void submitForm(PassRefPtr<FormSubmission>);
118
119     void reload(bool endToEndReload = false);
120     void reloadWithOverrideEncoding(const String& overrideEncoding);
121     void reloadWithOverrideURL(const KURL& overrideUrl, bool endToEndReload = false);
122
123     void open(CachedFrameBase&);
124     void loadItem(HistoryItem*, FrameLoadType);
125     HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
126
127     void retryAfterFailedCacheOnlyMainResourceLoad();
128
129     static void reportLocalLoadFailed(Frame*, const String& url);
130
131     // FIXME: These are all functions which stop loads. We have too many.
132     void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
133     void stopForUserCancel(bool deferCheckLoadComplete = false);
134     void stop();
135     void stopLoading(UnloadEventPolicy);
136     bool closeURL();
137     void cancelAndClear();
138     // FIXME: clear() is trying to do too many things. We should break it down into smaller functions (ideally with fewer raw Boolean parameters).
139     void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
140
141     bool isLoading() const;
142     bool frameHasLoaded() const;
143
144     int numPendingOrLoadingRequests(bool recurse) const;
145     String referrer() const;
146     String outgoingReferrer() const;
147     String outgoingOrigin() const;
148
149     DocumentLoader* activeDocumentLoader() const;
150     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
151     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
152     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
153     FrameState state() const { return m_state; }
154     static double timeOfLastCompletedLoad();
155
156     const ResourceRequest& originalRequest() const;
157     const ResourceRequest& initialRequest() const;
158     void receivedMainResourceError(const ResourceError&);
159
160     bool willLoadMediaElementURL(KURL&);
161
162     void handleFallbackContent();
163
164     ResourceError cancelledError(const ResourceRequest&) const;
165
166     bool isHostedByObjectElement() const;
167     bool isLoadingMainFrame() const;
168
169     bool isReplacing() const;
170     void setReplacing();
171     bool subframeIsLoading() const;
172     void willChangeTitle(DocumentLoader*);
173     void didChangeTitle(DocumentLoader*);
174     void didChangeIcons(IconType);
175
176     bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
177
178     FrameLoadType loadType() const;
179
180     CachePolicy subresourceCachePolicy() const;
181
182     void didLayout(LayoutMilestones);
183     void didFirstLayout();
184
185     void loadedResourceFromMemoryCache(CachedResource*, ResourceRequest& newRequest);
186     void tellClientAboutPastMemoryCacheLoads();
187
188     void checkLoadComplete();
189     void detachFromParent();
190     void detachViewsAndDocumentLoader();
191
192     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
193     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
194     
195     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
196
197     FrameLoaderClient* client() const { return m_client; }
198
199     void setDefersLoading(bool);
200
201     void didExplicitOpen();
202
203     // Callbacks from DocumentWriter
204     void didBeginDocument(bool dispatchWindowObjectAvailable);
205
206     void receivedFirstData();
207
208     void handledOnloadEvents();
209     String userAgent(const KURL&) const;
210
211     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
212     void dispatchDidClearWindowObjectsInAllWorlds();
213     void dispatchDocumentElementAvailable();
214
215     // The following sandbox flags will be forced, regardless of changes to
216     // the sandbox attribute of any parent frames.
217     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
218     SandboxFlags effectiveSandboxFlags() const;
219
220     bool checkIfFormActionAllowedByCSP(const KURL&) const;
221
222     Frame* opener();
223     void setOpener(Frame*);
224
225     void resetMultipleFormSubmissionProtection();
226
227     void checkCallImplicitClose();
228
229     void frameDetached();
230
231     void setOutgoingReferrer(const KURL&);
232
233     void loadDone();
234     void finishedParsing();
235     void checkCompleted();
236
237     void checkDidPerformFirstNavigation();
238
239     bool isComplete() const;
240
241     void setTitle(const StringWithDirection&);
242
243     void commitProvisionalLoad();
244
245     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
246
247     Frame* findFrameForNavigation(const AtomicString& name, Document* activeDocument = 0);
248
249     void applyUserAgent(ResourceRequest&);
250
251     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&, unsigned long requestIdentifier);
252
253     void completed();
254     bool allAncestorsAreComplete() const; // including this
255     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
256     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
257
258     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
259     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
260     // introduce a proper callback type for this function, we should make it private again.
261     void continueLoadAfterWillSubmitForm();
262
263     void setOriginalURLForDownloadRequest(ResourceRequest&);
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     void loadProgressingStatusChanged();
286
287     const KURL& previousURL() const { return m_previousURL; }
288
289 private:
290     enum FormSubmissionCacheLoadPolicy {
291         MayAttemptCacheOnlyLoadForFormSubmissionItem,
292         MayNotAttemptCacheOnlyLoadForFormSubmissionItem
293     };
294
295     bool allChildrenAreComplete() const; // immediate children, not all descendants
296
297     void checkTimerFired(Timer<FrameLoader>*);
298     
299     void loadSameDocumentItem(HistoryItem*);
300     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType, FormSubmissionCacheLoadPolicy);
301     
302     void loadProvisionalItemFromCachedPage();
303
304     void updateFirstPartyForCookies();
305     void setFirstPartyForCookies(const KURL&);
306     
307     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
308
309     void clearProvisionalLoad();
310     void transitionToCommitted(PassRefPtr<CachedPage>);
311     void frameLoadCompleted();
312
313     SubstituteData defaultSubstituteDataForURL(const KURL&);
314
315     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
316     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
317     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
318     
319     bool fireBeforeUnloadEvent(Chrome&);
320
321     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
322     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
323     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
324
325     bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
326     void scrollToFragmentWithParentBoundary(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     void reloadWithRequest(const ResourceRequest&, bool endToEndReload);
357
358     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
359
360     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
361
362     void detachChildren();
363     void closeAndRemoveChild(Frame*);
364
365     void loadInSameDocument(const KURL&, PassRefPtr<SerializedScriptValue> stateObject, bool isNewNavigation);
366
367     void prepareForLoadStart();
368     void provisionalLoadStarted();
369
370     void willTransitionToCommitted();
371     bool didOpenURL();
372
373     void scheduleCheckCompleted();
374     void scheduleCheckLoadComplete();
375     void startCheckCompleteTimer();
376
377     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
378
379     void dispatchGlobalObjectAvailableInAllWorlds();
380
381     Frame* m_frame;
382     FrameLoaderClient* m_client;
383
384     // FIXME: These should be OwnPtr<T> to reduce build times and simplify
385     // header dependencies unless performance testing proves otherwise.
386     // Some of these could be lazily created for memory savings on devices.
387     OwnPtr<PolicyChecker> m_policyChecker;
388     OwnPtr<HistoryController> m_history;
389     mutable ResourceLoadNotifier m_notifer;
390     mutable SubframeLoader m_subframeLoader;
391     mutable FrameLoaderStateMachine m_stateMachine;
392     OwnPtr<IconController> m_icon;
393     mutable MixedContentChecker m_mixedContentChecker;
394
395     class FrameProgressTracker;
396     OwnPtr<FrameProgressTracker> m_progressTracker;
397
398     FrameState m_state;
399     FrameLoadType m_loadType;
400
401     // Document loaders for the three phases of frame loading. Note that while 
402     // a new request is being loaded, the old document loader may still be referenced.
403     // E.g. while a new request is in the "policy" state, the old document loader may
404     // be consulted in particular as it makes sense to imply certain settings on the new loader.
405     RefPtr<DocumentLoader> m_documentLoader;
406     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
407     RefPtr<DocumentLoader> m_policyDocumentLoader;
408
409     bool m_delegateIsHandlingProvisionalLoadError;
410
411     bool m_quickRedirectComing;
412     bool m_sentRedirectNotification;
413     bool m_inStopAllLoaders;
414
415     String m_outgoingReferrer;
416
417     bool m_isExecutingJavaScriptFormAction;
418
419     bool m_didCallImplicitClose;
420     bool m_wasUnloadEventEmitted;
421     PageDismissalType m_pageDismissalEventBeingDispatched;
422     bool m_isComplete;
423
424     RefPtr<SerializedScriptValue> m_pendingStateObject;
425
426     bool m_needsClear;
427
428     KURL m_submittedFormURL;
429
430     Timer<FrameLoader> m_checkTimer;
431     bool m_shouldCallCheckCompleted;
432     bool m_shouldCallCheckLoadComplete;
433
434     Frame* m_opener;
435     HashSet<Frame*> m_openedFrames;
436
437     bool m_didPerformFirstNavigation;
438     bool m_loadingFromCachedPage;
439     bool m_suppressOpenerInNewFrame;
440
441     SandboxFlags m_forcedSandboxFlags;
442
443     RefPtr<FrameNetworkingContext> m_networkingContext;
444
445     KURL m_previousURL;
446     RefPtr<HistoryItem> m_requestedHistoryItem;
447 };
448
449 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
450 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
451 // the frame name references a frame different from the openerFrame, e.g. when it is
452 // "_self" or "_parent".
453 //
454 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
455 // and moving it to a more appropriate location.
456 PassRefPtr<Frame> createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
457
458 } // namespace WebCore
459
460 #endif // FrameLoader_h