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