2011-06-12 Adam Barth <abarth@webkit.org>
[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 "IconURL.h"
40 #include "PolicyChecker.h"
41 #include "ResourceLoadNotifier.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) || ENABLE(MHTML)
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     // 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     const ResourceRequest& originalRequest() const;
154     const ResourceRequest& initialRequest() const;
155     void receivedMainResourceError(const ResourceError&, bool isComplete);
156
157     bool willLoadMediaElementURL(KURL&);
158
159     void handleFallbackContent();
160     bool isStopping() const;
161
162     void finishedLoading();
163
164     // FIXME: Move this method to ResourceLoader with the rest of the ResourceError accessors.
165     ResourceError cancelledError(const ResourceRequest&) const;
166
167     bool isHostedByObjectElement() const;
168     bool isLoadingMainFrame() const;
169
170     void reload(bool endToEndReload = false);
171     void reloadWithOverrideEncoding(const String& overrideEncoding);
172
173     void finishedLoadingDocument(DocumentLoader*);
174     bool isReplacing() const;
175     void setReplacing();
176     void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
177     bool subframeIsLoading() const;
178     void willChangeTitle(DocumentLoader*);
179     void didChangeTitle(DocumentLoader*);
180     void didChangeIcons(DocumentLoader*, IconType);
181
182     FrameLoadType loadType() const;
183
184     CachePolicy subresourceCachePolicy() const;
185
186     void didFirstLayout();
187
188     void didFirstVisuallyNonEmptyLayout();
189
190     void loadedResourceFromMemoryCache(const CachedResource*);
191     void tellClientAboutPastMemoryCacheLoads();
192
193     void checkLoadComplete();
194     void detachFromParent();
195     void detachViewsAndDocumentLoader();
196
197     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
198     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
199     
200     static void addHTTPOriginIfNeeded(ResourceRequest&, String origin);
201
202     FrameLoaderClient* client() const { return m_client; }
203
204     void setDefersLoading(bool);
205
206     void changeLocation(PassRefPtr<SecurityOrigin>, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
207     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy);
208
209     void submitForm(PassRefPtr<FormSubmission>);
210
211     void stop();
212     void stopLoading(UnloadEventPolicy);
213     bool closeURL();
214
215     void didExplicitOpen();
216
217     // Callbacks from DocumentWriter
218     void didBeginDocument(bool dispatchWindowObjectAvailable);
219     void didEndDocument();
220     void willSetEncoding();
221
222     // Returns favicon.
223     KURL iconURL();
224
225     // Returns the given iconTypes' IconURLs, iconTypes could be any combination of IconType.
226     IconURLs iconURLs(int iconTypes);
227     void commitIconURLToIconDatabase(const KURL&);
228
229     KURL baseURL() const;
230
231     void handledOnloadEvents();
232     String userAgent(const KURL&) const;
233
234     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
235     void dispatchDidClearWindowObjectsInAllWorlds();
236     void dispatchDocumentElementAvailable();
237
238     void ownerElementSandboxFlagsChanged() { updateSandboxFlags(); }
239
240     bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
241     SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
242     // The following sandbox flags will be forced, regardless of changes to
243     // the sandbox attribute of any parent frames.
244     void setForcedSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags = flags; m_sandboxFlags |= flags; }
245
246     // Mixed content related functions.
247     static bool isMixedContent(SecurityOrigin* context, const KURL&);
248     bool checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
249     bool checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
250
251     Frame* opener();
252     void setOpener(Frame*);
253
254     bool isProcessingUserGesture();
255
256     void resetMultipleFormSubmissionProtection();
257
258     void checkCallImplicitClose();
259
260     void frameDetached();
261
262     void setOutgoingReferrer(const KURL&);
263
264     void loadDone();
265     void finishedParsing();
266     void checkCompleted();
267
268     void checkDidPerformFirstNavigation();
269
270     bool isComplete() const;
271
272     KURL completeURL(const String& url);
273
274     void cancelAndClear();
275
276     void setTitle(const StringWithDirection&);
277     void setIconURL(const IconURL&);
278
279     void commitProvisionalLoad();
280     bool isLoadingFromCachedPage() const { return m_loadingFromCachedPage; }
281
282     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
283
284     void startIconLoader();
285     void iconLoadDecisionReceived(IconLoadDecision);
286     void continueIconLoadWithDecision(IconLoadDecision);
287
288     bool shouldAllowNavigation(Frame* targetFrame) const;
289     Frame* findFrameForNavigation(const AtomicString& name);
290
291     void applyUserAgent(ResourceRequest& request);
292
293     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
294
295     void open(CachedFrameBase&);
296
297     // FIXME: Should these really be public?
298     void completed();
299     bool allAncestorsAreComplete() const; // including this
300     bool allChildrenAreComplete() const; // immediate children, not all descendants
301     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
302     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
303     void loadItem(HistoryItem*, FrameLoadType);
304
305     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
306     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
307     // introduce a proper callback type for this function, we should make it private again.
308     void continueLoadAfterWillSubmitForm();
309     
310     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
311
312     static ObjectContentType defaultObjectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages);
313
314     void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
315
316     bool quickRedirectComing() const { return m_quickRedirectComing; }
317
318     bool shouldClose();
319     
320     void started();
321
322     bool pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
323
324     NetworkingContext* networkingContext() const;
325
326 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
327     Archive* archive() const { return m_archive.get(); }
328 #endif
329
330 private:
331     void checkTimerFired(Timer<FrameLoader>*);
332     
333     void loadSameDocumentItem(HistoryItem*);
334     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
335     
336     void loadProvisionalItemFromCachedPage();
337
338     void receivedFirstData();
339
340     void updateFirstPartyForCookies();
341     void setFirstPartyForCookies(const KURL&);
342     
343     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
344
345     // Also not cool.
346     void stopLoadingSubframes(ClearProvisionalItemPolicy);
347
348     void clearProvisionalLoad();
349     void markLoadComplete();
350     void transitionToCommitted(PassRefPtr<CachedPage>);
351     void frameLoadCompleted();
352
353     void mainReceivedError(const ResourceError&, bool isComplete);
354
355     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
356     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
357     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
358     
359     bool fireBeforeUnloadEvent(Chrome*);
360
361     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
362     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
363     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
364
365     bool shouldScrollToAnchor(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
366
367     void checkLoadCompleteForThisFrame();
368
369     void setDocumentLoader(DocumentLoader*);
370     void setPolicyDocumentLoader(DocumentLoader*);
371     void setProvisionalDocumentLoader(DocumentLoader*);
372
373     void setState(FrameState);
374
375     void closeOldDataSources();
376     void prepareForCachedPageRestore();
377
378     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
379
380     void dispatchDidCommitLoad();
381
382     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy, ShouldReplaceDocumentIfJavaScriptURL);
383
384     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
385     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
386
387     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
388         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
389
390     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
391         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
392     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
393         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
394
395     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
396
397     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
398
399     void recursiveCheckLoadComplete();
400
401     void detachChildren();
402     void closeAndRemoveChild(Frame*);
403
404     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
405
406     void provisionalLoadStarted();
407
408     bool didOpenURL(const KURL&);
409
410     void scheduleCheckCompleted();
411     void scheduleCheckLoadComplete();
412     void startCheckCompleteTimer();
413
414     KURL originalRequestURL() const;
415
416     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
417
418     void updateSandboxFlags();
419
420     bool fillIconURL(IconType, IconURLs*);
421     IconURL getDefaultIconURL(IconType);
422
423     Frame* m_frame;
424     FrameLoaderClient* m_client;
425
426     mutable PolicyChecker m_policyChecker;
427     mutable HistoryController m_history;
428     mutable ResourceLoadNotifier m_notifer;
429     mutable SubframeLoader m_subframeLoader;
430     mutable FrameLoaderStateMachine m_stateMachine;
431
432     FrameState m_state;
433     FrameLoadType m_loadType;
434
435     // Document loaders for the three phases of frame loading. Note that while 
436     // a new request is being loaded, the old document loader may still be referenced.
437     // E.g. while a new request is in the "policy" state, the old document loader may
438     // be consulted in particular as it makes sense to imply certain settings on the new loader.
439     RefPtr<DocumentLoader> m_documentLoader;
440     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
441     RefPtr<DocumentLoader> m_policyDocumentLoader;
442
443     bool m_delegateIsHandlingProvisionalLoadError;
444
445     bool m_quickRedirectComing;
446     bool m_sentRedirectNotification;
447     bool m_inStopAllLoaders;
448
449     String m_outgoingReferrer;
450
451     bool m_isExecutingJavaScriptFormAction;
452
453     bool m_didCallImplicitClose;
454     bool m_wasUnloadEventEmitted;
455     bool m_pageDismissalEventBeingDispatched;
456     bool m_isComplete;
457     bool m_isLoadingMainResource;
458
459     RefPtr<SerializedScriptValue> m_pendingStateObject;
460
461     KURL m_workingURL;
462
463     OwnPtr<IconLoader> m_iconLoader;
464     bool m_mayLoadIconLater;
465
466     bool m_needsClear;
467
468     KURL m_submittedFormURL;
469
470     Timer<FrameLoader> m_checkTimer;
471     bool m_shouldCallCheckCompleted;
472     bool m_shouldCallCheckLoadComplete;
473
474     Frame* m_opener;
475     HashSet<Frame*> m_openedFrames;
476
477     bool m_didPerformFirstNavigation;
478     bool m_loadingFromCachedPage;
479     bool m_suppressOpenerInNewFrame;
480
481     SandboxFlags m_sandboxFlags;
482     SandboxFlags m_forcedSandboxFlags;
483
484     RefPtr<FrameNetworkingContext> m_networkingContext;
485
486 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
487     RefPtr<Archive> m_archive;
488 #endif
489
490     KURL m_previousUrl;
491 };
492
493 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
494 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
495 // the frame name references a frame different from the openerFrame, e.g. when it is
496 // "_self" or "_parent".
497 //
498 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
499 // and moving it to a more appropriate location.
500 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
501
502 } // namespace WebCore
503
504 #endif // FrameLoader_h