2011-05-24 Jay Civelli <jcivelli@chromium.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     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*, IconType);
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     // Returns favicon.
238     KURL iconURL();
239
240     // Returns the given iconTypes' IconURLs, iconTypes could be any combination of IconType.
241     IconURLs iconURLs(int iconTypes);
242     void commitIconURLToIconDatabase(const KURL&);
243
244     KURL baseURL() const;
245
246     void handledOnloadEvents();
247     String userAgent(const KURL&) const;
248
249     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
250     void dispatchDidClearWindowObjectsInAllWorlds();
251     void dispatchDocumentElementAvailable();
252
253     void ownerElementSandboxFlagsChanged() { updateSandboxFlags(); }
254
255     bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
256     SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
257     // The following sandbox flags will be forced, regardless of changes to
258     // the sandbox attribute of any parent frames.
259     void setForcedSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags = flags; m_sandboxFlags |= flags; }
260
261     // Mixed content related functions.
262     static bool isMixedContent(SecurityOrigin* context, const KURL&);
263     bool checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
264     bool checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
265
266     Frame* opener();
267     void setOpener(Frame*);
268
269     bool isProcessingUserGesture();
270
271     void resetMultipleFormSubmissionProtection();
272
273     void checkCallImplicitClose();
274
275     void frameDetached();
276
277     void setOutgoingReferrer(const KURL&);
278
279     void loadDone();
280     void finishedParsing();
281     void checkCompleted();
282
283     void checkDidPerformFirstNavigation();
284
285     bool isComplete() const;
286
287     KURL completeURL(const String& url);
288
289     void cancelAndClear();
290
291     void setTitle(const StringWithDirection&);
292     void setIconURL(const IconURL&);
293
294     void commitProvisionalLoad();
295     bool isLoadingFromCachedPage() const { return m_loadingFromCachedPage; }
296
297     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
298
299     void startIconLoader();
300     void iconLoadDecisionReceived(IconLoadDecision);
301     void continueIconLoadWithDecision(IconLoadDecision);
302
303     bool shouldAllowNavigation(Frame* targetFrame) const;
304     Frame* findFrameForNavigation(const AtomicString& name);
305
306     void applyUserAgent(ResourceRequest& request);
307
308     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
309
310     void open(CachedFrameBase&);
311
312 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
313     void hideMediaPlayerProxyPlugin(Widget*);
314     void showMediaPlayerProxyPlugin(Widget*);
315 #endif
316
317     // FIXME: Should these really be public?
318     void completed();
319     bool allAncestorsAreComplete() const; // including this
320     bool allChildrenAreComplete() const; // immediate children, not all descendants
321     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
322     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
323     void loadItem(HistoryItem*, FrameLoadType);
324
325     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
326     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
327     // introduce a proper callback type for this function, we should make it private again.
328     void continueLoadAfterWillSubmitForm();
329     
330     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
331
332     static ObjectContentType defaultObjectContentType(const KURL&, const String& mimeType, bool shouldPreferPlugInsForImages);
333
334     void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
335
336     bool quickRedirectComing() const { return m_quickRedirectComing; }
337
338     bool shouldClose();
339     
340     void started();
341
342     bool pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
343
344     NetworkingContext* networkingContext() const;
345
346 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
347     Archive* archive() const { return m_archive.get(); }
348 #endif
349
350 private:
351     void checkTimerFired(Timer<FrameLoader>*);
352     
353     void loadSameDocumentItem(HistoryItem*);
354     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
355     
356     void loadProvisionalItemFromCachedPage();
357
358     void receivedFirstData();
359
360     void updateFirstPartyForCookies();
361     void setFirstPartyForCookies(const KURL&);
362     
363     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
364
365     // Also not cool.
366     void stopLoadingSubframes(ClearProvisionalItemPolicy);
367
368     void clearProvisionalLoad();
369     void markLoadComplete();
370     void transitionToCommitted(PassRefPtr<CachedPage>);
371     void frameLoadCompleted();
372
373     void mainReceivedError(const ResourceError&, bool isComplete);
374
375     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
376     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
377     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
378     
379     bool fireBeforeUnloadEvent(Chrome*);
380
381     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
382     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
383     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
384
385     bool shouldScrollToAnchor(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
386
387     void checkLoadCompleteForThisFrame();
388
389     void setDocumentLoader(DocumentLoader*);
390     void setPolicyDocumentLoader(DocumentLoader*);
391     void setProvisionalDocumentLoader(DocumentLoader*);
392
393     void setState(FrameState);
394
395     void closeOldDataSources();
396     void prepareForCachedPageRestore();
397
398     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
399
400     void dispatchDidCommitLoad();
401
402     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy, ShouldReplaceDocumentIfJavaScriptURL);
403
404     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
405     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
406
407     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
408         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
409
410     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
411         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
412     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
413         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
414
415     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
416
417     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
418
419     void recursiveCheckLoadComplete();
420
421     void detachChildren();
422     void closeAndRemoveChild(Frame*);
423
424     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
425
426     void provisionalLoadStarted();
427
428     bool didOpenURL(const KURL&);
429
430     void scheduleCheckCompleted();
431     void scheduleCheckLoadComplete();
432     void startCheckCompleteTimer();
433
434     KURL originalRequestURL() const;
435
436     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
437
438     void updateSandboxFlags();
439
440     bool fillIconURL(IconType, IconURLs*);
441     IconURL getDefaultIconURL(IconType);
442
443     Frame* m_frame;
444     FrameLoaderClient* m_client;
445
446     mutable PolicyChecker m_policyChecker;
447     mutable HistoryController m_history;
448     mutable ResourceLoadNotifier m_notifer;
449     mutable SubframeLoader m_subframeLoader;
450     mutable FrameLoaderStateMachine m_stateMachine;
451
452     FrameState m_state;
453     FrameLoadType m_loadType;
454
455     // Document loaders for the three phases of frame loading. Note that while 
456     // a new request is being loaded, the old document loader may still be referenced.
457     // E.g. while a new request is in the "policy" state, the old document loader may
458     // be consulted in particular as it makes sense to imply certain settings on the new loader.
459     RefPtr<DocumentLoader> m_documentLoader;
460     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
461     RefPtr<DocumentLoader> m_policyDocumentLoader;
462
463     bool m_delegateIsHandlingProvisionalLoadError;
464
465     bool m_quickRedirectComing;
466     bool m_sentRedirectNotification;
467     bool m_inStopAllLoaders;
468
469     String m_outgoingReferrer;
470
471     bool m_isExecutingJavaScriptFormAction;
472
473     bool m_didCallImplicitClose;
474     bool m_wasUnloadEventEmitted;
475     bool m_pageDismissalEventBeingDispatched;
476     bool m_isComplete;
477     bool m_isLoadingMainResource;
478
479     RefPtr<SerializedScriptValue> m_pendingStateObject;
480
481     KURL m_workingURL;
482
483     OwnPtr<IconLoader> m_iconLoader;
484     bool m_mayLoadIconLater;
485
486     bool m_needsClear;
487
488     KURL m_submittedFormURL;
489
490     Timer<FrameLoader> m_checkTimer;
491     bool m_shouldCallCheckCompleted;
492     bool m_shouldCallCheckLoadComplete;
493
494     Frame* m_opener;
495     HashSet<Frame*> m_openedFrames;
496
497     bool m_didPerformFirstNavigation;
498     bool m_loadingFromCachedPage;
499     bool m_suppressOpenerInNewFrame;
500
501     SandboxFlags m_sandboxFlags;
502     SandboxFlags m_forcedSandboxFlags;
503
504     RefPtr<FrameNetworkingContext> m_networkingContext;
505
506 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
507     RefPtr<Archive> m_archive;
508 #endif
509
510     KURL m_previousUrl;
511 };
512
513 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
514 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
515 // the frame name references a frame different from the openerFrame, e.g. when it is
516 // "_self" or "_parent".
517 //
518 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
519 // and moving it to a more appropriate location.
520 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
521
522 } // namespace WebCore
523
524 #endif // FrameLoader_h