2011-01-27 Nate Chapin <japhet@chromium.org>
[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 "DocumentWriter.h"
36 #include "FrameLoaderStateMachine.h"
37 #include "FrameLoaderTypes.h"
38 #include "HistoryController.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     DocumentWriter* writer() const { return &m_writer; }
103     SubframeLoader* subframeLoader() const { return &m_subframeLoader; }
104
105     // FIXME: This is not cool, people. There are too many different functions that all start loads.
106     // We should aim to consolidate these into a smaller set of functions, and try to reuse more of
107     // the logic by extracting common code paths.
108
109     void prepareForLoadStart();
110     void setupForReplace();
111     void setupForReplaceByMIMEType(const String& newMIMEType);
112
113     void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
114
115     void loadFrameRequest(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,  // Called by submitForm, calls loadPostRequest and loadURL.
116         PassRefPtr<Event>, PassRefPtr<FormState>, ReferrerPolicy);
117
118     void load(const ResourceRequest&, bool lockHistory);                                        // Called by WebFrame, calls load(ResourceRequest, SubstituteData).
119     void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                 // Called both by WebFrame and internally, calls load(DocumentLoader*).
120     void load(const ResourceRequest&, const String& frameName, bool lockHistory);               // Called by WebPluginController.
121     
122     void loadArchive(PassRefPtr<Archive>);
123
124     static void reportLocalLoadFailed(Frame*, const String& url);
125
126     unsigned long loadResourceSynchronously(const ResourceRequest&, StoredCredentials, ResourceError&, ResourceResponse&, Vector<char>& data);
127
128     bool canHandleRequest(const ResourceRequest&);
129
130     // Also not cool.
131     void stopAllLoaders(DatabasePolicy = DatabasePolicyStop, ClearProvisionalItemPolicy = ShouldClearProvisionalItem);
132     void stopForUserCancel(bool deferCheckLoadComplete = false);
133
134     bool isLoadingMainResource() const { return m_isLoadingMainResource; }
135     bool isLoading() const;
136     bool frameHasLoaded() const;
137     void transferLoadingResourcesFromPage(Page*);
138     void dispatchTransferLoadingResourceFromPage(unsigned long, DocumentLoader*, const ResourceRequest&, Page*);
139
140     int numPendingOrLoadingRequests(bool recurse) const;
141     String referrer() const;
142     String outgoingReferrer() const;
143     String outgoingOrigin() const;
144
145     DocumentLoader* activeDocumentLoader() const;
146     DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
147     DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
148     DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
149     FrameState state() const { return m_state; }
150     static double timeOfLastCompletedLoad();
151
152     bool shouldUseCredentialStorage(ResourceLoader*);
153 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
154     bool canAuthenticateAgainstProtectionSpace(ResourceLoader* loader, const ProtectionSpace& protectionSpace);
155 #endif
156     const ResourceRequest& originalRequest() const;
157     const ResourceRequest& initialRequest() const;
158     void receivedMainResourceError(const ResourceError&, bool isComplete);
159
160     bool willLoadMediaElementURL(KURL&);
161
162     void handleFallbackContent();
163     bool isStopping() const;
164
165     void finishedLoading();
166
167     ResourceError cancelledError(const ResourceRequest&) const;
168     ResourceError fileDoesNotExistError(const ResourceResponse&) const;
169     ResourceError blockedError(const ResourceRequest&) const;
170     ResourceError cannotShowURLError(const ResourceRequest&) const;
171     ResourceError interruptionForPolicyChangeError(const ResourceRequest&) const;
172
173     bool isHostedByObjectElement() const;
174     bool isLoadingMainFrame() const;
175     bool canShowMIMEType(const String& MIMEType) const;
176     bool representationExistsForURLScheme(const String& URLScheme);
177     String generatedMIMETypeForURLScheme(const String& URLScheme);
178
179     void reload(bool endToEndReload = false);
180     void reloadWithOverrideEncoding(const String& overrideEncoding);
181
182     void didReceiveServerRedirectForProvisionalLoadForFrame();
183     void finishedLoadingDocument(DocumentLoader*);
184     bool isReplacing() const;
185     void setReplacing();
186     void revertToProvisional(DocumentLoader*);
187     void setMainDocumentError(DocumentLoader*, const ResourceError&);
188     void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
189     bool subframeIsLoading() const;
190     void willChangeTitle(DocumentLoader*);
191     void didChangeTitle(DocumentLoader*);
192     void didChangeIcons(DocumentLoader*);
193
194     FrameLoadType loadType() const;
195
196     CachePolicy subresourceCachePolicy() const;
197
198     void didFirstLayout();
199
200     void didFirstVisuallyNonEmptyLayout();
201
202     void loadedResourceFromMemoryCache(const CachedResource*);
203     void tellClientAboutPastMemoryCacheLoads();
204
205     void checkLoadComplete();
206     void detachFromParent();
207     void detachViewsAndDocumentLoader();
208
209     void addExtraFieldsToSubresourceRequest(ResourceRequest&);
210     void addExtraFieldsToMainResourceRequest(ResourceRequest&);
211     
212     static void addHTTPOriginIfNeeded(ResourceRequest&, String origin);
213
214     FrameLoaderClient* client() const { return m_client; }
215
216     void setDefersLoading(bool);
217
218     void changeLocation(PassRefPtr<SecurityOrigin>, const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool refresh = false);
219     void urlSelected(const KURL&, const String& target, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy);
220
221     void submitForm(PassRefPtr<FormSubmission>);
222
223     void stop();
224     void stopLoading(UnloadEventPolicy, DatabasePolicy = DatabasePolicyStop);
225     bool closeURL();
226
227     void didExplicitOpen();
228
229     // Callbacks from DocumentWriter
230     void didBeginDocument(bool dispatchWindowObjectAvailable);
231     void didEndDocument();
232     void willSetEncoding();
233
234     KURL iconURL();
235     void commitIconURLToIconDatabase(const KURL&);
236
237     KURL baseURL() const;
238
239     void handledOnloadEvents();
240     String userAgent(const KURL&) const;
241
242     void dispatchDidClearWindowObjectInWorld(DOMWrapperWorld*);
243     void dispatchDidClearWindowObjectsInAllWorlds();
244     void dispatchDocumentElementAvailable();
245
246     void ownerElementSandboxFlagsChanged() { updateSandboxFlags(); }
247
248     bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
249     SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
250     // The following sandbox flags will be forced, regardless of changes to
251     // the sandbox attribute of any parent frames.
252     void setForcedSandboxFlags(SandboxFlags flags) { m_forcedSandboxFlags = flags; m_sandboxFlags |= flags; }
253
254     // Mixed content related functions.
255     static bool isMixedContent(SecurityOrigin* context, const KURL&);
256     void checkIfDisplayInsecureContent(SecurityOrigin* context, const KURL&);
257     void checkIfRunInsecureContent(SecurityOrigin* context, const KURL&);
258
259     Frame* opener();
260     void setOpener(Frame*);
261
262     bool isProcessingUserGesture();
263
264     void resetMultipleFormSubmissionProtection();
265
266     void checkCallImplicitClose();
267
268     void frameDetached();
269
270     void setOutgoingReferrer(const KURL&);
271
272     void loadDone();
273     void finishedParsing();
274     void checkCompleted();
275
276     void checkDidPerformFirstNavigation();
277
278     bool isComplete() const;
279
280     KURL completeURL(const String& url);
281
282     void cancelAndClear();
283
284     void setTitle(const String&);
285     void setIconURL(const String&);
286
287     void commitProvisionalLoad();
288     bool isLoadingFromCachedPage() const { return m_loadingFromCachedPage; }
289
290     FrameLoaderStateMachine* stateMachine() const { return &m_stateMachine; }
291
292     void iconLoadDecisionAvailable();
293
294     bool shouldAllowNavigation(Frame* targetFrame) const;
295     Frame* findFrameForNavigation(const AtomicString& name);
296
297     void startIconLoader();
298
299     void applyUserAgent(ResourceRequest& request);
300
301     bool shouldInterruptLoadForXFrameOptions(const String&, const KURL&);
302
303     void open(CachedFrameBase&);
304
305 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
306     void hideMediaPlayerProxyPlugin(Widget*);
307     void showMediaPlayerProxyPlugin(Widget*);
308 #endif
309
310     // FIXME: Should these really be public?
311     void completed();
312     bool allAncestorsAreComplete() const; // including this
313     bool allChildrenAreComplete() const; // immediate children, not all descendants
314     void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList);
315     void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
316     void loadItem(HistoryItem*, FrameLoadType);
317
318     // FIXME: This is public because this asynchronous callback from the FrameLoaderClient
319     // uses the policy machinery (and therefore is called via the PolicyChecker).  Once we
320     // introduce a proper callback type for this function, we should make it private again.
321     void continueLoadAfterWillSubmitForm();
322     
323     bool suppressOpenerInNewFrame() const { return m_suppressOpenerInNewFrame; }
324
325     static ObjectContentType defaultObjectContentType(const KURL& url, const String& mimeType);
326
327     void clear(bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true);
328
329     bool quickRedirectComing() const { return m_quickRedirectComing; }
330
331     bool shouldClose();
332     
333     void started();
334
335     bool pageDismissalEventBeingDispatched() const { return m_pageDismissalEventBeingDispatched; }
336
337     NetworkingContext* networkingContext() const;
338
339 private:
340     void checkTimerFired(Timer<FrameLoader>*);
341     
342     void loadSameDocumentItem(HistoryItem*);
343     void loadDifferentDocumentItem(HistoryItem*, FrameLoadType);
344     
345     void loadProvisionalItemFromCachedPage();
346
347     void receivedFirstData();
348
349     void updateFirstPartyForCookies();
350     void setFirstPartyForCookies(const KURL&);
351     
352     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
353
354     // Also not cool.
355     void stopLoadingSubframes(DatabasePolicy, ClearProvisionalItemPolicy);
356
357     void clearProvisionalLoad();
358     void markLoadComplete();
359     void transitionToCommitted(PassRefPtr<CachedPage>);
360     void frameLoadCompleted();
361
362     void mainReceivedError(const ResourceError&, bool isComplete);
363
364     static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
365     static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
366     static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
367     
368     bool fireBeforeUnloadEvent(Chrome*);
369
370     void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
371     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, const NavigationAction&, bool shouldContinue);
372     void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
373
374     bool shouldScrollToAnchor(bool isFormSubmission, const String& httpMethod, FrameLoadType, const KURL&);
375
376     void checkLoadCompleteForThisFrame();
377
378     void setDocumentLoader(DocumentLoader*);
379     void setPolicyDocumentLoader(DocumentLoader*);
380     void setProvisionalDocumentLoader(DocumentLoader*);
381
382     void setState(FrameState);
383
384     void closeOldDataSources();
385     void prepareForCachedPageRestore();
386
387     bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
388
389     void dispatchDidCommitLoad();
390
391     void urlSelected(const FrameLoadRequest&, PassRefPtr<Event>, bool lockHistory, bool lockBackForwardList, ReferrerPolicy, ShouldReplaceDocumentIfJavaScriptURL);
392
393     void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>); // Calls continueLoadAfterNavigationPolicy
394     void load(DocumentLoader*);                                                         // Calls loadWithDocumentLoader   
395
396     void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,      // Calls loadWithDocumentLoader
397         bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
398
399     void loadPostRequest(const ResourceRequest&, const String& referrer,                // Called by loadFrameRequest, calls loadWithNavigationAction
400         const String& frameName, bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);
401     void loadURL(const KURL&, const String& referrer, const String& frameName,          // Called by loadFrameRequest, calls loadWithNavigationAction or dispatches to navigation policy delegate
402         bool lockHistory, FrameLoadType, PassRefPtr<Event>, PassRefPtr<FormState>);                                                         
403
404     bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
405
406     void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
407
408     void recursiveCheckLoadComplete();
409
410     void detachChildren();
411     void closeAndRemoveChild(Frame*);
412
413     void loadInSameDocument(const KURL&, SerializedScriptValue* stateObject, bool isNewNavigation);
414
415     void provisionalLoadStarted();
416
417     bool didOpenURL(const KURL&);
418
419     void scheduleCheckCompleted();
420     void scheduleCheckLoadComplete();
421     void startCheckCompleteTimer();
422
423     KURL originalRequestURL() const;
424
425     bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
426
427     void updateSandboxFlags();
428
429     Frame* m_frame;
430     FrameLoaderClient* m_client;
431
432     mutable PolicyChecker m_policyChecker;
433     mutable HistoryController m_history;
434     mutable ResourceLoadNotifier m_notifer;
435     mutable DocumentWriter m_writer;
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