https://bugs.webkit.org/show_bug.cgi?id=56425
[WebKit-https.git] / Source / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 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  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1.  Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer. 
12  * 2.  Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in the
14  *     documentation and/or other materials provided with the distribution. 
15  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
16  *     its contributors may be used to endorse or promote products derived
17  *     from this software without specific prior written permission. 
18  *
19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef FrameLoader_h
32 #define FrameLoader_h
33
34 #include "CachePolicy.h"
35 #include "FrameLoaderStateMachine.h"
36 #include "FrameLoaderTypes.h"
37 #include "HistoryController.h"
38 #include "IconDatabaseBase.h"
39 #include "PolicyChecker.h"
40 #include "ResourceLoadNotifier.h"
41 #include "SubframeLoader.h"
42 #include "ThreadableLoader.h"
43 #include "Timer.h"
44 #include <wtf/Forward.h>
45 #include <wtf/HashSet.h>
46
47 namespace WebCore {
48
49 class Archive;
50 class AuthenticationChallenge;
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 FormData;
60 class FormState;
61 class FormSubmission;
62 class Frame;
63 class FrameLoaderClient;
64 class FrameNetworkingContext;
65 class HistoryItem;
66 class HTMLFormElement;
67 class IconLoader;
68 class NavigationAction;
69 class NetworkingContext;
70 class Page;
71 class ProtectionSpace;
72 class ResourceError;
73 class ResourceLoader;
74 class ResourceRequest;
75 class ResourceResponse;
76 class ScriptSourceCode;
77 class ScriptValue;
78 class SecurityOrigin;
79 class SerializedScriptValue;
80 class SharedBuffer;
81 class SubstituteData;
82 class TextResourceDecoder;
83
84 struct FrameLoadRequest;
85 struct WindowFeatures;
86
87 bool isBackForwardLoadType(FrameLoadType);
88
89 class FrameLoader {
90     WTF_MAKE_NONCOPYABLE(FrameLoader);
91 public:
92     FrameLoader(Frame*, FrameLoaderClient*);
93     ~FrameLoader();
94
95     void init();
96
97     Frame* frame() const { return m_frame; }
98
99     PolicyChecker* policyChecker() const { return &m_policyChecker; }
100     HistoryController* history() const { return &m_history; }
101     ResourceLoadNotifier* notifier() const { return &m_notifer; }
102     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
103
104     // FIXME: This is not cool, people. There are too many different functions that all start loads.
105     // We should aim to consolidate these into a smaller set of functions, and try to reuse more of
106     // the logic by extracting common code paths.
107
108     void prepareForLoadStart();
109     void setupForReplace();
110     void setupForReplaceByMIMEType(const String& newMIMEType);
111
112     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
113
114     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
115         PassRefPtr<Event>, PassRefPtr<FormState>, ReferrerPolicy);
116
117     void load(const ResourceRequest&, bool lockHistory);                                        // Called by WebFrame, calls load(ResourceRequest, SubstituteData).
118     void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                 // Called both by WebFrame and internally, calls load(DocumentLoader*).
119     void load(const ResourceRequest&, const String& frameName, bool lockHistory);               // Called by WebPluginController.
120
121 #if ENABLE(WEB_ARCHIVE)
122     void loadArchive(PassRefPtr<Archive>);
123 #endif
124
125     static void reportLocalLoadFailed(Frame*, const String& url);
126
127     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
128
129     bool canHandleRequest(const ResourceRequest&);
130
131     // Also not cool.
132     void stopAllLoaders(ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
133     void stopForUserCancel(bool deferCheckLoadComplete = false);
134
135     bool isLoadingMainResource() const { return m_isLoadingMainResource; }
136     bool isLoading() const;
137     bool frameHasLoaded() const;
138     void transferLoadingResourcesFromPage(Page*);
139     void dispatchTransferLoadingResourceFromPage(unsigned long, DocumentLoader*, const ResourceRequest&, Page*);
140
141     int numPendingOrLoadingRequests(bool recurse) const;
142     String referrer() const;
143     String outgoingReferrer() const;
144     String outgoingOrigin() const;
145
146     DocumentLoader* activeDocumentLoader() const;
147     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
148     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
149     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
150     FrameState state() const { return m_state; }
151     static double timeOfLastCompletedLoad();
152
153     bool shouldUseCredentialStorage(ResourceLoader*);
154 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
155     bool canAuthenticateAgainstProtectionSpace(ResourceLoader* loader, const ProtectionSpace& protectionSpace);
156 #endif
157     const ResourceRequest& originalRequest() const;
158     const ResourceRequest& initialRequest() const;
159     void receivedMainResourceError(const ResourceError&, bool isComplete);
160
161     bool willLoadMediaElementURL(KURL&);
162
163     void handleFallbackContent();
164     bool isStopping() const;
165
166     void finishedLoading();
167
168     ResourceError cancelledError(const ResourceRequest&) const;
169     ResourceError fileDoesNotExistError(const ResourceResponse&) const;
170     ResourceError blockedError(const ResourceRequest&) const;
171     ResourceError cannotShowURLError(const ResourceRequest&) const;
172     ResourceError interruptionForPolicyChangeError(const ResourceRequest&) const;
173
174     bool isHostedByObjectElement() const;
175     bool isLoadingMainFrame() const;
176     bool canShowMIMEType(const String& MIMEType) const;
177     bool representationExistsForURLScheme(const String& URLScheme);
178     String generatedMIMETypeForURLScheme(const String& URLScheme);
179
180     void reload(bool endToEndReload = false);
181     void reloadWithOverrideEncoding(const String& overrideEncoding);
182
183     void didReceiveServerRedirectForProvisionalLoadForFrame();
184     void finishedLoadingDocument(DocumentLoader*);
185     bool isReplacing() const;
186     void setReplacing();
187     void revertToProvisional(DocumentLoader*);
188     void setMainDocumentError(DocumentLoader*, const ResourceError&);
189     void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
190     bool subframeIsLoading() const;
191     void willChangeTitle(DocumentLoader*);
192     void didChangeTitle(DocumentLoader*);
193     void didChangeIcons(DocumentLoader*);
194
195     FrameLoadType loadType() const;
196
197     CachePolicy subresourceCachePolicy() const;
198
199     void didFirstLayout();
200
201     void didFirstVisuallyNonEmptyLayout();
202
203     void loadedResourceFromMemoryCache(const CachedResource*);
204     void tellClientAboutPastMemoryCacheLoads();
205
206     void checkLoadComplete();
207     void detachFromParent();
208     void detachViewsAndDocumentLoader();
209
210     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
211     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
212     
213     static void addHTTPOriginIfNeeded(ResourceRequest&, String origin);
214
215     FrameLoaderClient* client() const { return m_client; }
216
217     void setDefersLoading(bool);
218
219     void changeLocation(PassRefPtr<SecurityOrigin>, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
220     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy);
221
222     void submitForm(PassRefPtr<FormSubmission>);
223
224     void stop();
225     void stopLoading(UnloadEventPolicy);
226     bool closeURL();
227
228     void didExplicitOpen();
229
230     // Callbacks from DocumentWriter
231     void didBeginDocument(bool dispatchWindowObjectAvailable);
232     void didEndDocument();
233     void willSetEncoding();
234
235     KURL iconURL();
236     void commitIconURLToIconDatabase(const KURL&);
237
238     KURL baseURL() const;
239
240     void handledOnloadEvents();
241     String userAgent(const KURL&) const;
242
243     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
244     void dispatchDidClearWindowObjectsInAllWorlds();
245     void dispatchDocumentElementAvailable();
246
247     void ownerElementSandboxFlagsChanged() { updateSandboxFlags(); }
248
249     bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
250     SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
251     // The following sandbox flags will be forced, regardless of changes to
252     // the sandbox attribute of any parent frames.
253     void setForcedSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags = flags; m_sandboxFlags |= flags; }
254
255     // Mixed content related functions.
256     static bool isMixedContent(SecurityOrigin* context, const KURL&);
257     void checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
258     void checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
259
260     Frame* opener();
261     void setOpener(Frame*);
262
263     bool isProcessingUserGesture();
264
265     void resetMultipleFormSubmissionProtection();
266
267     void checkCallImplicitClose();
268
269     void frameDetached();
270
271     void setOutgoingReferrer(const KURL&);
272
273     void loadDone();
274     void finishedParsing();
275     void checkCompleted();
276
277     void checkDidPerformFirstNavigation();
278
279     bool isComplete() const;
280
281     KURL completeURL(const String& url);
282
283     void cancelAndClear();
284
285     void setTitle(const String&);
286     void setIconURL(const String&);
287
288     void commitProvisionalLoad();
289     bool isLoadingFromCachedPage() const { return m_loadingFromCachedPage; }
290
291     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
292
293     void startIconLoader();
294     void iconLoadDecisionReceived(IconLoadDecision);
295     void continueIconLoadWithDecision(IconLoadDecision);
296
297     bool shouldAllowNavigation(Frame* targetFrame) const;
298     Frame* findFrameForNavigation(const AtomicString& name);
299
300     void applyUserAgent(ResourceRequest& request);
301
302     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
303
304     void open(CachedFrameBase&);
305
306 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
307     void hideMediaPlayerProxyPlugin(Widget*);
308     void showMediaPlayerProxyPlugin(Widget*);
309 #endif
310
311     // FIXME: Should these really be public?
312     void completed();
313     bool allAncestorsAreComplete() const; // including this
314     bool allChildrenAreComplete() const; // immediate children, not all descendants
315     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
316     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
317     void loadItem(HistoryItem*, FrameLoadType);
318
319     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
320     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
321     // introduce a proper callback type for this function, we should make it private again.
322     void continueLoadAfterWillSubmitForm();
323     
324     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
325
326     static ObjectContentType defaultObjectContentType(const KURL& url, const String& mimeType);
327
328     void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
329
330     bool quickRedirectComing() const { return m_quickRedirectComing; }
331
332     bool shouldClose();
333     
334     void started();
335
336     bool pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
337
338     NetworkingContext* networkingContext() const;
339
340 private:
341     void checkTimerFired(Timer<FrameLoader>*);
342     
343     void loadSameDocumentItem(HistoryItem*);
344     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
345     
346     void loadProvisionalItemFromCachedPage();
347
348     void receivedFirstData();
349
350     void updateFirstPartyForCookies();
351     void setFirstPartyForCookies(const KURL&);
352     
353     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
354
355     // Also not cool.
356     void stopLoadingSubframes(ClearProvisionalItemPolicy);
357
358     void clearProvisionalLoad();
359     void markLoadComplete();
360     void transitionToCommitted(PassRefPtr<CachedPage>);
361     void frameLoadCompleted();
362
363     void mainReceivedError(const ResourceError&, bool isComplete);
364
365     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
366     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
367     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
368     
369     bool fireBeforeUnloadEvent(Chrome*);
370
371     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
372     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
373     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
374
375     bool shouldScrollToAnchor(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
376
377     void checkLoadCompleteForThisFrame();
378
379     void setDocumentLoader(DocumentLoader*);
380     void setPolicyDocumentLoader(DocumentLoader*);
381     void setProvisionalDocumentLoader(DocumentLoader*);
382
383     void setState(FrameState);
384
385     void closeOldDataSources();
386     void prepareForCachedPageRestore();
387
388     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
389
390     void dispatchDidCommitLoad();
391
392     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy, ShouldReplaceDocumentIfJavaScriptURL);
393
394     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
395     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
396
397     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
398         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
399
400     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
401         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
402     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
403         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
404
405     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
406
407     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
408
409     void recursiveCheckLoadComplete();
410
411     void detachChildren();
412     void closeAndRemoveChild(Frame*);
413
414     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
415
416     void provisionalLoadStarted();
417
418     bool didOpenURL(const KURL&);
419
420     void scheduleCheckCompleted();
421     void scheduleCheckLoadComplete();
422     void startCheckCompleteTimer();
423
424     KURL originalRequestURL() const;
425
426     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
427
428     void updateSandboxFlags();
429
430     Frame* m_frame;
431     FrameLoaderClient* m_client;
432
433     mutable PolicyChecker m_policyChecker;
434     mutable HistoryController m_history;
435     mutable ResourceLoadNotifier m_notifer;
436     mutable SubframeLoader m_subframeLoader;
437     mutable FrameLoaderStateMachine m_stateMachine;
438
439     FrameState m_state;
440     FrameLoadType m_loadType;
441
442     // Document loaders for the three phases of frame loading. Note that while 
443     // a new request is being loaded, the old document loader may still be referenced.
444     // E.g. while a new request is in the "policy" state, the old document loader may
445     // be consulted in particular as it makes sense to imply certain settings on the new loader.
446     RefPtr<DocumentLoader> m_documentLoader;
447     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
448     RefPtr<DocumentLoader> m_policyDocumentLoader;
449
450     bool m_delegateIsHandlingProvisionalLoadError;
451
452     bool m_quickRedirectComing;
453     bool m_sentRedirectNotification;
454     bool m_inStopAllLoaders;
455
456     String m_outgoingReferrer;
457
458     bool m_isExecutingJavaScriptFormAction;
459
460     bool m_didCallImplicitClose;
461     bool m_wasUnloadEventEmitted;
462     bool m_pageDismissalEventBeingDispatched;
463     bool m_isComplete;
464     bool m_isLoadingMainResource;
465
466     RefPtr<SerializedScriptValue> m_pendingStateObject;
467
468     KURL m_workingURL;
469
470     OwnPtr<IconLoader> m_iconLoader;
471     bool m_mayLoadIconLater;
472
473     bool m_needsClear;
474
475     KURL m_submittedFormURL;
476
477     Timer<FrameLoader> m_checkTimer;
478     bool m_shouldCallCheckCompleted;
479     bool m_shouldCallCheckLoadComplete;
480
481     Frame* m_opener;
482     HashSet<Frame*> m_openedFrames;
483
484     bool m_didPerformFirstNavigation;
485     bool m_loadingFromCachedPage;
486     bool m_suppressOpenerInNewFrame;
487
488     SandboxFlags m_sandboxFlags;
489     SandboxFlags m_forcedSandboxFlags;
490
491     RefPtr<FrameNetworkingContext> m_networkingContext;
492
493     KURL m_previousUrl;
494 };
495
496 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
497 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
498 // the frame name references a frame different from the openerFrame, e.g. when it is
499 // "_self" or "_parent".
500 //
501 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
502 // and moving it to a more appropriate location.
503 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
504
505 } // namespace WebCore
506
507 #endif // FrameLoader_h