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 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
48namespace WebCore {
49
50class Archive;
51class CachedFrameBase;
52class CachedPage;
53class CachedResource;
54class Chrome;
55class DOMWrapperWorld;
56class Document;
57class DocumentLoader;
58class Event;
59class FormState;
60class FormSubmission;
61class FrameLoaderClient;
62class FrameNetworkingContext;
63class HistoryController;
64class HistoryItem;
65class IconController;
66class NavigationAction;
67class NetworkingContext;
68class Page;
69class PageActivityAssertionToken;
70class PolicyChecker;
71class ResourceError;
72class ResourceRequest;
73class ResourceResponse;
74class SecurityOrigin;
75class SerializedScriptValue;
76class StringWithDirection;
77class SubframeLoader;
78class SubstituteData;
79
80struct FrameLoadRequest;
81struct WindowFeatures;
82
83bool isBackForwardLoadType(FrameLoadType);
84
85class FrameLoader {
86    WTF_MAKE_NONCOPYABLE(FrameLoader);
87public:
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&, LockHistory, LockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
111        PassRefPtr<Event>, PassRefPtr<FormState>, ShouldSendReferrer, AllowNavigationToInvalidURL);
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, LockHistory = LockHistory::Yes,
121        LockBackForwardList = LockBackForwardList::Yes, bool refresh = false, AllowNavigationToInvalidURL = AllowNavigationToInvalidURL::Yes);
122    void urlSelected(const URL&, const String& target, PassRefPtr<Event>, LockHistory, LockBackForwardList, ShouldSendReferrer);
123    void submitForm(PassRefPtr<FormSubmission>);
124
125    void reload(bool endToEndReload = false);
126    void reloadWithOverrideEncoding(const String& overrideEncoding);
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
220    // The following sandbox flags will be forced, regardless of changes to
221    // the sandbox attribute of any parent frames.
222    void forceSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags |= flags; }
223    SandboxFlags effectiveSandboxFlags() const;
224
225    bool checkIfFormActionAllowedByCSP(const URL&) const;
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 URL&);
237
238    void loadDone();
239    void finishedParsing();
240    void checkCompleted();
241
242    bool isComplete() const;
243
244    void commitProvisionalLoad();
245
246    void setLoadsSynchronously(bool loadsSynchronously) { m_loadsSynchronously = loadsSynchronously; }
247    bool loadsSynchronously() const { return m_loadsSynchronously; }
248
249    FrameLoaderStateMachine& stateMachine() { return m_stateMachine; }
250
251    Frame* findFrameForNavigation(const AtomicString& name, Document* activeDocument = 0);
252
253    void applyUserAgent(ResourceRequest&);
254
255    bool shouldInterruptLoadForXFrameOptions(const String&, const URL&, unsigned long requestIdentifier);
256
257    void completed();
258    bool allAncestorsAreComplete() const; // including this
259    void clientRedirected(const URL&, double delay, double fireDate, LockBackForwardList);
260    void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
261
262    // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
263    // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
264    // introduce a proper callback type for this function, we should make it private again.
265    void continueLoadAfterWillSubmitForm();
266
267    void setOriginalURLForDownloadRequest(ResourceRequest&);
268
269    bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
270
271    static ObjectContentType defaultObjectContentType(const URL&, const String& mimeType, bool shouldPreferPlugInsForImages);
272
273    bool quickRedirectComing() const { return m_quickRedirectComing; }
274
275    bool shouldClose();
276
277    void started();
278
279    enum PageDismissalType {
280        NoDismissal = 0,
281        BeforeUnloadDismissal = 1,
282        PageHideDismissal = 2,
283        UnloadDismissal = 3
284    };
285    PageDismissalType pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
286
287    NetworkingContext* networkingContext() const;
288
289    void loadProgressingStatusChanged();
290
291    const URL& previousURL() const { return m_previousURL; }
292
293    void forcePageTransitionIfNeeded();
294
295private:
296    enum FormSubmissionCacheLoadPolicy {
297        MayAttemptCacheOnlyLoadForFormSubmissionItem,
298        MayNotAttemptCacheOnlyLoadForFormSubmissionItem
299    };
300
301    bool allChildrenAreComplete() const; // immediate children, not all descendants
302
303    void checkTimerFired(Timer<FrameLoader>&);
304
305    void loadSameDocumentItem(HistoryItem*);
306    void loadDifferentDocumentItem(HistoryItem*, FrameLoadType, FormSubmissionCacheLoadPolicy);
307
308    void loadProvisionalItemFromCachedPage();
309
310    void updateFirstPartyForCookies();
311    void setFirstPartyForCookies(const URL&);
312
313    void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
314
315    void clearProvisionalLoad();
316    void transitionToCommitted(CachedPage*);
317    void frameLoadCompleted();
318
319    SubstituteData defaultSubstituteDataForURL(const URL&);
320
321    bool handleBeforeUnloadEvent(Chrome&, FrameLoader* frameLoaderBeingNavigated);
322
323    void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue, AllowNavigationToInvalidURL);
324    void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue, AllowNavigationToInvalidURL);
325    void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
326
327    bool shouldPerformFragmentNavigation(bool isFormSubmission, const String& httpMethod, FrameLoadType, const URL&);
328    void scrollToFragmentWithParentBoundary(const URL&);
329
330    void checkLoadCompleteForThisFrame();
331
332    void setDocumentLoader(DocumentLoader*);
333    void setPolicyDocumentLoader(DocumentLoader*);
334    void setProvisionalDocumentLoader(DocumentLoader*);
335
336    void setState(FrameState);
337
338    void closeOldDataSources();
339    void prepareForCachedPageRestore();
340
341    bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
342
343    void dispatchDidCommitLoad();
344
345    void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, LockHistory, LockBackForwardList, ShouldSendReferrer, ShouldReplaceDocumentIfJavaScriptURL, AllowNavigationToInvalidURL);
346
347    void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>, AllowNavigationToInvalidURL); // Calls continueLoadAfterNavigationPolicy
348    void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader
349
350    void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
351        LockHistory, FrameLoadType, PassRefPtr<FormState>, AllowNavigationToInvalidURL);
352
353    void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
354        const String& frameName, LockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>, AllowNavigationToInvalidURL);
355    void loadURL(const URL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
356        LockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>, AllowNavigationToInvalidURL);
357
358    bool shouldReload(const URL& currentURL, const URL& destinationURL);
359
360    void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
361
362    void detachChildren();
363    void closeAndRemoveChild(Frame*);
364
365    void loadInSameDocument(const URL&, 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 URL&) const;
378
379    void dispatchGlobalObjectAvailableInAllWorlds();
380
381    Frame& m_frame;
382    FrameLoaderClient& m_client;
383
384    const std::unique_ptr<PolicyChecker> m_policyChecker;
385    const std::unique_ptr<HistoryController> m_history;
386    mutable ResourceLoadNotifier m_notifier;
387    const std::unique_ptr<SubframeLoader> m_subframeLoader;
388    mutable FrameLoaderStateMachine m_stateMachine;
389    const std::unique_ptr<IconController> m_icon;
390    mutable MixedContentChecker m_mixedContentChecker;
391
392    class FrameProgressTracker;
393    std::unique_ptr<FrameProgressTracker> m_progressTracker;
394
395    FrameState m_state;
396    FrameLoadType m_loadType;
397
398    // Document loaders for the three phases of frame loading. Note that while
399    // a new request is being loaded, the old document loader may still be referenced.
400    // E.g. while a new request is in the "policy" state, the old document loader may
401    // be consulted in particular as it makes sense to imply certain settings on the new loader.
402    RefPtr<DocumentLoader> m_documentLoader;
403    RefPtr<DocumentLoader> m_provisionalDocumentLoader;
404    RefPtr<DocumentLoader> m_policyDocumentLoader;
405
406    bool m_delegateIsHandlingProvisionalLoadError;
407
408    bool m_quickRedirectComing;
409    bool m_sentRedirectNotification;
410    bool m_inStopAllLoaders;
411
412    String m_outgoingReferrer;
413
414    bool m_isExecutingJavaScriptFormAction;
415
416    bool m_didCallImplicitClose;
417    bool m_wasUnloadEventEmitted;
418    PageDismissalType m_pageDismissalEventBeingDispatched;
419    bool m_isComplete;
420
421    RefPtr<SerializedScriptValue> m_pendingStateObject;
422
423    bool m_needsClear;
424
425    URL m_submittedFormURL;
426
427    Timer<FrameLoader> m_checkTimer;
428    bool m_shouldCallCheckCompleted;
429    bool m_shouldCallCheckLoadComplete;
430
431    Frame* m_opener;
432    HashSet<Frame*> m_openedFrames;
433
434    bool m_loadingFromCachedPage;
435    bool m_suppressOpenerInNewFrame;
436
437    bool m_currentNavigationHasShownBeforeUnloadConfirmPanel;
438
439    bool m_loadsSynchronously;
440
441    SandboxFlags m_forcedSandboxFlags;
442
443    RefPtr<FrameNetworkingContext> m_networkingContext;
444
445    URL m_previousURL;
446    RefPtr<HistoryItem> m_requestedHistoryItem;
447    std::unique_ptr<PageActivityAssertionToken> m_activityAssertion;
448};
449
450// This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
451// modal dialog creation.  The lookupFrame is for looking up the frame name in case
452// the frame name references a frame different from the openerFrame, e.g. when it is
453// "_self" or "_parent".
454//
455// FIXME: Consider making this function part of an appropriate class (not FrameLoader)
456// and moving it to a more appropriate location.
457PassRefPtr<Frame> createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
458
459} // namespace WebCore
460
461#endif // FrameLoader_h
462