2011-01-26 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     const KURL& url() const;
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 iconLoadDecisionAvailable();
294
295     bool shouldAllowNavigation(Frame* targetFrame) const;
296     Frame* findFrameForNavigation(const AtomicString& name);
297
298     void startIconLoader();
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(DatabasePolicy, 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 DocumentWriter m_writer;
437     mutable SubframeLoader m_subframeLoader;
438     mutable FrameLoaderStateMachine m_stateMachine;
439
440     FrameState m_state;
441     FrameLoadType m_loadType;
442
443     // Document loaders for the three phases of frame loading. Note that while 
444     // a new request is being loaded, the old document loader may still be referenced.
445     // E.g. while a new request is in the "policy" state, the old document loader may
446     // be consulted in particular as it makes sense to imply certain settings on the new loader.
447     RefPtr<DocumentLoader> m_documentLoader;
448     RefPtr<DocumentLoader> m_provisionalDocumentLoader;
449     RefPtr<DocumentLoader> m_policyDocumentLoader;
450
451     bool m_delegateIsHandlingProvisionalLoadError;
452
453     bool m_quickRedirectComing;
454     bool m_sentRedirectNotification;
455     bool m_inStopAllLoaders;
456
457     String m_outgoingReferrer;
458
459     bool m_isExecutingJavaScriptFormAction;
460
461     bool m_didCallImplicitClose;
462     bool m_wasUnloadEventEmitted;
463     bool m_pageDismissalEventBeingDispatched;
464     bool m_isComplete;
465     bool m_isLoadingMainResource;
466
467     RefPtr<SerializedScriptValue> m_pendingStateObject;
468
469     KURL m_workingURL;
470
471     OwnPtr<IconLoader> m_iconLoader;
472     bool m_mayLoadIconLater;
473
474     bool m_needsClear;
475
476     KURL m_submittedFormURL;
477
478     Timer<FrameLoader> m_checkTimer;
479     bool m_shouldCallCheckCompleted;
480     bool m_shouldCallCheckLoadComplete;
481
482     Frame* m_opener;
483     HashSet<Frame*> m_openedFrames;
484
485     bool m_didPerformFirstNavigation;
486     bool m_loadingFromCachedPage;
487     bool m_suppressOpenerInNewFrame;
488
489     SandboxFlags m_sandboxFlags;
490     SandboxFlags m_forcedSandboxFlags;
491
492     RefPtr<FrameNetworkingContext> m_networkingContext;
493
494     KURL m_previousUrl;
495 };
496
497 // This function is called by createWindow() in JSDOMWindowBase.cpp, for example, for
498 // modal dialog creation.  The lookupFrame is for looking up the frame name in case
499 // the frame name references a frame different from the openerFrame, e.g. when it is
500 // "_self" or "_parent".
501 //
502 // FIXME: Consider making this function part of an appropriate class (not FrameLoader)
503 // and moving it to a more appropriate location.
504 Frame* createWindow(Frame* openerFrame, Frame* lookupFrame, const FrameLoadRequest&, const WindowFeatures&, bool& created);
505
506 } // namespace WebCore
507
508 #endif // FrameLoader_h