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