86aff5e8f0f9f76fdf2e4e108b69ca8867ddb383
[WebKit-https.git] / WebCore / loader / FrameLoader.h
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #ifndef FrameLoader_h
31 #define FrameLoader_h
32
33 #include "CachePolicy.h"
34 #include "FormState.h"
35 #include "FrameLoaderTypes.h"
36 #include "ResourceRequest.h"
37 #include "Timer.h"
38
39 namespace WebCore {
40
41     class Archive;
42     class AuthenticationChallenge;
43     class CachedFrame;
44     class CachedPage;
45     class CachedResource;
46     class Document;
47     class DocumentLoader;
48     class Element;
49     class Event;
50     class FormData;
51     class Frame;
52     class FrameLoaderClient;
53     class HistoryItem;
54     class HTMLAppletElement;
55     class HTMLFormElement;
56     class HTMLFrameOwnerElement;
57     class IconLoader;
58     class IntSize;
59     class NavigationAction;
60     class RenderPart;
61     class ResourceError;
62     class ResourceLoader;
63     class ResourceResponse;
64     class ScriptSourceCode;
65     class ScriptValue;
66     class SecurityOrigin;
67     class SharedBuffer;
68     class SubstituteData;
69     class TextResourceDecoder;
70     class Widget;
71
72     struct FormSubmission;
73     struct FrameLoadRequest;
74     struct ScheduledRedirection;
75     struct WindowFeatures;
76
77     bool isBackForwardLoadType(FrameLoadType);
78
79     typedef void (*NavigationPolicyDecisionFunction)(void* argument,
80         const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
81     typedef void (*NewWindowPolicyDecisionFunction)(void* argument,
82         const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
83     typedef void (*ContentPolicyDecisionFunction)(void* argument, PolicyAction);
84
85     class PolicyCheck {
86     public:
87         PolicyCheck();
88
89         void clear();
90         void set(const ResourceRequest&, PassRefPtr<FormState>,
91             NavigationPolicyDecisionFunction, void* argument);
92         void set(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName,
93             NewWindowPolicyDecisionFunction, void* argument);
94         void set(ContentPolicyDecisionFunction, void* argument);
95
96         const ResourceRequest& request() const { return m_request; }
97         void clearRequest();
98
99         void call(bool shouldContinue);
100         void call(PolicyAction);
101         void cancel();
102
103     private:
104         ResourceRequest m_request;
105         RefPtr<FormState> m_formState;
106         String m_frameName;
107
108         NavigationPolicyDecisionFunction m_navigationFunction;
109         NewWindowPolicyDecisionFunction m_newWindowFunction;
110         ContentPolicyDecisionFunction m_contentFunction;
111         void* m_argument;
112     };
113
114     class FrameLoader : Noncopyable {
115     public:
116         FrameLoader(Frame*, FrameLoaderClient*);
117         ~FrameLoader();
118
119         void init();
120
121         Frame* frame() const { return m_frame; }
122
123         // FIXME: This is not cool, people. We should aim to consolidate these variety of loading related methods into a smaller set,
124         // and try to reuse more of the same logic by extracting common code paths.
125         void prepareForLoadStart();
126         void setupForReplace();
127         void setupForReplaceByMIMEType(const String& newMIMEType);
128
129         void loadWithDocumentLoader(DocumentLoader*, FrameLoadType, PassRefPtr<FormState>);         // Calls continueLoadAfterNavigationPolicy
130         void load(DocumentLoader*);                                                                 // Calls loadWithDocumentLoader   
131
132         void loadWithNavigationAction(const ResourceRequest&, const NavigationAction&,              // Calls loadWithDocumentLoader()
133             bool lockHistory, FrameLoadType, PassRefPtr<FormState>);
134
135         void loadPostRequest(const ResourceRequest&, const String& referrer,                        // Called by loadFrameRequestWithFormAndValues(), calls loadWithNavigationAction
136             const String& frameName, bool lockHistory, FrameLoadType, Event*, PassRefPtr<FormState>);
137
138         void loadURL(const KURL& newURL, const String& referrer, const String& frameName,           // Called by loadFrameRequestWithFormAndValues(), calls loadWithNavigationAction or else dispatches to navigation policy delegate    
139             bool lockHistory, FrameLoadType, Event*, PassRefPtr<FormState>);                                                         
140         void loadURLIntoChildFrame(const KURL&, const String& referer, Frame*);
141
142         void loadFrameRequestWithFormAndValues(const FrameLoadRequest&, bool lockHistory, bool lockBackForwardList,           // Called by submitForm, calls loadPostRequest()
143             Event*, HTMLFormElement*, const HashMap<String, String>& formValues);
144
145         void load(const ResourceRequest&, bool lockHistory);                                                          // Called by WebFrame, calls (ResourceRequest, SubstituteData)
146         void load(const ResourceRequest&, const SubstituteData&, bool lockHistory);                                   // Called both by WebFrame and internally, calls (DocumentLoader*)
147         void load(const ResourceRequest&, const String& frameName, bool lockHistory);                                 // Called by WebPluginController
148         
149         void loadArchive(PassRefPtr<Archive> archive);
150
151         // Returns true for any non-local URL. If Document parameter is supplied, its local load policy dictates,
152         // otherwise if referrer is non-empty and represents a local file, then the local load is allowed.
153         static bool canLoad(const KURL&, const String& referrer, const Document* theDocument = 0);
154         static void reportLocalLoadFailed(Frame*, const String& url);
155
156         static bool shouldHideReferrer(const KURL& url, const String& referrer);
157
158         // Called by createWindow in JSDOMWindowBase.cpp, e.g. to fulfill a modal dialog creation
159         Frame* createWindow(FrameLoader* frameLoaderForFrameLookup, const FrameLoadRequest&, const WindowFeatures&, bool& created);
160
161         unsigned long loadResourceSynchronously(const ResourceRequest&, ResourceError&, ResourceResponse&, Vector<char>& data);
162
163         bool canHandleRequest(const ResourceRequest&);
164
165         // Also not cool.
166         void stopAllLoaders();
167         void stopForUserCancel(bool deferCheckLoadComplete = false);
168
169         bool isLoadingMainResource() const { return m_isLoadingMainResource; }
170         bool isLoading() const;
171         bool frameHasLoaded() const;
172
173         int numPendingOrLoadingRequests(bool recurse) const;
174         String referrer() const;
175         String outgoingReferrer() const;
176         String outgoingOrigin() const;
177         void loadEmptyDocumentSynchronously();
178
179         DocumentLoader* activeDocumentLoader() const;
180         DocumentLoader* documentLoader() const { return m_documentLoader.get(); }
181         DocumentLoader* policyDocumentLoader() const { return m_policyDocumentLoader.get(); }
182         DocumentLoader* provisionalDocumentLoader() const { return m_provisionalDocumentLoader.get(); }
183         FrameState state() const { return m_state; }
184         static double timeOfLastCompletedLoad();
185
186         bool shouldUseCredentialStorage(ResourceLoader*);
187         void didReceiveAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
188         void didCancelAuthenticationChallenge(ResourceLoader*, const AuthenticationChallenge&);
189         
190         void assignIdentifierToInitialRequest(unsigned long identifier, const ResourceRequest&);
191         void willSendRequest(ResourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
192         void didReceiveResponse(ResourceLoader*, const ResourceResponse&);
193         void didReceiveData(ResourceLoader*, const char*, int, int lengthReceived);
194         void didFinishLoad(ResourceLoader*);
195         void didFailToLoad(ResourceLoader*, const ResourceError&);
196         const ResourceRequest& originalRequest() const;
197         const ResourceRequest& initialRequest() const;
198         void receivedMainResourceError(const ResourceError&, bool isComplete);
199         void receivedData(const char*, int);
200
201         void handleFallbackContent();
202         bool isStopping() const;
203
204         void finishedLoading();
205
206         ResourceError cancelledError(const ResourceRequest&) const;
207         ResourceError fileDoesNotExistError(const ResourceResponse&) const;
208         ResourceError blockedError(const ResourceRequest&) const;
209         ResourceError cannotShowURLError(const ResourceRequest&) const;
210
211         void cannotShowMIMEType(const ResourceResponse&);
212         ResourceError interruptionForPolicyChangeError(const ResourceRequest&);
213
214         bool isHostedByObjectElement() const;
215         bool isLoadingMainFrame() const;
216         bool canShowMIMEType(const String& MIMEType) const;
217         bool representationExistsForURLScheme(const String& URLScheme);
218         String generatedMIMETypeForURLScheme(const String& URLScheme);
219
220         void notifyIconChanged();
221
222         void checkNavigationPolicy(const ResourceRequest&, NavigationPolicyDecisionFunction function, void* argument);
223         void checkContentPolicy(const String& MIMEType, ContentPolicyDecisionFunction, void* argument);
224         void cancelContentPolicyCheck();
225
226         void reload(bool endToEndReload = false);
227         void reloadWithOverrideEncoding(const String& overrideEncoding);
228
229         void didReceiveServerRedirectForProvisionalLoadForFrame();
230         void finishedLoadingDocument(DocumentLoader*);
231         void committedLoad(DocumentLoader*, const char*, int);
232         bool isReplacing() const;
233         void setReplacing();
234         void revertToProvisional(DocumentLoader*);
235         void setMainDocumentError(DocumentLoader*, const ResourceError&);
236         void mainReceivedCompleteError(DocumentLoader*, const ResourceError&);
237         bool subframeIsLoading() const;
238         void willChangeTitle(DocumentLoader*);
239         void didChangeTitle(DocumentLoader*);
240
241         FrameLoadType loadType() const;
242         CachePolicy cachePolicy() const;
243
244         void didFirstLayout();
245         bool firstLayoutDone() const;
246
247         void didFirstVisuallyNonEmptyLayout();
248
249         void clientRedirectCancelledOrFinished(bool cancelWithLoadInProgress);
250         void clientRedirected(const KURL&, double delay, double fireDate, bool lockBackForwardList, bool isJavaScriptFormAction);
251         bool shouldReload(const KURL& currentURL, const KURL& destinationURL);
252 #if ENABLE(WML)
253         void setForceReloadWmlDeck(bool);
254 #endif
255
256         bool isQuickRedirectComing() const;
257
258         void sendRemainingDelegateMessages(unsigned long identifier, const ResourceResponse&, int length, const ResourceError&);
259         void requestFromDelegate(ResourceRequest&, unsigned long& identifier, ResourceError&);
260         void loadedResourceFromMemoryCache(const CachedResource*);
261         void tellClientAboutPastMemoryCacheLoads();
262
263         void recursiveCheckLoadComplete();
264         void checkLoadComplete();
265         void detachFromParent();
266         void detachChildren();
267         void closeAndRemoveChild(Frame*);
268
269         void addExtraFieldsToSubresourceRequest(ResourceRequest&);
270         void addExtraFieldsToMainResourceRequest(ResourceRequest&);
271         
272         static void addHTTPOriginIfNeeded(ResourceRequest&, String origin);
273
274         FrameLoaderClient* client() const { return m_client; }
275
276         void setDefersLoading(bool);
277
278         void changeLocation(const String& url, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false, bool refresh = false);
279         void changeLocation(const KURL&, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false, bool refresh = false);
280         void urlSelected(const ResourceRequest&, const String& target, Event*, bool lockHistory, bool lockBackForwardList, bool userGesture);
281         void urlSelected(const FrameLoadRequest&, Event*, bool lockHistory, bool lockBackForwardList);
282       
283         bool requestFrame(HTMLFrameOwnerElement*, const String& url, const AtomicString& frameName);
284         Frame* loadSubframe(HTMLFrameOwnerElement*, const KURL&, const String& name, const String& referrer);
285
286         void submitForm(const char* action, const String& url, PassRefPtr<FormData>, const String& target, const String& contentType, const String& boundary, Event*, bool lockHistory, bool lockBackForwardList);
287         void submitFormAgain();
288         void submitForm(const FrameLoadRequest&, Event*, bool lockHistory, bool lockBackForwardList);
289
290         void stop();
291         void stopLoading(bool sendUnload);
292         bool closeURL();
293
294         void didExplicitOpen();
295
296         KURL iconURL();
297         void commitIconURLToIconDatabase(const KURL&);
298
299         KURL baseURL() const;
300         String baseTarget() const;
301         KURL dataURLBaseFromRequest(const ResourceRequest& request) const;
302
303         bool isScheduledLocationChangePending() const { return m_scheduledRedirection && isLocationChange(*m_scheduledRedirection); }
304         void scheduleHTTPRedirection(double delay, const String& url);
305         void scheduleLocationChange(const String& url, const String& referrer, bool lockHistory = true, bool lockBackForwardList = true, bool userGesture = false);
306         void scheduleRefresh(bool userGesture = false);
307         void scheduleHistoryNavigation(int steps);
308
309         bool canGoBackOrForward(int distance) const;
310         void goBackOrForward(int distance);
311         int getHistoryLength();
312         KURL historyURL(int distance);
313
314         void begin();
315         void begin(const KURL&, bool dispatchWindowObjectAvailable = true, SecurityOrigin* forcedSecurityOrigin = 0);
316
317         void write(const char* str, int len = -1, bool flush = false);
318         void write(const String&);
319         void end();
320         void endIfNotLoadingMainResource();
321
322         void setEncoding(const String& encoding, bool userChosen);
323         String encoding() const;
324
325         // Returns true if url is a JavaScript URL.
326         bool executeIfJavaScriptURL(const KURL& url, bool userGesture = false, bool replaceDocument = true);
327
328         ScriptValue executeScript(const ScriptSourceCode&);
329         ScriptValue executeScript(const String& script, bool forceUserGesture = false);
330
331         void gotoAnchor();
332         bool gotoAnchor(const String& name); // returns true if the anchor was found
333         void scrollToAnchor(const KURL&);
334
335         void tokenizerProcessedData();
336
337         void handledOnloadEvents();
338         String userAgent(const KURL&) const;
339
340         Widget* createJavaAppletWidget(const IntSize&, HTMLAppletElement*, const HashMap<String, String>& args);
341
342         void dispatchWindowObjectAvailable();
343         void dispatchDocumentElementAvailable();
344         void restoreDocumentState();
345
346         Frame* opener();
347         void setOpener(Frame*);
348         bool openedByDOM() const;
349         void setOpenedByDOM();
350
351         void provisionalLoadStarted();
352
353         bool userGestureHint();
354
355         void resetMultipleFormSubmissionProtection();
356         void didNotOpenURL(const KURL&);
357
358         void addData(const char* bytes, int length);
359
360         bool canCachePage();
361
362         void checkCallImplicitClose();
363         bool didOpenURL(const KURL&);
364
365         void frameDetached();
366
367         const KURL& url() const { return m_URL; }
368
369         void updateBaseURLForEmptyDocument();
370
371         void setResponseMIMEType(const String&);
372         const String& responseMIMEType() const;
373
374         bool containsPlugins() const;
375
376         void loadDone();
377         void finishedParsing();
378         void checkCompleted();
379         void scheduleCheckCompleted();
380         void scheduleCheckLoadComplete();
381
382         void clearRecordedFormValues();
383         void setFormAboutToBeSubmitted(PassRefPtr<HTMLFormElement> element);
384         void recordFormValue(const String& name, const String& value);
385
386         bool isComplete() const;
387
388         bool requestObject(RenderPart* frame, const String& url, const AtomicString& frameName,
389             const String& serviceType, const Vector<String>& paramNames, const Vector<String>& paramValues);
390
391         KURL completeURL(const String& url);
392
393         KURL originalRequestURL() const;
394
395         void cancelAndClear();
396
397         void setTitle(const String&);
398         
399         bool shouldTreatURLAsSameAsCurrent(const KURL&) const;
400
401         void commitProvisionalLoad(PassRefPtr<CachedPage>);
402
403         void goToItem(HistoryItem*, FrameLoadType);
404         void saveDocumentAndScrollState();
405         void saveScrollPositionAndViewStateToItem(HistoryItem*);
406
407         // FIXME: These accessors are here for a dwindling number of users in WebKit, WebFrame
408         // being the primary one.  After they're no longer needed there, they can be removed!
409         HistoryItem* currentHistoryItem();
410         void setCurrentHistoryItem(PassRefPtr<HistoryItem>);
411         void setProvisionalHistoryItem(PassRefPtr<HistoryItem>);
412
413         void continueLoadWithData(SharedBuffer*, const String& mimeType, const String& textEncoding, const KURL&); 
414
415         enum LocalLoadPolicy {
416           AllowLocalLoadsForAll,  // No restriction on local loads.
417           AllowLocalLoadsForLocalAndSubstituteData,
418           AllowLocalLoadsForLocalOnly,
419         };
420         static void setLocalLoadPolicy(LocalLoadPolicy);
421         static bool restrictAccessToLocal();
422         static bool allowSubstituteDataAccessToLocal();
423
424         static void registerURLSchemeAsLocal(const String&);
425         static bool shouldTreatURLAsLocal(const String&);
426         static bool shouldTreatURLSchemeAsLocal(const String&);
427
428         static void registerURLSchemeAsNoAccess(const String&);
429         static bool shouldTreatURLSchemeAsNoAccess(const String&);
430
431         bool committingFirstRealLoad() const { return !m_creatingInitialEmptyDocument && !m_committedFirstRealDocumentLoad; }
432
433         void iconLoadDecisionAvailable();
434
435         bool shouldAllowNavigation(Frame* targetFrame) const;
436         Frame* findFrameForNavigation(const AtomicString& name);
437
438         void startIconLoader();
439
440         void applyUserAgent(ResourceRequest& request);
441
442     private:
443         PassRefPtr<HistoryItem> createHistoryItem(bool useOriginal);
444         PassRefPtr<HistoryItem> createHistoryItemTree(Frame* targetFrame, bool clipAtTarget);
445
446         bool canCachePageContainingThisFrame();
447 #ifndef NDEBUG
448         void logCanCachePageDecision();
449         bool logCanCacheFrameDecision(int indentLevel);
450 #endif
451
452         void addBackForwardItemClippedAtTarget(bool doClip);
453         void restoreScrollPositionAndViewState();
454         void saveDocumentState();
455         void loadItem(HistoryItem*, FrameLoadType);
456         bool urlsMatchItem(HistoryItem*) const;
457         void invalidateCurrentItemCachedPage();
458         void recursiveGoToItem(HistoryItem*, HistoryItem*, FrameLoadType);
459         bool childFramesMatchItem(HistoryItem*) const;
460
461         void updateHistoryForBackForwardNavigation();
462         void updateHistoryForReload();
463         void updateHistoryForStandardLoad();
464         void updateHistoryForRedirectWithLockedBackForwardList();
465         void updateHistoryForClientRedirect();
466         void updateHistoryForCommit();
467         void updateHistoryForAnchorScroll();
468     
469         void redirectionTimerFired(Timer<FrameLoader>*);
470         void checkCompletedTimerFired(Timer<FrameLoader>*);
471         void checkLoadCompleteTimerFired(Timer<FrameLoader>*);
472         
473         void cancelRedirection(bool newLoadInProgress = false);
474
475         void started();
476
477         void completed();
478         void parentCompleted();
479
480         bool shouldUsePlugin(const KURL&, const String& mimeType, bool hasFallback, bool& useFallback);
481         bool loadPlugin(RenderPart*, const KURL&, const String& mimeType,
482         const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback);
483         
484         bool loadProvisionalItemFromCachedPage();
485         void cachePageForHistoryItem(HistoryItem*);
486
487         void receivedFirstData();
488
489         void updatePolicyBaseURL();
490         void setPolicyBaseURL(const KURL&);
491         
492         void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType loadType, bool isMainResource, bool cookiePolicyURLFromRequest);
493
494         // Also not cool.
495         void stopLoadingSubframes();
496
497         void clearProvisionalLoad();
498         void markLoadComplete();
499         void transitionToCommitted(PassRefPtr<CachedPage>);
500         void frameLoadCompleted();
501
502         void mainReceivedError(const ResourceError&, bool isComplete);
503
504         void setLoadType(FrameLoadType);
505
506         void checkNavigationPolicy(const ResourceRequest&, DocumentLoader*, PassRefPtr<FormState>,
507                                    NavigationPolicyDecisionFunction, void* argument);
508         void checkNewWindowPolicy(const NavigationAction&, const ResourceRequest&, 
509                                   PassRefPtr<FormState>, const String& frameName);
510
511         void continueAfterNavigationPolicy(PolicyAction);
512         void continueAfterNewWindowPolicy(PolicyAction);
513         void continueAfterContentPolicy(PolicyAction);
514         void continueLoadAfterWillSubmitForm(PolicyAction = PolicyUse);
515
516         static void callContinueLoadAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
517         void continueLoadAfterNavigationPolicy(const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
518         static void callContinueLoadAfterNewWindowPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
519         void continueLoadAfterNewWindowPolicy(const ResourceRequest&, PassRefPtr<FormState>, const String& frameName, bool shouldContinue);
520         static void callContinueFragmentScrollAfterNavigationPolicy(void*, const ResourceRequest&, PassRefPtr<FormState>, bool shouldContinue);
521         void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
522         bool shouldScrollToAnchor(bool isFormSubmission, FrameLoadType loadType, const KURL& url);
523         void addHistoryItemForFragmentScroll();
524
525         void stopPolicyCheck();
526
527         void closeDocument();
528         
529         void checkLoadCompleteForThisFrame();
530
531         void setDocumentLoader(DocumentLoader*);
532         void setPolicyDocumentLoader(DocumentLoader*);
533         void setProvisionalDocumentLoader(DocumentLoader*);
534
535         void setState(FrameState);
536
537         void closeOldDataSources();
538         void open(CachedPage&);
539         void open(CachedFrame&);
540
541         void updateHistoryAfterClientRedirect();
542
543         void clear(bool clearWindowProperties = true, bool clearScriptObjects = true);
544
545         bool shouldReloadToHandleUnreachableURL(DocumentLoader*);
546         void handleUnimplementablePolicy(const ResourceError&);
547
548         void scheduleRedirection(ScheduledRedirection*);
549         void startRedirectionTimer();
550         void stopRedirectionTimer();
551
552         void dispatchDidCommitLoad();
553         void dispatchAssignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&);
554         void dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest&, const ResourceResponse& redirectResponse);
555         void dispatchDidReceiveResponse(DocumentLoader*, unsigned long identifier, const ResourceResponse&);
556         void dispatchDidReceiveContentLength(DocumentLoader*, unsigned long identifier, int length);
557         void dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier);
558
559         static bool isLocationChange(const ScheduledRedirection&);
560
561         Frame* m_frame;
562         FrameLoaderClient* m_client;
563
564         FrameState m_state;
565         FrameLoadType m_loadType;
566
567         // Document loaders for the three phases of frame loading. Note that while 
568         // a new request is being loaded, the old document loader may still be referenced.
569         // E.g. while a new request is in the "policy" state, the old document loader may
570         // be consulted in particular as it makes sense to imply certain settings on the new loader.
571         RefPtr<DocumentLoader> m_documentLoader;
572         RefPtr<DocumentLoader> m_provisionalDocumentLoader;
573         RefPtr<DocumentLoader> m_policyDocumentLoader;
574
575         // This identifies the type of navigation action which prompted this load. Note 
576         // that WebKit conveys this value as the WebActionNavigationTypeKey value
577         // on navigation action delegate callbacks.
578         FrameLoadType m_policyLoadType;
579         PolicyCheck m_policyCheck;
580
581         bool m_delegateIsHandlingProvisionalLoadError;
582         bool m_delegateIsDecidingNavigationPolicy;
583         bool m_delegateIsHandlingUnimplementablePolicy;
584
585         bool m_firstLayoutDone;
586         bool m_quickRedirectComing;
587         bool m_sentRedirectNotification;
588         bool m_inStopAllLoaders;
589         bool m_navigationDuringLoad;
590
591         String m_outgoingReferrer;
592
593         OwnPtr<FormSubmission> m_deferredFormSubmission;
594
595         bool m_isExecutingJavaScriptFormAction;
596         bool m_isRunningScript;
597
598         String m_responseMIMEType;
599
600         bool m_didCallImplicitClose;
601         bool m_wasUnloadEventEmitted;
602         bool m_isComplete;
603         bool m_isLoadingMainResource;
604
605         KURL m_URL;
606         KURL m_workingURL;
607
608         OwnPtr<IconLoader> m_iconLoader;
609         bool m_mayLoadIconLater;
610
611         bool m_cancellingWithLoadInProgress;
612
613         OwnPtr<ScheduledRedirection> m_scheduledRedirection;
614
615         bool m_needsClear;
616         bool m_receivedData;
617
618         bool m_encodingWasChosenByUser;
619         String m_encoding;
620         RefPtr<TextResourceDecoder> m_decoder;
621
622         bool m_containsPlugIns;
623
624         RefPtr<HTMLFormElement> m_formAboutToBeSubmitted;
625         HashMap<String, String> m_formValuesAboutToBeSubmitted;
626         KURL m_submittedFormURL;
627     
628         Timer<FrameLoader> m_redirectionTimer;
629         Timer<FrameLoader> m_checkCompletedTimer;
630         Timer<FrameLoader> m_checkLoadCompleteTimer;
631
632         Frame* m_opener;
633         HashSet<Frame*> m_openedFrames;
634
635         bool m_openedByDOM;
636
637         bool m_creatingInitialEmptyDocument;
638         bool m_isDisplayingInitialEmptyDocument;
639         bool m_committedFirstRealDocumentLoad;
640
641         RefPtr<HistoryItem> m_currentHistoryItem;
642         RefPtr<HistoryItem> m_previousHistoryItem;
643         RefPtr<HistoryItem> m_provisionalHistoryItem;
644         
645         bool m_didPerformFirstNavigation;
646         
647 #ifndef NDEBUG
648         bool m_didDispatchDidCommitLoad;
649 #endif
650
651 #if ENABLE(WML)
652         bool m_forceReloadWmlDeck;
653 #endif
654     };
655
656 } // namespace WebCore
657
658 #endif // FrameLoader_h