Cached Page and Frame don't need to be ref-counted.
[WebKit-https.git] / Source / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2011, 2013 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 PageActivityAssertionToken;
70 class PolicyChecker;
71 class ResourceError;
72 class ResourceRequest;
73 class ResourceResponse;
74 class SecurityOrigin;
75 class SerializedScriptValue;
76 class StringWithDirection;
77 class SubstituteData;
78
79 struct FrameLoadRequest;
80 struct WindowFeatures;
81
82 bool isBackForwardLoadType(FrameLoadType);
83
84 class FrameLoader {
85     WTF_MAKE_NONCOPYABLE(FrameLoader);
86 public:
87     FrameLoader(Frame&, FrameLoaderClient&);
88     ~FrameLoader();
89
90     void init();
91
92     Frame& frame() const { return m_frame; }
93
94     PolicyChecker* policyChecker() const { return m_policyChecker.get(); }
95     HistoryController& history() const { return *m_history; }
96     ResourceLoadNotifier* notifier() const { return &m_notifer; }
97     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
98     IconController* icon() const { return m_icon.get(); }
99     MixedContentChecker* mixedContentChecker() const { return &m_mixedContentChecker; }
100
101     void prepareForHistoryNavigation();
102     void setupForReplace();
103
104     // FIXME: These are all functions which start loads. We have too many.
105     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
106     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
107         PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer);
108
109     void load(const FrameLoadRequest&);
110
111 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
112     void loadArchive(PassRefPtr<Archive>);
113 #endif
114     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data);
115
116     void changeLocation(SecurityOrigin*, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
117     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer);
118     void submitForm(PassRefPtr<FormSubmission>);
119
120     void reload(bool endToEndReload = false);
121     void reloadWithOverrideEncoding(const String& overrideEncoding);
122     void reloadWithOverrideURL(const KURL& overrideUrl, bool endToEndReload = false);
123
124     void open(CachedFrameBase&);
125     void loadItem(HistoryItem*, FrameLoadType);
126     HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
127
128     void retryAfterFailedCacheOnlyMainResourceLoad();
129
130     static void reportLocalLoadFailed(Frame*, const String& url);
131
132     // FIXME: These are all functions which stop loads. We have too many.
133     void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
134     void stopForUserCancel(bool deferCheckLoadComplete = false);
135     void stop();
136     void stopLoading(UnloadEventPolicy);
137     bool closeURL();
138     void cancelAndClear();
139     // FIXME: clear() is trying to do too many things. We should break it down into smaller functions (ideally with fewer raw Boolean parameters).
140     void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
141
142     bool isLoading() const;
143     bool frameHasLoaded() const;
144
145     int numPendingOrLoadingRequests(bool recurse) const;
146     String referrer() const;
147     String outgoingReferrer() const;
148     String outgoingOrigin() const;
149
150     DocumentLoader* activeDocumentLoader() const;
151     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
152     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
153     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
154     FrameState state() const { return m_state; }
155     static double timeOfLastCompletedLoad();
156
157     const ResourceRequest& originalRequest() const;
158     const ResourceRequest& initialRequest() const;
159     void receivedMainResourceError(const ResourceError&);
160
161     bool willLoadMediaElementURL(KURL&);
162
163     void handleFallbackContent();
164
165     ResourceError cancelledError(const ResourceRequest&) const;
166
167     bool isHostedByObjectElement() const;
168     bool isLoadingMainFrame() const;
169
170     bool isReplacing() const;
171     void setReplacing();
172     bool subframeIsLoading() const;
173     void willChangeTitle(DocumentLoader*);
174     void didChangeTitle(DocumentLoader*);
175     void didChangeIcons(IconType);
176
177     bool shouldTreatURLAsSrcdocDocument(const KURL&) const;
178
179     FrameLoadType loadType() const;
180
181     CachePolicy subresourceCachePolicy() const;
182
183     void didLayout(LayoutMilestones);
184     void didFirstLayout();
185
186     void loadedResourceFromMemoryCache(CachedResource*, ResourceRequest& newRequest);
187     void tellClientAboutPastMemoryCacheLoads();
188
189     void checkLoadComplete();
190     void detachFromParent();
191     void detachViewsAndDocumentLoader();
192
193     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
194     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
195     
196     static void addHTTPOriginIfNeeded(ResourceRequest&, const String& origin);
197
198     FrameLoaderClient& client() const { return m_client; }
199
200     void setDefersLoading(bool);
201
202     void didExplicitOpen();
203
204     // Callbacks from DocumentWriter
205     void didBeginDocument(bool dispatchWindowObjectAvailable);
206
207     void receivedFirstData();
208
209     void handledOnloadEvents();
210     String userAgent(const KURL&) const;
211
212     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
213     void dispatchDidClearWindowObjectsInAllWorlds();
214     void dispatchDocumentElementAvailable();
215
216     // The following sandbox flags will be forced, regardless of changes to
217     // the sandbox attribute of any parent frames.
218     void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
219     SandboxFlags effectiveSandboxFlags() const;
220
221     bool checkIfFormActionAllowedByCSP(const KURL&) const;
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 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&, unsigned long requestIdentifier);
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     void loadProgressingStatusChanged();
285
286     const KURL& previousURL() const { return m_previousURL; }
287
288     void forcePageTransitionIfNeeded();
289
290 private:
291     enum FormSubmissionCacheLoadPolicy {
292         MayAttemptCacheOnlyLoadForFormSubmissionItem,
293         MayNotAttemptCacheOnlyLoadForFormSubmissionItem
294     };
295
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, FormSubmissionCacheLoadPolicy);
302     
303     void loadProvisionalItemFromCachedPage();
304
305     void updateFirstPartyForCookies();
306     void setFirstPartyForCookies(const KURL&);
307     
308     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
309
310     void clearProvisionalLoad();
311     void transitionToCommitted(CachedPage*);
312     void frameLoadCompleted();
313
314     SubstituteData defaultSubstituteDataForURL(const KURL&);
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 handleBeforeUnloadEvent(Chrome&, FrameLoader* frameLoaderBeingNavigated);
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 shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
327     void scrollToFragmentWithParentBoundary(const KURL&);
328
329     void checkLoadCompleteForThisFrame();
330
331     void setDocumentLoader(DocumentLoader*);
332     void setPolicyDocumentLoader(DocumentLoader*);
333     void setProvisionalDocumentLoader(DocumentLoader*);
334
335     void setState(FrameState);
336
337     void closeOldDataSources();
338     void prepareForCachedPageRestore();
339
340     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
341
342     void dispatchDidCommitLoad();
343
344     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ShouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL);
345
346     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
347     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
348
349     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
350         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
351
352     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
353         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
354     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
355         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
356
357     void reloadWithRequest(const ResourceRequest&, bool endToEndReload);
358
359     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
360
361     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
362
363     void detachChildren();
364     void closeAndRemoveChild(Frame*);
365
366     void loadInSameDocument(const KURL&, PassRefPtr<SerializedScriptValue> stateObject, bool isNewNavigation);
367
368     void prepareForLoadStart();
369     void provisionalLoadStarted();
370
371     void willTransitionToCommitted();
372     bool didOpenURL();
373
374     void scheduleCheckCompleted();
375     void scheduleCheckLoadComplete();
376     void startCheckCompleteTimer();
377
378     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
379
380     void dispatchGlobalObjectAvailableInAllWorlds();
381
382     Frame& m_frame;
383     FrameLoaderClient& m_client;
384
385     // FIXME: These should be OwnPtr<T> to reduce build times and simplify
386     // header dependencies unless performance testing proves otherwise.
387     // Some of these could be lazily created for memory savings on devices.
388     OwnPtr<PolicyChecker> m_policyChecker;
389     const OwnPtr<HistoryController> m_history;
390     mutable ResourceLoadNotifier m_notifer;
391     mutable SubframeLoader m_subframeLoader;
392     mutable FrameLoaderStateMachine m_stateMachine;
393     OwnPtr<IconController> m_icon;
394     mutable MixedContentChecker m_mixedContentChecker;
395
396     class FrameProgressTracker;
397     OwnPtr<FrameProgressTracker> m_progressTracker;
398
399     FrameState m_state;
400     FrameLoadType m_loadType;
401
402     // Document loaders for the three phases of frame loading. Note that while 
403     // a new request is being loaded, the old document loader may still be referenced.
404     // E.g. while a new request is in the "policy" state, the old document loader may
405     // be consulted in particular as it makes sense to imply certain settings on the new loader.
406     RefPtr<DocumentLoader> m_documentLoader;
407     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
408     RefPtr<DocumentLoader> m_policyDocumentLoader;
409
410     bool m_delegateIsHandlingProvisionalLoadError;
411
412     bool m_quickRedirectComing;
413     bool m_sentRedirectNotification;
414     bool m_inStopAllLoaders;
415
416     String m_outgoingReferrer;
417
418     bool m_isExecutingJavaScriptFormAction;
419
420     bool m_didCallImplicitClose;
421     bool m_wasUnloadEventEmitted;
422     PageDismissalType m_pageDismissalEventBeingDispatched;
423     bool m_isComplete;
424
425     RefPtr<SerializedScriptValue> m_pendingStateObject;
426
427     bool m_needsClear;
428
429     KURL m_submittedFormURL;
430
431     Timer<FrameLoader> m_checkTimer;
432     bool m_shouldCallCheckCompleted;
433     bool m_shouldCallCheckLoadComplete;
434
435     Frame* m_opener;
436     HashSet<Frame*> m_openedFrames;
437
438     bool m_didPerformFirstNavigation;
439     bool m_loadingFromCachedPage;
440     bool m_suppressOpenerInNewFrame;
441     
442     bool m_currentNavigationHasShownBeforeUnloadConfirmPanel;
443
444     SandboxFlags m_forcedSandboxFlags;
445
446     RefPtr<FrameNetworkingContext> m_networkingContext;
447
448     KURL m_previousURL;
449     RefPtr<HistoryItem> m_requestedHistoryItem;
450     OwnPtr<PageActivityAssertionToken> m_activityAssertion;
451 };
452
453 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
454 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
455 // the frame name references a frame different from the openerFrame, e.g. when it is
456 // "_self" or "_parent".
457 //
458 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
459 // and moving it to a more appropriate location.
460 PassRefPtr<Frame> createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
461
462 } // namespace WebCore
463
464 #endif // FrameLoader_h