LayoutTests:
[WebKit-https.git] / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef FrameLoader_h
30 #define FrameLoader_h
31
32 #include "CachedResource.h"
33 #include "CachePolicy.h"
34 #include "FormState.h"
35 #include "FrameLoaderTypes.h"
36 #include "KURL.h"
37 #include "StringHash.h"
38 #include "Timer.h"
39 #include <wtf/Forward.h>
40 #include <wtf/HashSet.h>
41 #include <wtf/HashMap.h>
42 #include <wtf/Noncopyable.h>
43 #include <wtf/OwnPtr.h>
44 #include <wtf/RefPtr.h>
45 #include "ResourceRequest.h"
46
47 namespace KJS {
48     class JSValue;
49 }
50
51 namespace WebCore {
52
53     class AuthenticationChallenge;
54     class Document;
55     class DocumentLoader;
56     class Element;
57     class Event;
58     class FormData;
59     class Frame;
60     class FrameLoaderClient;
61     class HistoryItem;
62     class HTMLFormElement;
63     class HTMLFrameOwnerElement;
64     class IconLoader;
65     class IntSize;
66     class NavigationAction;
67     class Node;
68     class PageCache;
69     class PageState;
70     class RenderPart;
71     class ResourceError;
72     class ResourceLoader;
73     class ResourceRequest;
74     class ResourceResponse;
75     class SharedBuffer;
76     class SubstituteData;
77     class TextResourceDecoder;
78     class Widget;
79
80     struct FormSubmission;
81     struct FrameLoadRequest;
82     struct ScheduledRedirection;
83     struct WindowFeatures;
84
85     bool isBackForwardLoadType(FrameLoadType);
86
87     typedef void (*NavigationPolicyDecisionFunction)(void* argument,
88         const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
89     typedef void (*NewWindowPolicyDecisionFunction)(void* argument,
90         const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
91     typedef void (*ContentPolicyDecisionFunction)(void* argument, PolicyAction);
92
93     class PolicyCheck {
94     public:
95         PolicyCheck();
96
97         void clear();
98         void set(const ResourceRequest&, PassRefPtr<FormState>,
99             NavigationPolicyDecisionFunction, void* argument);
100         void set(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName,
101             NewWindowPolicyDecisionFunction, void* argument);
102         void set(ContentPolicyDecisionFunction, void* argument);
103
104         const ResourceRequest& request() const { return m_request; }
105         void clearRequest();
106
107         void call(bool shouldContinue);
108         void call(PolicyAction);
109         void cancel();
110
111     private:
112         ResourceRequest m_request;
113         RefPtr<FormState> m_formState;
114         String m_frameName;
115
116         NavigationPolicyDecisionFunction m_navigationFunction;
117         NewWindowPolicyDecisionFunction m_newWindowFunction;
118         ContentPolicyDecisionFunction m_contentFunction;
119         void* m_argument;
120     };
121
122     class FrameLoader : Noncopyable {
123     public:
124         FrameLoader(Frame*, FrameLoaderClient*);
125         ~FrameLoader();
126
127         Frame* frame() const { return m_frame; }
128
129         // FIXME: This is not cool, people.
130         void prepareForLoadStart();
131         void setupForReplace();
132         void setupForReplaceByMIMEType(const String& newMIMEType);
133         void finalSetupForReplace(DocumentLoader*);
134         void load(const KURL&, Event*);
135         void load(const FrameLoadRequest&, bool userGesture,
136             Event*, HTMLFormElement*, const HashMap<String, String>& formValues);
137         void load(const KURL&, const String& referrer, FrameLoadType, const String& target,
138             Event*, HTMLFormElement*, const HashMap<String, String>& formValues);
139         void post(const KURL&, const String& referrer, const String& target,
140             PassRefPtr<FormData>, const String& contentType,
141             Event*, HTMLFormElement*, const HashMap<String, String>& formValues);
142
143         void load(const ResourceRequest&);
144         void load(const ResourceRequest&, const SubstituteData&);
145         void load(const ResourceRequest&, const String& frameName);
146         void load(const ResourceRequest&, const NavigationAction&, FrameLoadType, PassRefPtr<FormState>);
147         
148         void load(DocumentLoader*);
149         void load(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>);
150
151         static bool canLoad(const KURL&, const String& referrer, bool& hideReferrer);
152         static bool canLoad(const KURL&, const Document*);
153         static bool canLoad(const CachedResource&, const Document*);
154
155         static bool shouldHideReferrer(const KURL& url, const String& referrer);
156
157         Frame* createWindow(const FrameLoadRequest&, const WindowFeatures&);
158
159         void loadResourceSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, Vector<char>& data);
160
161         bool canHandleRequest(const ResourceRequest&);
162
163         // Also not cool.
164         void stopAllLoaders();
165         void cancelPendingArchiveLoad(ResourceLoader*);
166
167         bool isLoadingMainResource() const;
168         bool isLoading() const;
169
170         int numPendingOrLoadingRequests(bool recurse) const;
171         bool isReloading() const;
172         String referrer() const;
173         String outgoingReferrer() const;
174         void loadEmptyDocumentSynchronously();
175
176         DocumentLoader* activeDocumentLoader() const;
177         DocumentLoader* documentLoader() const;
178         DocumentLoader* provisionalDocumentLoader();
179         FrameState state() const;
180         static double timeOfLastCompletedLoad();
181         
182         void didReceiveAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
183         void didCancelAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
184         
185         void assignIdentifierToInitialRequest(unsigned long identifier, const ResourceRequest&);
186         void willSendRequest(ResourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
187         void didReceiveResponse(ResourceLoader*, const ResourceResponse&);
188         void didReceiveData(ResourceLoader*, const char*, int, int lengthReceived);
189         void didFinishLoad(ResourceLoader*);
190         void didFailToLoad(ResourceLoader*, const ResourceError&);
191         bool privateBrowsingEnabled() const;
192         const ResourceRequest& originalRequest() const;
193         const ResourceRequest& initialRequest() const;
194         void receivedMainResourceError(const ResourceError&, bool isComplete);
195         void receivedData(const char*, int);
196
197         void handleFallbackContent();
198         bool isStopping() const;
199
200         void finishedLoading();
201         KURL URL() const;
202
203         ResourceError cancelledError(const ResourceRequest&) const;
204         ResourceError fileDoesNotExistError(const ResourceResponse&) const;
205         ResourceError blockedError(const ResourceRequest&) const;
206         bool willUseArchive(ResourceLoader*, const ResourceRequest&, const KURL&) const;
207         bool isArchiveLoadPending(ResourceLoader*) const;
208         void cannotShowMIMEType(const ResourceResponse&);
209         ResourceError interruptionForPolicyChangeError(const ResourceRequest&);
210
211         bool isHostedByObjectElement() const;
212         bool isLoadingMainFrame() const;
213         bool canShowMIMEType(const String& MIMEType) const;
214         bool representationExistsForURLScheme(const String& URLScheme);
215         String generatedMIMETypeForURLScheme(const String& URLScheme);
216
217         void notifyIconChanged();
218
219         void checkNavigationPolicy(const ResourceRequest&, NavigationPolicyDecisionFunction function, void* argument);
220         void checkContentPolicy(const String& MIMEType, ContentPolicyDecisionFunction, void* argument);
221         void cancelContentPolicyCheck();
222
223         void reload();
224         void reloadAllowingStaleData(const String& overrideEncoding);
225
226         void didReceiveServerRedirectForProvisionalLoadForFrame();
227         void finishedLoadingDocument(DocumentLoader*);
228         void committedLoad(DocumentLoader*, const char*, int);
229         bool isReplacing() const;
230         void setReplacing();
231         void revertToProvisional(DocumentLoader*);
232         void setMainDocumentError(DocumentLoader*, const ResourceError&);
233         void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
234         bool subframeIsLoading() const;
235         void willChangeTitle(DocumentLoader*);
236         void didChangeTitle(DocumentLoader*);
237
238         FrameLoadType loadType() const;
239
240         void didFirstLayout();
241         bool firstLayoutDone() const;
242
243         void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
244         void clientRedirected(const KURL&, double delay, double fireDate, bool lockHistory, bool isJavaScriptFormAction);
245         bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
246
247         bool isQuickRedirectComing() const;
248
249         void sendRemainingDelegateMessages(unsigned long identifier, const ResourceResponse&, unsigned length, const ResourceError&);
250         void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
251         void loadedResourceFromMemoryCache(const ResourceRequest&, const ResourceResponse&, int length);
252
253         void recursiveCheckLoadComplete();
254         void checkLoadComplete();
255         void detachFromParent();
256         void detachChildren();
257
258         void addExtraFieldsToRequest(ResourceRequest&, bool isMainResource, bool alwaysFromRequest);
259
260         FrameLoaderClient* client() const;
261
262         void setDefersLoading(bool);
263
264         void changeLocation(const String& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
265         void urlSelected(const ResourceRequest&, const String& target, Event*, bool lockHistory = false);
266         void urlSelected(const FrameLoadRequest&, Event*);
267       
268         bool requestFrame(HTMLFrameOwnerElement*, const String& URL, const AtomicString& frameName);
269         Frame* loadSubframe(HTMLFrameOwnerElement*, const KURL& URL, const String& name, const String& referrer);
270
271         void submitForm(const char* action, const String& URL, PassRefPtr<FormData>, const String& target, const String& contentType, const String& boundary, Event*);
272         void submitFormAgain();
273         void submitForm(const FrameLoadRequest&, Event*);
274
275         void stop();
276         void stopLoading(bool sendUnload);
277         bool closeURL();
278
279         void didExplicitOpen();
280
281         KURL iconURL();
282         void commitIconURLToIconDatabase(const KURL&);
283
284         KURL baseURL() const;
285         String baseTarget() const;
286         KURL dataURLBaseFromRequest(const ResourceRequest& request) const;
287
288         void scheduleRedirection(double delay, const String& URL, bool lockHistory = true);
289
290         void scheduleLocationChange(const String& URL, const String& referrer, bool lockHistory = true, bool userGesture = false);
291         void scheduleRefresh(bool userGesture = false);
292         bool isScheduledLocationChangePending() const;
293
294         void scheduleHistoryNavigation(int steps);
295
296         bool canGoBackOrForward(int distance) const;
297         void goBackOrForward(int distance);
298         int getHistoryLength();
299         KURL historyURL(int distance);
300
301         void begin();
302         void begin(const KURL&);
303         void write(const char* str, int len = -1, bool flush = false);
304         void write(const String&);
305         void end();
306
307         void endIfNotLoading();
308
309         void setEncoding(const String& encoding, bool userChosen);
310         String encoding() const;
311
312         KJS::JSValue* executeScript(const String& URL, int baseLine, Node*, const String& script);
313         KJS::JSValue* executeScript(Node*, const String& script, bool forceUserGesture = false);
314
315         bool gotoAnchor(const String& name); // returns true if the anchor was found
316         void scrollToAnchor(const KURL&);
317
318         void tokenizerProcessedData();
319
320         void handledOnloadEvents();
321         String userAgent(const KURL&) const;
322
323         Widget* createJavaAppletWidget(const IntSize&, Element*, const HashMap<String, String>& args);
324
325         void createEmptyDocument();
326
327         void partClearedInBegin(); 
328         void restoreDocumentState();
329
330         String overrideMediaType() const;
331
332         Frame* opener();
333         void setOpener(Frame*);
334         bool openedByJavaScript();
335         void setOpenedByJavaScript();
336
337         void provisionalLoadStarted();
338
339         bool userGestureHint();
340
341         void resetMultipleFormSubmissionProtection();
342         void didNotOpenURL(const KURL&);
343
344         void addData(const char* bytes, int length);
345
346         bool canCachePage();
347
348         void checkEmitLoadEvent();
349         bool didOpenURL(const KURL&);
350
351         void frameDetached();
352
353         KURL url() const;
354
355         void updateBaseURLForEmptyDocument();
356
357         void setResponseMIMEType(const String&);
358         const String& responseMIMEType() const;
359
360         bool containsPlugins() const;
361
362         void loadDone();
363         void finishedParsing();
364         void checkCompleted();
365         void scheduleCheckCompleted();
366
367         void clearRecordedFormValues();
368         void recordFormValue(const String& name, const String& value, PassRefPtr<HTMLFormElement>);
369
370         bool isComplete() const;
371
372         bool requestObject(RenderPart* frame, const String& URL, const AtomicString& frameName,
373             const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
374
375         KURL completeURL(const String& URL);
376
377         void clear(bool clearWindowProperties = true);
378
379         void didTellBridgeAboutLoad(const String& URL);
380         bool haveToldBridgeAboutLoad(const String& URL);
381
382         KURL originalRequestURL() const;
383
384         void cancelAndClear();
385
386         void setTitle(const String&);
387         void dispatchDidChangeLocationWithinPage();
388         
389         void dispatchDidFinishLoadToClient();
390         void updateGlobalHistoryForStandardLoad(const KURL&);
391         void updateGlobalHistoryForReload(const KURL&);
392         bool shouldGoToHistoryItem(HistoryItem*) const;
393         bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
394
395         void commitProvisionalLoad(PassRefPtr<PageCache>);
396
397         void goToItem(HistoryItem*, FrameLoadType);
398         void saveDocumentAndScrollState();
399         void saveScrollPositionAndViewStateToItem(HistoryItem*);
400
401         // FIXME: These accessors are here for a dwindling number of users in WebKit, WebFrame
402         // being the primary one.  After they're no longer needed there, they can be removed!
403         HistoryItem* currentHistoryItem();
404         HistoryItem* previousHistoryItem();
405         HistoryItem* provisionalHistoryItem();
406         void setCurrentHistoryItem(PassRefPtr<HistoryItem>);
407         void setPreviousHistoryItem(PassRefPtr<HistoryItem>);
408         void setProvisionalHistoryItem(PassRefPtr<HistoryItem>);
409
410         void continueLoadWithData(SharedBuffer*, const String& mimeType, const String& textEncoding, const KURL&); 
411
412         static void registerURLSchemeAsLocal(const String& scheme);
413         static bool restrictAccessToLocal();
414         static void setRestrictAccessToLocal(bool);
415         static bool shouldTreatURLAsLocal(const String& url);
416
417     private:        
418         PassRefPtr<HistoryItem> createHistoryItem(bool useOriginal);
419         PassRefPtr<HistoryItem> createHistoryItemTree(Frame* targetFrame, bool clipAtTarget);
420
421         void addBackForwardItemClippedAtTarget(bool doClip);
422         void restoreScrollPositionAndViewState();
423         void saveDocumentState();
424         void loadItem(HistoryItem*, FrameLoadType);
425         bool urlsMatchItem(HistoryItem*) const;
426         void purgePageCache();
427         void invalidateCurrentItemPageCache();
428         void recursiveGoToItem(HistoryItem*, HistoryItem*, FrameLoadType);
429         bool childFramesMatchItem(HistoryItem*) const;
430
431         void updateHistoryForBackForwardNavigation();
432         void updateHistoryForReload();
433         void updateHistoryForStandardLoad();
434         void updateHistoryForInternalLoad();
435         void updateHistoryForClientRedirect();
436         void updateHistoryForCommit();
437     
438         void redirectionTimerFired(Timer<FrameLoader>*);
439         void checkCompletedTimerFired(Timer<FrameLoader>*);
440
441         void cancelRedirection(bool newLoadInProgress = false);
442
443         void started();
444
445         void completed();
446         void parentCompleted();
447
448         bool shouldUsePlugin(const KURL&, const String& mimeType, bool hasFallback, bool& useFallback);
449         bool loadPlugin(RenderPart*, const KURL&, const String& mimeType,
450         const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
451         
452         bool loadProvisionalItemFromPageCache();
453         bool createPageCache(HistoryItem*);
454
455         void emitLoadEvent();
456
457         void receivedFirstData();
458
459         void gotoAnchor();
460
461         void updatePolicyBaseURL();
462         void setPolicyBaseURL(const String&);
463
464         void replaceContentsWithScriptResult(const KURL&);
465
466         // Also not cool.
467         void startLoading();
468         void stopLoadingSubframes();
469
470         void clearProvisionalLoad();
471         void markLoadComplete();
472         void commitProvisionalLoad();
473         void transitionToCommitted(PassRefPtr<PageCache>);
474         void frameLoadCompleted();
475
476         void mainReceivedError(const ResourceError&, bool isComplete);
477
478         void setLoadType(FrameLoadType);
479
480         void checkNavigationPolicy(const ResourceRequest&, DocumentLoader*, PassRefPtr<FormState>,
481                                    NavigationPolicyDecisionFunction, void* argument);
482         void checkNewWindowPolicy(const NavigationAction&, const ResourceRequest&, 
483                                   PassRefPtr<FormState>, const String& frameName);
484
485         void continueAfterNavigationPolicy(PolicyAction);
486         void continueAfterNewWindowPolicy(PolicyAction);
487         void continueAfterContentPolicy(PolicyAction);
488         void continueAfterWillSubmitForm(PolicyAction = PolicyUse);
489
490         static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
491         void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
492         static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
493         void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
494         static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
495         void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
496         void addHistoryItemForFragmentScroll();
497
498         void stopPolicyCheck();
499
500         void closeDocument();
501         
502         void checkLoadCompleteForThisFrame();
503
504         void setDocumentLoader(DocumentLoader*);
505         void setPolicyDocumentLoader(DocumentLoader*);
506         void setProvisionalDocumentLoader(DocumentLoader*);
507
508         void setState(FrameState);
509
510         void closeOldDataSources();
511         void open(PageState&);
512         void opened();
513         void updateHistoryAfterClientRedirect();
514
515         bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
516         void handleUnimplementablePolicy(const ResourceError&);
517
518         void applyUserAgent(ResourceRequest& request);
519
520         bool canTarget(Frame*) const;
521
522         void scheduleRedirection(ScheduledRedirection*);
523         void startRedirectionTimer();
524         void stopRedirectionTimer();
525
526         void startIconLoader();
527
528         Frame* m_frame;
529         FrameLoaderClient* m_client;
530
531         FrameState m_state;
532         FrameLoadType m_loadType;
533
534         RefPtr<DocumentLoader> m_documentLoader;
535         RefPtr<DocumentLoader> m_provisionalDocumentLoader;
536         RefPtr<DocumentLoader> m_policyDocumentLoader;
537
538         FrameLoadType m_policyLoadType;
539         PolicyCheck m_policyCheck;
540
541         bool m_delegateIsHandlingProvisionalLoadError;
542         bool m_delegateIsDecidingNavigationPolicy;
543         bool m_delegateIsHandlingUnimplementablePolicy;
544
545         bool m_firstLayoutDone;
546         bool m_quickRedirectComing;
547         bool m_sentRedirectNotification;
548         bool m_inStopAllLoaders;
549
550         String m_outgoingReferrer;
551
552         CachePolicy m_cachePolicy;
553
554         HashSet<String> m_urlsBridgeKnowsAbout;
555
556         OwnPtr<FormSubmission> m_deferredFormSubmission;
557
558         bool m_isExecutingJavaScriptFormAction;
559         bool m_isRunningScript;
560
561         String m_responseMIMEType;
562
563         bool m_wasLoadEventEmitted;
564         bool m_wasUnloadEventEmitted;
565         bool m_isComplete;
566         bool m_isLoadingMainResource;
567
568         KURL m_URL;
569         KURL m_workingURL;
570
571         OwnPtr<IconLoader> m_iconLoader;
572
573         bool m_cancellingWithLoadInProgress;
574
575         OwnPtr<ScheduledRedirection> m_scheduledRedirection;
576
577         bool m_needsClear;
578         bool m_receivedData;
579
580         bool m_encodingWasChosenByUser;
581         String m_encoding;
582         RefPtr<TextResourceDecoder> m_decoder;
583
584         bool m_containsPlugIns;
585
586         RefPtr<HTMLFormElement> m_formAboutToBeSubmitted;
587         HashMap<String, String> m_formValuesAboutToBeSubmitted;
588         KURL m_submittedFormURL;
589     
590         Timer<FrameLoader> m_redirectionTimer;
591         Timer<FrameLoader> m_checkCompletedTimer;
592
593         Frame* m_opener;
594         HashSet<Frame*> m_openedFrames;
595
596         bool m_openedByJavaScript;
597
598         RefPtr<HistoryItem> m_currentHistoryItem;
599         RefPtr<HistoryItem> m_previousHistoryItem;
600         RefPtr<HistoryItem> m_provisionalHistoryItem;
601
602     };
603
604 }
605
606 #endif